Debian Codegraph @

Lib/test/test_complex.py

raw
1 import unittest
2 import sys
3 from test import support
4 from test.support.testcase import ComplexesAreIdenticalMixin
5 from test.support.numbers import (
6 VALID_UNDERSCORE_LITERALS,
7 INVALID_UNDERSCORE_LITERALS,
8 )
9
10 from random import random
11 from math import isnan, copysign
12 import operator
13
14 INF = float("inf")
15 NAN = float("nan")
16 DBL_MAX = sys.float_info.max
17 # These tests ensure that complex math does the right thing
18
19 ZERO_DIVISION = (
20 (1+1j, 0+0j),
21 (1+1j, 0.0),
22 (1+1j, 0),
23 (1.0, 0+0j),
24 (1, 0+0j),
25 )
26
27 class WithIndex:
28 def __init__(self, value):
29 self.value = value
30 def __index__(self):
31 return self.value
32
33 class WithFloat:
34 def __init__(self, value):
35 self.value = value
36 def __float__(self):
37 return self.value
38
39 class ComplexSubclass(complex):
40 pass
41
42 class OtherComplexSubclass(complex):
43 pass
44
45 class MyInt:
46 def __init__(self, value):
47 self.value = value
48
49 def __int__(self):
50 return self.value
51
52 class WithComplex:
53 def __init__(self, value):
54 self.value = value
55 def __complex__(self):
56 return self.value
57
58 class ComplexTest(ComplexesAreIdenticalMixin, unittest.TestCase):
59
60 def assertAlmostEqual(self, a, b):
61 if isinstance(a, complex):
62 if isinstance(b, complex):
63 unittest.TestCase.assertAlmostEqual(self, a.real, b.real)
64 unittest.TestCase.assertAlmostEqual(self, a.imag, b.imag)
65 else:
66 unittest.TestCase.assertAlmostEqual(self, a.real, b)
67 unittest.TestCase.assertAlmostEqual(self, a.imag, 0.)
68 else:
69 if isinstance(b, complex):
70 unittest.TestCase.assertAlmostEqual(self, a, b.real)
71 unittest.TestCase.assertAlmostEqual(self, 0., b.imag)
72 else:
73 unittest.TestCase.assertAlmostEqual(self, a, b)
74
75 def assertClose(self, x, y, eps=1e-9):
76 """Return true iff complexes x and y "are close"."""
77 # put the one with larger magnitude second
78 if abs(x) > abs(y):
79 x, y = y, x
80 if y == 0:
81 return abs(x) < eps
82 if x == 0:
83 return abs(y) < eps
84 # check that relative difference < eps
85 self.assertTrue(abs(x-y)/abs(y) < eps)
86
87 def check_div(self, x, y):
88 """Compute complex z=x*y, and check that z/x==y and z/y==x."""
89 z = x * y
90 if x:
91 self.assertClose(z / x, y)
92 if y:
93 self.assertClose(z / y, x)
94
95 def test_truediv(self):
96 simple_real = [float(i) for i in range(-5, 6)]
97 simple_complex = [complex(x, y) for x in simple_real for y in simple_real]
98 for x in simple_complex:
99 for y in simple_complex:
100 self.check_div(x, y)
101
102 # A naive complex division algorithm (such as in 2.0) is very prone to
103 # nonsense errors for these (overflows and underflows).
104 self.check_div(complex(1e200, 1e200), 1+0j)
105 self.check_div(complex(1e-200, 1e-200), 1+0j)
106
107 # Smith's algorithm has several sources of inaccuracy
108 # for components of the result. In examples below,
109 # it's cancellation of digits in computation of sum.
110 self.check_div(1e-09+1j, 1+1j)
111 self.check_div(8.289760544677449e-09+0.13257307440728516j,
112 0.9059966714925808+0.5054864708672686j)
113
114 # Just for fun.
115 for i in range(100):
116 x = complex(random(), random())
117 y = complex(random(), random())
118 self.check_div(x, y)
119 y = complex(1e10*y.real, y.imag)
120 self.check_div(x, y)
121
122 self.assertAlmostEqual(complex.__truediv__(2+0j, 1+1j), 1-1j)
123 self.assertRaises(TypeError, operator.truediv, 1j, None)
124 self.assertRaises(TypeError, operator.truediv, None, 1j)
125
126 for denom_real, denom_imag in [(0, NAN), (NAN, 0), (NAN, NAN)]:
127 z = complex(0, 0) / complex(denom_real, denom_imag)
128 self.assertTrue(isnan(z.real))
129 self.assertTrue(isnan(z.imag))
130 z = float(0) / complex(denom_real, denom_imag)
131 self.assertTrue(isnan(z.real))
132 self.assertTrue(isnan(z.imag))
133
134 self.assertComplexesAreIdentical(complex(INF, NAN) / 2,
135 complex(INF, NAN))
136
137 self.assertComplexesAreIdentical(complex(INF, 1)/(0.0+1j),
138 complex(NAN, -INF))
139
140 # test recover of infs if numerator has infs and denominator is finite
141 self.assertComplexesAreIdentical(complex(INF, -INF)/(1+0j),
142 complex(INF, -INF))
143 self.assertComplexesAreIdentical(complex(INF, INF)/(0.0+1j),
144 complex(INF, -INF))
145 self.assertComplexesAreIdentical(complex(NAN, INF)/complex(2**1000, 2**-1000),
146 complex(INF, INF))
147 self.assertComplexesAreIdentical(complex(INF, NAN)/complex(2**1000, 2**-1000),
148 complex(INF, -INF))
149
150 # test recover of zeros if denominator is infinite
151 self.assertComplexesAreIdentical((1+1j)/complex(INF, INF), (0.0+0j))
152 self.assertComplexesAreIdentical((1+1j)/complex(INF, -INF), (0.0+0j))
153 self.assertComplexesAreIdentical((1+1j)/complex(-INF, INF),
154 complex(0.0, -0.0))
155 self.assertComplexesAreIdentical((1+1j)/complex(-INF, -INF),
156 complex(-0.0, 0))
157 self.assertComplexesAreIdentical((INF+1j)/complex(INF, INF),
158 complex(NAN, NAN))
159 self.assertComplexesAreIdentical(complex(1, INF)/complex(INF, INF),
160 complex(NAN, NAN))
161 self.assertComplexesAreIdentical(complex(INF, 1)/complex(1, INF),
162 complex(NAN, NAN))
163
164 # mixed types
165 self.assertEqual((1+1j)/float(2), 0.5+0.5j)
166 self.assertEqual(float(1)/(1+2j), 0.2-0.4j)
167 self.assertEqual(float(1)/(-1+2j), -0.2-0.4j)
168 self.assertEqual(float(1)/(1-2j), 0.2+0.4j)
169 self.assertEqual(float(1)/(2+1j), 0.4-0.2j)
170 self.assertEqual(float(1)/(-2+1j), -0.4-0.2j)
171 self.assertEqual(float(1)/(2-1j), 0.4+0.2j)
172
173 self.assertComplexesAreIdentical(INF/(1+0j),
174 complex(INF, NAN))
175 self.assertComplexesAreIdentical(INF/(0.0+1j),
176 complex(NAN, -INF))
177 self.assertComplexesAreIdentical(INF/complex(2**1000, 2**-1000),
178 complex(INF, NAN))
179 self.assertComplexesAreIdentical(INF/complex(NAN, NAN),
180 complex(NAN, NAN))
181
182 self.assertComplexesAreIdentical(float(1)/complex(INF, INF), (0.0-0j))
183 self.assertComplexesAreIdentical(float(1)/complex(INF, -INF), (0.0+0j))
184 self.assertComplexesAreIdentical(float(1)/complex(-INF, INF),
185 complex(-0.0, -0.0))
186 self.assertComplexesAreIdentical(float(1)/complex(-INF, -INF),
187 complex(-0.0, 0))
188 self.assertComplexesAreIdentical(float(1)/complex(INF, NAN),
189 complex(0.0, -0.0))
190 self.assertComplexesAreIdentical(float(1)/complex(-INF, NAN),
191 complex(-0.0, -0.0))
192 self.assertComplexesAreIdentical(float(1)/complex(NAN, INF),
193 complex(0.0, -0.0))
194 self.assertComplexesAreIdentical(float(INF)/complex(NAN, INF),
195 complex(NAN, NAN))
196
197 def test_truediv_zero_division(self):
198 for a, b in ZERO_DIVISION:
199 with self.assertRaises(ZeroDivisionError):
200 a / b
201
202 def test_floordiv(self):
203 with self.assertRaises(TypeError):
204 (1+1j) // (1+0j)
205 with self.assertRaises(TypeError):
206 (1+1j) // 1.0
207 with self.assertRaises(TypeError):
208 (1+1j) // 1
209 with self.assertRaises(TypeError):
210 1.0 // (1+0j)
211 with self.assertRaises(TypeError):
212 1 // (1+0j)
213
214 def test_floordiv_zero_division(self):
215 for a, b in ZERO_DIVISION:
216 with self.assertRaises(TypeError):
217 a // b
218
219 def test_richcompare(self):
220 self.assertIs(complex.__eq__(1+1j, 1<<10000), False)
221 self.assertIs(complex.__lt__(1+1j, None), NotImplemented)
222 self.assertIs(complex.__eq__(1+1j, None), NotImplemented)
223 self.assertIs(complex.__eq__(1+1j, 1+1j), True)
224 self.assertIs(complex.__eq__(1+1j, 2+2j), False)
225 self.assertIs(complex.__ne__(1+1j, 1+1j), False)
226 self.assertIs(complex.__ne__(1+1j, 2+2j), True)
227 for i in range(1, 100):
228 f = i / 100.0
229 self.assertIs(complex.__eq__(f+0j, f), True)
230 self.assertIs(complex.__ne__(f+0j, f), False)
231 self.assertIs(complex.__eq__(complex(f, f), f), False)
232 self.assertIs(complex.__ne__(complex(f, f), f), True)
233 self.assertIs(complex.__lt__(1+1j, 2+2j), NotImplemented)
234 self.assertIs(complex.__le__(1+1j, 2+2j), NotImplemented)
235 self.assertIs(complex.__gt__(1+1j, 2+2j), NotImplemented)
236 self.assertIs(complex.__ge__(1+1j, 2+2j), NotImplemented)
237 self.assertRaises(TypeError, operator.lt, 1+1j, 2+2j)
238 self.assertRaises(TypeError, operator.le, 1+1j, 2+2j)
239 self.assertRaises(TypeError, operator.gt, 1+1j, 2+2j)
240 self.assertRaises(TypeError, operator.ge, 1+1j, 2+2j)
241 self.assertIs(operator.eq(1+1j, 1+1j), True)
242 self.assertIs(operator.eq(1+1j, 2+2j), False)
243 self.assertIs(operator.ne(1+1j, 1+1j), False)
244 self.assertIs(operator.ne(1+1j, 2+2j), True)
245 self.assertIs(operator.eq(1+1j, 2.0), False)
246
247 def test_richcompare_boundaries(self):
248 def check(n, deltas, is_equal, imag = 0.0):
249 for delta in deltas:
250 i = n + delta
251 z = complex(i, imag)
252 self.assertIs(complex.__eq__(z, i), is_equal(delta))
253 self.assertIs(complex.__ne__(z, i), not is_equal(delta))
254 # For IEEE-754 doubles the following should hold:
255 # x in [2 ** (52 + i), 2 ** (53 + i + 1)] -> x mod 2 ** i == 0
256 # where the interval is representable, of course.
257 for i in range(1, 10):
258 pow = 52 + i
259 mult = 2 ** i
260 check(2 ** pow, range(1, 101), lambda delta: delta % mult == 0)
261 check(2 ** pow, range(1, 101), lambda delta: False, float(i))
262 check(2 ** 53, range(-100, 0), lambda delta: True)
263
264 def test_add(self):
265 self.assertEqual(1j + int(+1), complex(+1, 1))
266 self.assertEqual(1j + int(-1), complex(-1, 1))
267 self.assertComplexesAreIdentical(complex(-0.0, -0.0) + (-0.0),
268 complex(-0.0, -0.0))
269 self.assertComplexesAreIdentical((-0.0) + complex(-0.0, -0.0),
270 complex(-0.0, -0.0))
271 self.assertRaises(OverflowError, operator.add, 1j, 10**1000)
272 self.assertRaises(TypeError, operator.add, 1j, None)
273 self.assertRaises(TypeError, operator.add, None, 1j)
274
275 def test_sub(self):
276 self.assertEqual(1j - int(+1), complex(-1, 1))
277 self.assertEqual(1j - int(-1), complex(1, 1))
278 self.assertComplexesAreIdentical(complex(-0.0, -0.0) - 0.0,
279 complex(-0.0, -0.0))
280 self.assertComplexesAreIdentical(-0.0 - complex(0.0, 0.0),
281 complex(-0.0, -0.0))
282 self.assertComplexesAreIdentical(complex(1, 2) - complex(2, 1),
283 complex(-1, 1))
284 self.assertComplexesAreIdentical(complex(2, 1) - complex(1, 2),
285 complex(1, -1))
286 self.assertRaises(OverflowError, operator.sub, 1j, 10**1000)
287 self.assertRaises(TypeError, operator.sub, 1j, None)
288 self.assertRaises(TypeError, operator.sub, None, 1j)
289
290 def test_mul(self):
291 self.assertEqual(1j * int(20), complex(0, 20))
292 self.assertEqual(1j * int(-1), complex(0, -1))
293 for c, r in [(2, complex(INF, 2)), (INF, complex(INF, INF)),
294 (0, complex(NAN, 0)), (-0.0, complex(NAN, -0.0)),
295 (NAN, complex(NAN, NAN))]:
296 with self.subTest(c=c, r=r):
297 self.assertComplexesAreIdentical(complex(INF, 1) * c, r)
298 self.assertComplexesAreIdentical(c * complex(INF, 1), r)
299 self.assertRaises(OverflowError, operator.mul, 1j, 10**1000)
300 self.assertRaises(TypeError, operator.mul, 1j, None)
301 self.assertRaises(TypeError, operator.mul, None, 1j)
302
303 for z, w, r in [(1e300+1j, complex(INF, INF), complex(NAN, INF)),
304 (1e300+1j, complex(NAN, INF), complex(-INF, INF)),
305 (1e300+1j, complex(INF, NAN), complex(INF, INF)),
306 (complex(INF, 1), complex(NAN, INF), complex(NAN, INF)),
307 (complex(INF, 1), complex(INF, NAN), complex(INF, NAN)),
308 (complex(NAN, 1), complex(1, INF), complex(-INF, NAN)),
309 (complex(1, NAN), complex(1, INF), complex(NAN, INF)),
310 (complex(1e200, NAN), complex(1e200, NAN), complex(INF, NAN)),
311 (complex(1e200, NAN), complex(NAN, 1e200), complex(NAN, INF)),
312 (complex(NAN, 1e200), complex(1e200, NAN), complex(NAN, INF)),
313 (complex(NAN, 1e200), complex(NAN, 1e200), complex(-INF, NAN)),
314 (complex(NAN, NAN), complex(NAN, NAN), complex(NAN, NAN))]:
315 with self.subTest(z=z, w=w, r=r):
316 self.assertComplexesAreIdentical(z * w, r)
317 self.assertComplexesAreIdentical(w * z, r)
318
319 def test_mod(self):
320 # % is no longer supported on complex numbers
321 with self.assertRaises(TypeError):
322 (1+1j) % (1+0j)
323 with self.assertRaises(TypeError):
324 (1+1j) % 1.0
325 with self.assertRaises(TypeError):
326 (1+1j) % 1
327 with self.assertRaises(TypeError):
328 1.0 % (1+0j)
329 with self.assertRaises(TypeError):
330 1 % (1+0j)
331
332 def test_mod_zero_division(self):
333 for a, b in ZERO_DIVISION:
334 with self.assertRaises(TypeError):
335 a % b
336
337 def test_divmod(self):
338 self.assertRaises(TypeError, divmod, 1+1j, 1+0j)
339 self.assertRaises(TypeError, divmod, 1+1j, 1.0)
340 self.assertRaises(TypeError, divmod, 1+1j, 1)
341 self.assertRaises(TypeError, divmod, 1.0, 1+0j)
342 self.assertRaises(TypeError, divmod, 1, 1+0j)
343
344 def test_divmod_zero_division(self):
345 for a, b in ZERO_DIVISION:
346 self.assertRaises(TypeError, divmod, a, b)
347
348 def test_pow(self):
349 self.assertAlmostEqual(pow(1+1j, 0+0j), 1.0)
350 self.assertAlmostEqual(pow(0+0j, 2+0j), 0.0)
351 self.assertEqual(pow(0+0j, 2000+0j), 0.0)
352 self.assertEqual(pow(0, 0+0j), 1.0)
353 self.assertEqual(pow(-1, 0+0j), 1.0)
354 self.assertRaises(ZeroDivisionError, pow, 0+0j, 1j)
355 self.assertRaises(ZeroDivisionError, pow, 0+0j, -1000)
356 self.assertAlmostEqual(pow(1j, -1), 1/1j)
357 self.assertAlmostEqual(pow(1j, 200), 1)
358 self.assertRaises(ValueError, pow, 1+1j, 1+1j, 1+1j)
359 self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j)
360 self.assertRaises(OverflowError, pow, 1e200+1j, 5)
361 self.assertRaises(TypeError, pow, 1j, None)
362 self.assertRaises(TypeError, pow, None, 1j)
363 self.assertAlmostEqual(pow(1j, 0.5), 0.7071067811865476+0.7071067811865475j)
364
365 a = 3.33+4.43j
366 self.assertEqual(a ** 0j, 1)
367 self.assertEqual(a ** 0.+0.j, 1)
368
369 self.assertEqual(3j ** 0j, 1)
370 self.assertEqual(3j ** 0, 1)
371
372 try:
373 0j ** a
374 except ZeroDivisionError:
375 pass
376 else:
377 self.fail("should fail 0.0 to negative or complex power")
378
379 try:
380 0j ** (3-2j)
381 except ZeroDivisionError:
382 pass
383 else:
384 self.fail("should fail 0.0 to negative or complex power")
385
386 # The following is used to exercise certain code paths
387 self.assertEqual(a ** 105, a ** 105)
388 self.assertEqual(a ** -105, a ** -105)
389 self.assertEqual(a ** -30, a ** -30)
390
391 self.assertEqual(0.0j ** 0, 1)
392
393 b = 5.1+2.3j
394 self.assertRaises(ValueError, pow, a, b, 0)
395
396 # Check some boundary conditions; some of these used to invoke
397 # undefined behaviour (https://bugs.python.org/issue44698). We're
398 # not actually checking the results of these operations, just making
399 # sure they don't crash (for example when using clang's
400 # UndefinedBehaviourSanitizer).
401 values = (sys.maxsize, sys.maxsize+1, sys.maxsize-1,
402 -sys.maxsize, -sys.maxsize+1, -sys.maxsize+1)
403 for real in values:
404 for imag in values:
405 with self.subTest(real=real, imag=imag):
406 c = complex(real, imag)
407 try:
408 c ** real
409 except OverflowError:
410 pass
411 try:
412 c ** c
413 except OverflowError:
414 pass
415
416 # gh-113841: possible undefined division by 0 in _Py_c_pow()
417 x, y = 9j, 33j**3
418 with self.assertRaises(OverflowError):
419 x**y
420
421 def test_pow_with_small_integer_exponents(self):
422 # Check that small integer exponents are handled identically
423 # regardless of their type.
424 values = [
425 complex(5.0, 12.0),
426 complex(5.0e100, 12.0e100),
427 complex(-4.0, INF),
428 complex(INF, 0.0),
429 ]
430 exponents = [-19, -5, -3, -2, -1, 0, 1, 2, 3, 5, 19]
431 for value in values:
432 for exponent in exponents:
433 with self.subTest(value=value, exponent=exponent):
434 try:
435 int_pow = value**exponent
436 except OverflowError:
437 int_pow = "overflow"
438 try:
439 float_pow = value**float(exponent)
440 except OverflowError:
441 float_pow = "overflow"
442 try:
443 complex_pow = value**complex(exponent)
444 except OverflowError:
445 complex_pow = "overflow"
446 self.assertEqual(str(float_pow), str(int_pow))
447 self.assertEqual(str(complex_pow), str(int_pow))
448
449 def test_boolcontext(self):
450 for i in range(100):
451 self.assertTrue(complex(random() + 1e-6, random() + 1e-6))
452 self.assertTrue(not complex(0.0, 0.0))
453 self.assertTrue(1j)
454
455 def test_conjugate(self):
456 self.assertEqual(complex(5.3, 9.8).conjugate(), 5.3-9.8j)
457
458 def test_constructor(self):
459 def check(z, x, y):
460 self.assertIs(type(z), complex)
461 self.assertFloatsAreIdentical(z.real, x)
462 self.assertFloatsAreIdentical(z.imag, y)
463
464 check(complex(), 0.0, 0.0)
465 check(complex(10), 10.0, 0.0)
466 check(complex(4.25), 4.25, 0.0)
467 check(complex(4.25+0j), 4.25, 0.0)
468 check(complex(4.25+0.5j), 4.25, 0.5)
469 check(complex(ComplexSubclass(4.25+0.5j)), 4.25, 0.5)
470 check(complex(WithComplex(4.25+0.5j)), 4.25, 0.5)
471
472 check(complex(1, 10), 1.0, 10.0)
473 check(complex(1, 10.0), 1.0, 10.0)
474 check(complex(1, 4.25), 1.0, 4.25)
475 check(complex(1.0, 10), 1.0, 10.0)
476 check(complex(4.25, 10), 4.25, 10.0)
477 check(complex(1.0, 10.0), 1.0, 10.0)
478 check(complex(4.25, 0.5), 4.25, 0.5)
479
480 with self.assertWarnsRegex(DeprecationWarning,
481 "argument 'real' must be a real number, not complex"):
482 check(complex(4.25+0j, 0), 4.25, 0.0)
483 with self.assertWarnsRegex(DeprecationWarning,
484 "argument 'real' must be a real number, not .*ComplexSubclass"):
485 check(complex(ComplexSubclass(4.25+0j), 0), 4.25, 0.0)
486 with self.assertWarnsRegex(DeprecationWarning,
487 "argument 'real' must be a real number, not .*WithComplex"):
488 check(complex(WithComplex(4.25+0j), 0), 4.25, 0.0)
489 with self.assertWarnsRegex(DeprecationWarning,
490 "argument 'real' must be a real number, not complex"):
491 check(complex(4.25j, 0), 0.0, 4.25)
492 with self.assertWarnsRegex(DeprecationWarning,
493 "argument 'real' must be a real number, not complex"):
494 check(complex(0j, 4.25), 0.0, 4.25)
495 with self.assertWarnsRegex(DeprecationWarning,
496 "argument 'imag' must be a real number, not complex"):
497 check(complex(0, 4.25+0j), 0.0, 4.25)
498 with self.assertWarnsRegex(DeprecationWarning,
499 "argument 'imag' must be a real number, not .*ComplexSubclass"):
500 check(complex(0, ComplexSubclass(4.25+0j)), 0.0, 4.25)
501 with self.assertRaisesRegex(TypeError,
502 "argument 'imag' must be a real number, not .*WithComplex"):
503 complex(0, WithComplex(4.25+0j))
504 with self.assertWarnsRegex(DeprecationWarning,
505 "argument 'imag' must be a real number, not complex"):
506 check(complex(0.0, 4.25j), -4.25, 0.0)
507 with self.assertWarnsRegex(DeprecationWarning,
508 "argument 'real' must be a real number, not complex"):
509 check(complex(4.25+0j, 0j), 4.25, 0.0)
510 with self.assertWarnsRegex(DeprecationWarning,
511 "argument 'real' must be a real number, not complex"):
512 check(complex(4.25j, 0j), 0.0, 4.25)
513 with self.assertWarnsRegex(DeprecationWarning,
514 "argument 'real' must be a real number, not complex"):
515 check(complex(0j, 4.25+0j), 0.0, 4.25)
516 with self.assertWarnsRegex(DeprecationWarning,
517 "argument 'real' must be a real number, not complex"):
518 check(complex(0j, 4.25j), -4.25, 0.0)
519
520 check(complex(real=4.25), 4.25, 0.0)
521 with self.assertWarnsRegex(DeprecationWarning,
522 "argument 'real' must be a real number, not complex"):
523 check(complex(real=4.25+0j), 4.25, 0.0)
524 with self.assertWarnsRegex(DeprecationWarning,
525 "argument 'real' must be a real number, not complex"):
526 check(complex(real=4.25+1.5j), 4.25, 1.5)
527 check(complex(imag=1.5), 0.0, 1.5)
528 check(complex(real=4.25, imag=1.5), 4.25, 1.5)
529 check(complex(4.25, imag=1.5), 4.25, 1.5)
530
531 # check that the sign of a zero in the real or imaginary part
532 # is preserved when constructing from two floats.
533 for x in 1.0, -1.0:
534 for y in 0.0, -0.0:
535 check(complex(x, y), x, y)
536 check(complex(y, x), y, x)
537
538 c = complex(4.25, 1.5)
539 self.assertIs(complex(c), c)
540 c2 = ComplexSubclass(c)
541 self.assertEqual(c2, c)
542 self.assertIs(type(c2), ComplexSubclass)
543 del c, c2
544
545 self.assertRaisesRegex(TypeError,
546 "argument must be a string or a number, not dict",
547 complex, {})
548 self.assertRaisesRegex(TypeError,
549 "argument must be a string or a number, not NoneType",
550 complex, None)
551 self.assertRaisesRegex(TypeError,
552 "argument 'real' must be a real number, not dict",
553 complex, {1:2}, 0)
554 self.assertRaisesRegex(TypeError,
555 "argument 'real' must be a real number, not str",
556 complex, '1', 0)
557 self.assertRaisesRegex(TypeError,
558 "argument 'imag' must be a real number, not dict",
559 complex, 0, {1:2})
560 self.assertRaisesRegex(TypeError,
561 "argument 'imag' must be a real number, not str",
562 complex, 0, '1')
563
564 self.assertRaises(TypeError, complex, WithComplex(1.5))
565 self.assertRaises(TypeError, complex, WithComplex(1))
566 self.assertRaises(TypeError, complex, WithComplex(None))
567 self.assertRaises(TypeError, complex, WithComplex(4.25+0j), object())
568 self.assertRaises(TypeError, complex, WithComplex(1.5), object())
569 self.assertRaises(TypeError, complex, WithComplex(1), object())
570 self.assertRaises(TypeError, complex, WithComplex(None), object())
571
572 class EvilExc(Exception):
573 pass
574
575 class evilcomplex:
576 def __complex__(self):
577 raise EvilExc
578
579 self.assertRaises(EvilExc, complex, evilcomplex())
580
581 check(complex(WithFloat(4.25)), 4.25, 0.0)
582 check(complex(WithFloat(4.25), 1.5), 4.25, 1.5)
583 check(complex(1.5, WithFloat(4.25)), 1.5, 4.25)
584 self.assertRaises(TypeError, complex, WithFloat(42))
585 self.assertRaises(TypeError, complex, WithFloat(42), 1.5)
586 self.assertRaises(TypeError, complex, 1.5, WithFloat(42))
587 self.assertRaises(TypeError, complex, WithFloat(None))
588 self.assertRaises(TypeError, complex, WithFloat(None), 1.5)
589 self.assertRaises(TypeError, complex, 1.5, WithFloat(None))
590
591 check(complex(WithIndex(42)), 42.0, 0.0)
592 check(complex(WithIndex(42), 1.5), 42.0, 1.5)
593 check(complex(1.5, WithIndex(42)), 1.5, 42.0)
594 self.assertRaises(OverflowError, complex, WithIndex(2**2000))
595 self.assertRaises(OverflowError, complex, WithIndex(2**2000), 1.5)
596 self.assertRaises(OverflowError, complex, 1.5, WithIndex(2**2000))
597 self.assertRaises(TypeError, complex, WithIndex(None))
598 self.assertRaises(TypeError, complex, WithIndex(None), 1.5)
599 self.assertRaises(TypeError, complex, 1.5, WithIndex(None))
600
601 class MyInt:
602 def __int__(self):
603 return 42
604
605 self.assertRaises(TypeError, complex, MyInt())
606 self.assertRaises(TypeError, complex, MyInt(), 1.5)
607 self.assertRaises(TypeError, complex, 1.5, MyInt())
608
609 class complex0(complex):
610 """Test usage of __complex__() when inheriting from 'complex'"""
611 def __complex__(self):
612 return 42j
613
614 class complex1(complex):
615 """Test usage of __complex__() with a __new__() method"""
616 def __new__(self, value=0j):
617 return complex.__new__(self, 2*value)
618 def __complex__(self):
619 return self
620
621 class complex2(complex):
622 """Make sure that __complex__() calls fail if anything other than a
623 complex is returned"""
624 def __complex__(self):
625 return None
626
627 check(complex(complex0(1j)), 0.0, 42.0)
628 with self.assertWarns(DeprecationWarning):
629 check(complex(complex1(1j)), 0.0, 2.0)
630 self.assertRaises(TypeError, complex, complex2(1j))
631
632 def test___complex__(self):
633 z = 3 + 4j
634 self.assertEqual(z.__complex__(), z)
635 self.assertEqual(type(z.__complex__()), complex)
636
637 z = ComplexSubclass(3 + 4j)
638 self.assertEqual(z.__complex__(), 3 + 4j)
639 self.assertEqual(type(z.__complex__()), complex)
640
641 @support.requires_IEEE_754
642 def test_constructor_special_numbers(self):
643 for x in 0.0, -0.0, INF, -INF, NAN:
644 for y in 0.0, -0.0, INF, -INF, NAN:
645 with self.subTest(x=x, y=y):
646 z = complex(x, y)
647 self.assertFloatsAreIdentical(z.real, x)
648 self.assertFloatsAreIdentical(z.imag, y)
649 z = ComplexSubclass(x, y)
650 self.assertIs(type(z), ComplexSubclass)
651 self.assertFloatsAreIdentical(z.real, x)
652 self.assertFloatsAreIdentical(z.imag, y)
653 z = complex(ComplexSubclass(x, y))
654 self.assertIs(type(z), complex)
655 self.assertFloatsAreIdentical(z.real, x)
656 self.assertFloatsAreIdentical(z.imag, y)
657 z = ComplexSubclass(complex(x, y))
658 self.assertIs(type(z), ComplexSubclass)
659 self.assertFloatsAreIdentical(z.real, x)
660 self.assertFloatsAreIdentical(z.imag, y)
661
662 def test_constructor_from_string(self):
663 def check(z, x, y):
664 self.assertIs(type(z), complex)
665 self.assertFloatsAreIdentical(z.real, x)
666 self.assertFloatsAreIdentical(z.imag, y)
667
668 check(complex("1"), 1.0, 0.0)
669 check(complex("1j"), 0.0, 1.0)
670 check(complex("-1"), -1.0, 0.0)
671 check(complex("+1"), 1.0, 0.0)
672 check(complex("1+2j"), 1.0, 2.0)
673 check(complex("(1+2j)"), 1.0, 2.0)
674 check(complex("(1.5+4.25j)"), 1.5, 4.25)
675 check(complex("4.25+1J"), 4.25, 1.0)
676 check(complex(" ( +4.25-6J )"), 4.25, -6.0)
677 check(complex(" ( +4.25-J )"), 4.25, -1.0)
678 check(complex(" ( +4.25+j )"), 4.25, 1.0)
679 check(complex("J"), 0.0, 1.0)
680 check(complex("( j )"), 0.0, 1.0)
681 check(complex("+J"), 0.0, 1.0)
682 check(complex("( -j)"), 0.0, -1.0)
683 check(complex('1-1j'), 1.0, -1.0)
684 check(complex('1J'), 0.0, 1.0)
685
686 check(complex('1e-500'), 0.0, 0.0)
687 check(complex('-1e-500j'), 0.0, -0.0)
688 check(complex('1e-500+1e-500j'), 0.0, 0.0)
689 check(complex('-1e-500+1e-500j'), -0.0, 0.0)
690 check(complex('1e-500-1e-500j'), 0.0, -0.0)
691 check(complex('-1e-500-1e-500j'), -0.0, -0.0)
692
693 # SF bug 543840: complex(string) accepts strings with \0
694 # Fixed in 2.3.
695 self.assertRaises(ValueError, complex, '1+1j\0j')
696 self.assertRaises(ValueError, complex, "")
697 self.assertRaises(ValueError, complex, "\0")
698 self.assertRaises(ValueError, complex, "3\09")
699 self.assertRaises(ValueError, complex, "1+")
700 self.assertRaises(ValueError, complex, "1+1j+1j")
701 self.assertRaises(ValueError, complex, "--")
702 self.assertRaises(ValueError, complex, "(1+2j")
703 self.assertRaises(ValueError, complex, "1+2j)")
704 self.assertRaises(ValueError, complex, "1+(2j)")
705 self.assertRaises(ValueError, complex, "(1+2j)123")
706 self.assertRaises(ValueError, complex, "x")
707 self.assertRaises(ValueError, complex, "1j+2")
708 self.assertRaises(ValueError, complex, "1e1ej")
709 self.assertRaises(ValueError, complex, "1e++1ej")
710 self.assertRaises(ValueError, complex, ")1+2j(")
711 # the following three are accepted by Python 2.6
712 self.assertRaises(ValueError, complex, "1..1j")
713 self.assertRaises(ValueError, complex, "1.11.1j")
714 self.assertRaises(ValueError, complex, "1e1.1j")
715
716 # check that complex accepts long unicode strings
717 self.assertIs(type(complex("1"*500)), complex)
718 # check whitespace processing
719 self.assertEqual(complex('\N{EM SPACE}(\N{EN SPACE}1+1j ) '), 1+1j)
720 # Invalid unicode string
721 # See bpo-34087
722 self.assertRaises(ValueError, complex, '\u3053\u3093\u306b\u3061\u306f')
723
724 def test_constructor_negative_nans_from_string(self):
725 self.assertEqual(copysign(1., complex("-nan").real), -1.)
726 self.assertEqual(copysign(1., complex("-nanj").imag), -1.)
727 self.assertEqual(copysign(1., complex("-nan-nanj").real), -1.)
728 self.assertEqual(copysign(1., complex("-nan-nanj").imag), -1.)
729
730 def test_underscores(self):
731 # check underscores
732 for lit in VALID_UNDERSCORE_LITERALS:
733 if not any(ch in lit for ch in 'xXoObB'):
734 self.assertEqual(complex(lit), eval(lit))
735 self.assertEqual(complex(lit), complex(lit.replace('_', '')))
736 for lit in INVALID_UNDERSCORE_LITERALS:
737 if lit in ('0_7', '09_99'): # octals are not recognized here
738 continue
739 if not any(ch in lit for ch in 'xXoObB'):
740 self.assertRaises(ValueError, complex, lit)
741
742 def test_from_number(self, cls=complex):
743 def eq(actual, expected):
744 self.assertEqual(actual, expected)
745 self.assertIs(type(actual), cls)
746
747 eq(cls.from_number(3.14), 3.14+0j)
748 eq(cls.from_number(3.14j), 3.14j)
749 eq(cls.from_number(314), 314.0+0j)
750 eq(cls.from_number(OtherComplexSubclass(3.14, 2.72)), 3.14+2.72j)
751 eq(cls.from_number(WithComplex(3.14+2.72j)), 3.14+2.72j)
752 eq(cls.from_number(WithFloat(3.14)), 3.14+0j)
753 eq(cls.from_number(WithIndex(314)), 314.0+0j)
754
755 cNAN = complex(NAN, NAN)
756 x = cls.from_number(cNAN)
757 self.assertTrue(x != x)
758 self.assertIs(type(x), cls)
759 if cls is complex:
760 self.assertIs(cls.from_number(cNAN), cNAN)
761
762 self.assertRaises(TypeError, cls.from_number, '3.14')
763 self.assertRaises(TypeError, cls.from_number, b'3.14')
764 self.assertRaises(TypeError, cls.from_number, MyInt(314))
765 self.assertRaises(TypeError, cls.from_number, {})
766 self.assertRaises(TypeError, cls.from_number)
767
768 def test_from_number_subclass(self):
769 self.test_from_number(ComplexSubclass)
770
771 def test_hash(self):
772 for x in range(-30, 30):
773 self.assertEqual(hash(x), hash(complex(x, 0)))
774 x /= 3.0 # now check against floating-point
775 self.assertEqual(hash(x), hash(complex(x, 0.)))
776
777 self.assertNotEqual(hash(2000005 - 1j), -1)
778
779 def test_abs(self):
780 nums = [complex(x/3., y/7.) for x in range(-9,9) for y in range(-9,9)]
781 for num in nums:
782 self.assertAlmostEqual((num.real**2 + num.imag**2) ** 0.5, abs(num))
783
784 self.assertRaises(OverflowError, abs, complex(DBL_MAX, DBL_MAX))
785
786 def test_repr_str(self):
787 def test(v, expected, test_fn=self.assertEqual):
788 test_fn(repr(v), expected)
789 test_fn(str(v), expected)
790
791 test(1+6j, '(1+6j)')
792 test(1-6j, '(1-6j)')
793
794 test(-(1+0j), '(-1+-0j)', test_fn=self.assertNotEqual)
795
796 test(complex(1., INF), "(1+infj)")
797 test(complex(1., -INF), "(1-infj)")
798 test(complex(INF, 1), "(inf+1j)")
799 test(complex(-INF, INF), "(-inf+infj)")
800 test(complex(NAN, 1), "(nan+1j)")
801 test(complex(1, NAN), "(1+nanj)")
802 test(complex(NAN, NAN), "(nan+nanj)")
803 test(complex(-NAN, -NAN), "(nan+nanj)")
804
805 test(complex(0, INF), "infj")
806 test(complex(0, -INF), "-infj")
807 test(complex(0, NAN), "nanj")
808
809 self.assertEqual(1-6j,complex(repr(1-6j)))
810 self.assertEqual(1+6j,complex(repr(1+6j)))
811 self.assertEqual(-6j,complex(repr(-6j)))
812 self.assertEqual(6j,complex(repr(6j)))
813
814 @support.requires_IEEE_754
815 def test_negative_zero_repr_str(self):
816 def test(v, expected, test_fn=self.assertEqual):
817 test_fn(repr(v), expected)
818 test_fn(str(v), expected)
819
820 test(complex(0., 1.), "1j")
821 test(complex(-0., 1.), "(-0+1j)")
822 test(complex(0., -1.), "-1j")
823 test(complex(-0., -1.), "(-0-1j)")
824
825 test(complex(0., 0.), "0j")
826 test(complex(0., -0.), "-0j")
827 test(complex(-0., 0.), "(-0+0j)")
828 test(complex(-0., -0.), "(-0-0j)")
829
830 def test_pos(self):
831 self.assertEqual(+(1+6j), 1+6j)
832 self.assertEqual(+ComplexSubclass(1, 6), 1+6j)
833 self.assertIs(type(+ComplexSubclass(1, 6)), complex)
834
835 def test_neg(self):
836 self.assertEqual(-(1+6j), -1-6j)
837
838 def test_getnewargs(self):
839 self.assertEqual((1+2j).__getnewargs__(), (1.0, 2.0))
840 self.assertEqual((1-2j).__getnewargs__(), (1.0, -2.0))
841 self.assertEqual((2j).__getnewargs__(), (0.0, 2.0))
842 self.assertEqual((-0j).__getnewargs__(), (0.0, -0.0))
843 self.assertEqual(complex(0, INF).__getnewargs__(), (0.0, INF))
844 self.assertEqual(complex(INF, 0).__getnewargs__(), (INF, 0.0))
845
846 @support.requires_IEEE_754
847 def test_plus_minus_0j(self):
848 # test that -0j and 0j literals are not identified
849 z1, z2 = 0j, -0j
850 self.assertFloatsAreIdentical(z1.imag, 0.0)
851 self.assertFloatsAreIdentical(z2.imag, -0.0)
852
853 @support.requires_IEEE_754
854 def test_negated_imaginary_literal(self):
855 z0 = -0j
856 z1 = -7j
857 z2 = -1e1000j
858 # Note: In versions of Python < 3.2, a negated imaginary literal
859 # accidentally ended up with real part 0.0 instead of -0.0, thanks to a
860 # modification during CST -> AST translation (see issue #9011). That's
861 # fixed in Python 3.2.
862 self.assertFloatsAreIdentical(z0.real, -0.0)
863 self.assertFloatsAreIdentical(z0.imag, -0.0)
864 self.assertFloatsAreIdentical(z1.real, -0.0)
865 self.assertFloatsAreIdentical(z1.imag, -7.0)
866 self.assertFloatsAreIdentical(z2.real, -0.0)
867 self.assertFloatsAreIdentical(z2.imag, -INF)
868
869 @support.requires_IEEE_754
870 def test_overflow(self):
871 self.assertEqual(complex("1e500"), complex(INF, 0.0))
872 self.assertEqual(complex("-1e500j"), complex(0.0, -INF))
873 self.assertEqual(complex("-1e500+1.8e308j"), complex(-INF, INF))
874
875 @support.requires_IEEE_754
876 def test_repr_roundtrip(self):
877 vals = [0.0, 1e-500, 1e-315, 1e-200, 0.0123, 3.1415, 1e50, INF, NAN]
878 vals += [-v for v in vals]
879
880 # complex(repr(z)) should recover z exactly, even for complex
881 # numbers involving an infinity, nan, or negative zero
882 for x in vals:
883 for y in vals:
884 z = complex(x, y)
885 roundtrip = complex(repr(z))
886 self.assertComplexesAreIdentical(z, roundtrip)
887
888 # if we predefine some constants, then eval(repr(z)) should
889 # also work, except that it might change the sign of zeros
890 inf, nan = float('inf'), float('nan')
891 infj, nanj = complex(0.0, inf), complex(0.0, nan)
892 for x in vals:
893 for y in vals:
894 z = complex(x, y)
895 roundtrip = eval(repr(z))
896 # adding 0.0 has no effect beside changing -0.0 to 0.0
897 self.assertFloatsAreIdentical(0.0 + z.real,
898 0.0 + roundtrip.real)
899 self.assertFloatsAreIdentical(0.0 + z.imag,
900 0.0 + roundtrip.imag)
901
902 def test_format(self):
903 # empty format string is same as str()
904 self.assertEqual(format(1+3j, ''), str(1+3j))
905 self.assertEqual(format(1.5+3.5j, ''), str(1.5+3.5j))
906 self.assertEqual(format(3j, ''), str(3j))
907 self.assertEqual(format(3.2j, ''), str(3.2j))
908 self.assertEqual(format(3+0j, ''), str(3+0j))
909 self.assertEqual(format(3.2+0j, ''), str(3.2+0j))
910
911 # empty presentation type should still be analogous to str,
912 # even when format string is nonempty (issue #5920).
913 self.assertEqual(format(3.2+0j, '-'), str(3.2+0j))
914 self.assertEqual(format(3.2+0j, '<'), str(3.2+0j))
915 z = 4/7. - 100j/7.
916 self.assertEqual(format(z, ''), str(z))
917 self.assertEqual(format(z, '-'), str(z))
918 self.assertEqual(format(z, '<'), str(z))
919 self.assertEqual(format(z, '10'), str(z))
920 z = complex(0.0, 3.0)
921 self.assertEqual(format(z, ''), str(z))
922 self.assertEqual(format(z, '-'), str(z))
923 self.assertEqual(format(z, '<'), str(z))
924 self.assertEqual(format(z, '2'), str(z))
925 z = complex(-0.0, 2.0)
926 self.assertEqual(format(z, ''), str(z))
927 self.assertEqual(format(z, '-'), str(z))
928 self.assertEqual(format(z, '<'), str(z))
929 self.assertEqual(format(z, '3'), str(z))
930
931 self.assertEqual(format(1+3j, 'g'), '1+3j')
932 self.assertEqual(format(3j, 'g'), '0+3j')
933 self.assertEqual(format(1.5+3.5j, 'g'), '1.5+3.5j')
934
935 self.assertEqual(format(1.5+3.5j, '+g'), '+1.5+3.5j')
936 self.assertEqual(format(1.5-3.5j, '+g'), '+1.5-3.5j')
937 self.assertEqual(format(1.5-3.5j, '-g'), '1.5-3.5j')
938 self.assertEqual(format(1.5+3.5j, ' g'), ' 1.5+3.5j')
939 self.assertEqual(format(1.5-3.5j, ' g'), ' 1.5-3.5j')
940 self.assertEqual(format(-1.5+3.5j, ' g'), '-1.5+3.5j')
941 self.assertEqual(format(-1.5-3.5j, ' g'), '-1.5-3.5j')
942
943 self.assertEqual(format(-1.5-3.5e-20j, 'g'), '-1.5-3.5e-20j')
944 self.assertEqual(format(-1.5-3.5j, 'f'), '-1.500000-3.500000j')
945 self.assertEqual(format(-1.5-3.5j, 'F'), '-1.500000-3.500000j')
946 self.assertEqual(format(-1.5-3.5j, 'e'), '-1.500000e+00-3.500000e+00j')
947 self.assertEqual(format(-1.5-3.5j, '.2e'), '-1.50e+00-3.50e+00j')
948 self.assertEqual(format(-1.5-3.5j, '.2E'), '-1.50E+00-3.50E+00j')
949 self.assertEqual(format(-1.5e10-3.5e5j, '.2G'), '-1.5E+10-3.5E+05j')
950
951 self.assertEqual(format(1.5+3j, '<20g'), '1.5+3j ')
952 self.assertEqual(format(1.5+3j, '*<20g'), '1.5+3j**************')
953 self.assertEqual(format(1.5+3j, '>20g'), ' 1.5+3j')
954 self.assertEqual(format(1.5+3j, '^20g'), ' 1.5+3j ')
955 self.assertEqual(format(1.5+3j, '<20'), '(1.5+3j) ')
956 self.assertEqual(format(1.5+3j, '>20'), ' (1.5+3j)')
957 self.assertEqual(format(1.5+3j, '^20'), ' (1.5+3j) ')
958 self.assertEqual(format(1.123-3.123j, '^20.2'), ' (1.1-3.1j) ')
959
960 self.assertEqual(format(1.5+3j, '20.2f'), ' 1.50+3.00j')
961 self.assertEqual(format(1.5+3j, '>20.2f'), ' 1.50+3.00j')
962 self.assertEqual(format(1.5+3j, '<20.2f'), '1.50+3.00j ')
963 self.assertEqual(format(1.5e20+3j, '<20.2f'), '150000000000000000000.00+3.00j')
964 self.assertEqual(format(1.5e20+3j, '>40.2f'), ' 150000000000000000000.00+3.00j')
965 self.assertEqual(format(1.5e20+3j, '^40,.2f'), ' 150,000,000,000,000,000,000.00+3.00j ')
966 self.assertEqual(format(1.5e21+3j, '^40,.2f'), ' 1,500,000,000,000,000,000,000.00+3.00j ')
967 self.assertEqual(format(1.5e21+3000j, ',.2f'), '1,500,000,000,000,000,000,000.00+3,000.00j')
968
969 # Issue 7094: Alternate formatting (specified by #)
970 self.assertEqual(format(1+1j, '.0e'), '1e+00+1e+00j')
971 self.assertEqual(format(1+1j, '#.0e'), '1.e+00+1.e+00j')
972 self.assertEqual(format(1+1j, '.0f'), '1+1j')
973 self.assertEqual(format(1+1j, '#.0f'), '1.+1.j')
974 self.assertEqual(format(1.1+1.1j, 'g'), '1.1+1.1j')
975 self.assertEqual(format(1.1+1.1j, '#g'), '1.10000+1.10000j')
976
977 # Alternate doesn't make a difference for these, they format the same with or without it
978 self.assertEqual(format(1+1j, '.1e'), '1.0e+00+1.0e+00j')
979 self.assertEqual(format(1+1j, '#.1e'), '1.0e+00+1.0e+00j')
980 self.assertEqual(format(1+1j, '.1f'), '1.0+1.0j')
981 self.assertEqual(format(1+1j, '#.1f'), '1.0+1.0j')
982
983 # Misc. other alternate tests
984 self.assertEqual(format((-1.5+0.5j), '#f'), '-1.500000+0.500000j')
985 self.assertEqual(format((-1.5+0.5j), '#.0f'), '-2.+0.j')
986 self.assertEqual(format((-1.5+0.5j), '#e'), '-1.500000e+00+5.000000e-01j')
987 self.assertEqual(format((-1.5+0.5j), '#.0e'), '-2.e+00+5.e-01j')
988 self.assertEqual(format((-1.5+0.5j), '#g'), '-1.50000+0.500000j')
989 self.assertEqual(format((-1.5+0.5j), '.0g'), '-2+0.5j')
990 self.assertEqual(format((-1.5+0.5j), '#.0g'), '-2.+0.5j')
991
992 # zero padding is invalid
993 self.assertRaises(ValueError, (1.5+0.5j).__format__, '010f')
994
995 # '=' alignment is invalid
996 self.assertRaises(ValueError, (1.5+3j).__format__, '=20')
997
998 # integer presentation types are an error
999 for t in 'bcdoxX':
1000 self.assertRaises(ValueError, (1.5+0.5j).__format__, t)
1001
1002 # make sure everything works in ''.format()
1003 self.assertEqual('*{0:.3f}*'.format(3.14159+2.71828j), '*3.142+2.718j*')
1004
1005 # issue 3382
1006 self.assertEqual(format(complex(NAN, NAN), 'f'), 'nan+nanj')
1007 self.assertEqual(format(complex(1, NAN), 'f'), '1.000000+nanj')
1008 self.assertEqual(format(complex(NAN, 1), 'f'), 'nan+1.000000j')
1009 self.assertEqual(format(complex(NAN, -1), 'f'), 'nan-1.000000j')
1010 self.assertEqual(format(complex(NAN, NAN), 'F'), 'NAN+NANj')
1011 self.assertEqual(format(complex(1, NAN), 'F'), '1.000000+NANj')
1012 self.assertEqual(format(complex(NAN, 1), 'F'), 'NAN+1.000000j')
1013 self.assertEqual(format(complex(NAN, -1), 'F'), 'NAN-1.000000j')
1014 self.assertEqual(format(complex(INF, INF), 'f'), 'inf+infj')
1015 self.assertEqual(format(complex(1, INF), 'f'), '1.000000+infj')
1016 self.assertEqual(format(complex(INF, 1), 'f'), 'inf+1.000000j')
1017 self.assertEqual(format(complex(INF, -1), 'f'), 'inf-1.000000j')
1018 self.assertEqual(format(complex(INF, INF), 'F'), 'INF+INFj')
1019 self.assertEqual(format(complex(1, INF), 'F'), '1.000000+INFj')
1020 self.assertEqual(format(complex(INF, 1), 'F'), 'INF+1.000000j')
1021 self.assertEqual(format(complex(INF, -1), 'F'), 'INF-1.000000j')
1022
1023
1024 if __name__ == "__main__":
1025 unittest.main()