2 from test
import test_support
4 from random
import random
5 from math
import atan2
, isnan
, copysign
9 # These tests ensure that complex math does the right thing
11 class ComplexTest(unittest
.TestCase
):
13 def assertAlmostEqual(self
, a
, b
):
14 if isinstance(a
, complex):
15 if isinstance(b
, complex):
16 unittest
.TestCase
.assertAlmostEqual(self
, a
.real
, b
.real
)
17 unittest
.TestCase
.assertAlmostEqual(self
, a
.imag
, b
.imag
)
19 unittest
.TestCase
.assertAlmostEqual(self
, a
.real
, b
)
20 unittest
.TestCase
.assertAlmostEqual(self
, a
.imag
, 0.)
22 if isinstance(b
, complex):
23 unittest
.TestCase
.assertAlmostEqual(self
, a
, b
.real
)
24 unittest
.TestCase
.assertAlmostEqual(self
, 0., b
.imag
)
26 unittest
.TestCase
.assertAlmostEqual(self
, a
, b
)
28 def assertCloseAbs(self
, x
, y
, eps
=1e-9):
29 """Return true iff floats x and y "are close\""""
30 # put the one with larger magnitude second
37 # check that relative difference < eps
38 self.assertTrue(abs((x-y)/y) < eps)
40 def assertFloatsAreIdentical(self, x, y):
41 """assert that floats x
and y are identical
, in the sense that
:
42 (1) both x
and y are nans
, or
43 (2) both x
and y are infinities
, with the same sign
, or
44 (3) both x
and y are zeros
, with the same sign
, or
45 (4) x
and y are both finite
and nonzero
, and x
== y
48 msg = 'floats {!r} and {!r} are not identical'
50 if isnan(x) or isnan(y):
51 if isnan(x) and isnan(y):
56 # both zero; check that signs match
57 elif copysign(1.0, x) == copysign(1.0, y):
60 msg += ': zeros have different signs'
61 self.fail(msg.format(x, y))
63 def assertClose(self, x, y, eps=1e-9):
64 """Return true iff complexes x
and y
"are close\""""
65 self
.assertCloseAbs(x
.real
, y
.real
, eps
)
66 self
.assertCloseAbs(x
.imag
, y
.imag
, eps
)
68 def check_div(self
, x
, y
):
69 """Compute complex z=x*y, and check that z/x==y and z/y==x."""
73 self
.assertClose(q
, y
)
75 self
.assertClose(q
, y
)
77 self
.assertClose(q
, y
)
80 self
.assertClose(q
, x
)
82 self
.assertClose(q
, x
)
84 self
.assertClose(q
, x
)
87 simple_real
= [float(i
) for i
in xrange(-5, 6)]
88 simple_complex
= [complex(x
, y
) for x
in simple_real
for y
in simple_real
]
89 for x
in simple_complex
:
90 for y
in simple_complex
:
93 # A naive complex division algorithm (such as in 2.0) is very prone to
94 # nonsense errors for these (overflows and underflows).
95 self
.check_div(complex(1e200
, 1e200
), 1+0j
)
96 self
.check_div(complex(1e-200, 1e-200), 1+0j
)
100 self
.check_div(complex(random(), random()),
101 complex(random(), random()))
103 self
.assertRaises(ZeroDivisionError, complex.__div
__, 1+1j
, 0+0j
)
104 # FIXME: The following currently crashes on Alpha
105 # self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j)
107 def test_truediv(self
):
108 self
.assertAlmostEqual(complex.__truediv
__(2+0j
, 1+1j
), 1-1j
)
109 self
.assertRaises(ZeroDivisionError, complex.__truediv
__, 1+1j
, 0+0j
)
111 def test_floordiv(self
):
112 self
.assertAlmostEqual(complex.__floordiv
__(3+0j
, 1.5+0j
), 2)
113 self
.assertRaises(ZeroDivisionError, complex.__floordiv
__, 3+0j
, 0+0j
)
115 def test_coerce(self
):
116 self
.assertRaises(OverflowError, complex.__coerce
__, 1+1j
, 1L<<10000)
118 def test_no_implicit_coerce(self
):
119 # Python 2.7 removed implicit coercion from the complex type
121 def __coerce__(self
, other
):
124 def __cmp__(self
, other
):
128 self
.assertRaises(TypeError, lambda: a
+ 2.0j
)
129 self
.assertTrue(a
< 2.0j
)
131 def test_richcompare(self
):
132 self
.assertEqual(complex.__eq
__(1+1j
, 1L<<10000), False)
133 self
.assertEqual(complex.__lt
__(1+1j
, None), NotImplemented)
134 self
.assertIs(complex.__eq
__(1+1j
, 1+1j
), True)
135 self
.assertIs(complex.__eq
__(1+1j
, 2+2j
), False)
136 self
.assertIs(complex.__ne
__(1+1j
, 1+1j
), False)
137 self
.assertIs(complex.__ne
__(1+1j
, 2+2j
), True)
138 self
.assertRaises(TypeError, complex.__lt
__, 1+1j
, 2+2j
)
139 self
.assertRaises(TypeError, complex.__le
__, 1+1j
, 2+2j
)
140 self
.assertRaises(TypeError, complex.__gt
__, 1+1j
, 2+2j
)
141 self
.assertRaises(TypeError, complex.__ge
__, 1+1j
, 2+2j
)
143 def test_richcompare_boundaries(self
):
144 def check(n
, deltas
, is_equal
, imag
= 0.0):
148 self
.assertIs(complex.__eq
__(z
, i
), is_equal(delta
))
149 self
.assertIs(complex.__ne
__(z
, i
), not is_equal(delta
))
150 # For IEEE-754 doubles the following should hold:
151 # x in [2 ** (52 + i), 2 ** (53 + i + 1)] -> x mod 2 ** i == 0
152 # where the interval is representable, of course.
153 for i
in range(1, 10):
156 check(2 ** pow, range(1, 101), lambda delta
: delta
% mult
== 0)
157 check(2 ** pow, range(1, 101), lambda delta
: False, float(i
))
158 check(2 ** 53, range(-100, 0), lambda delta
: True)
161 self
.assertRaises(ZeroDivisionError, (1+1j
).__mod
__, 0+0j
)
166 except ZeroDivisionError:
169 self
.fail("modulo parama can't be 0")
171 def test_divmod(self
):
172 self
.assertRaises(ZeroDivisionError, divmod, 1+1j
, 0+0j
)
175 self
.assertAlmostEqual(pow(1+1j
, 0+0j
), 1.0)
176 self
.assertAlmostEqual(pow(0+0j
, 2+0j
), 0.0)
177 self
.assertRaises(ZeroDivisionError, pow, 0+0j
, 1j
)
178 self
.assertAlmostEqual(pow(1j
, -1), 1/1j
)
179 self
.assertAlmostEqual(pow(1j
, 200), 1)
180 self
.assertRaises(ValueError, pow, 1+1j
, 1+1j
, 1+1j
)
183 self
.assertEqual(a
** 0j
, 1)
184 self
.assertEqual(a
** 0.+0.j
, 1)
186 self
.assertEqual(3j
** 0j
, 1)
187 self
.assertEqual(3j
** 0, 1)
191 except ZeroDivisionError:
194 self
.fail("should fail 0.0 to negative or complex power")
198 except ZeroDivisionError:
201 self
.fail("should fail 0.0 to negative or complex power")
203 # The following is used to exercise certain code paths
204 self
.assertEqual(a
** 105, a
** 105)
205 self
.assertEqual(a
** -105, a
** -105)
206 self
.assertEqual(a
** -30, a
** -30)
208 self
.assertEqual(0.0j
** 0, 1)
211 self
.assertRaises(ValueError, pow, a
, b
, 0)
213 def test_boolcontext(self
):
214 for i
in xrange(100):
215 self
.assertTrue(complex(random() + 1e-6, random() + 1e-6))
216 self
.assertTrue(not complex(0.0, 0.0))
218 def test_conjugate(self
):
219 self
.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j
)
221 def test_constructor(self
):
223 def __init__(self
, value
): self
.value
= value
224 def __complex__(self
): return self
.value
226 def __init__(self
, value
): self
.value
= value
227 def __complex__(self
): return self
.value
228 self
.assertEqual(complex(OS(1+10j
)), 1+10j
)
229 self
.assertEqual(complex(NS(1+10j
)), 1+10j
)
230 self
.assertRaises(TypeError, complex, OS(None))
231 self
.assertRaises(TypeError, complex, NS(None))
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(10L), 10+0j
)
237 self
.assertAlmostEqual(complex(10+0j
), 10+0j
)
238 self
.assertAlmostEqual(complex(1,10), 1+10j
)
239 self
.assertAlmostEqual(complex(1,10L), 1+10j
)
240 self
.assertAlmostEqual(complex(1,10.0), 1+10j
)
241 self
.assertAlmostEqual(complex(1L,10), 1+10j
)
242 self
.assertAlmostEqual(complex(1L,10L), 1+10j
)
243 self
.assertAlmostEqual(complex(1L,10.0), 1+10j
)
244 self
.assertAlmostEqual(complex(1.0,10), 1+10j
)
245 self
.assertAlmostEqual(complex(1.0,10L), 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(314L), 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(314L, 0L), 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
)
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
)
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.)
289 """Function that produces different results for 0. and -0."""
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.))
298 self
.assertTrue(complex(c
) is c
)
301 self
.assertRaises(TypeError, complex, "1", "1")
302 self
.assertRaises(TypeError, complex, 1, "1")
304 if test_support
.have_unicode
:
305 self
.assertEqual(complex(unicode(" 3.14+J ")), 3.14+1j
)
307 # SF bug 543840: complex(string) accepts strings with \0
309 self
.assertRaises(ValueError, complex, '1+1j\0j')
311 self
.assertRaises(TypeError, int, 5+3j
)
312 self
.assertRaises(TypeError, long, 5+3j
)
313 self
.assertRaises(TypeError, float, 5+3j
)
314 self
.assertRaises(ValueError, complex, "")
315 self
.assertRaises(TypeError, complex, None)
316 self
.assertRaises(ValueError, complex, "\0")
317 self
.assertRaises(ValueError, complex, "3\09")
318 self
.assertRaises(TypeError, complex, "1", "2")
319 self
.assertRaises(TypeError, complex, "1", 42)
320 self
.assertRaises(TypeError, complex, 1, "2")
321 self
.assertRaises(ValueError, complex, "1+")
322 self
.assertRaises(ValueError, complex, "1+1j+1j")
323 self
.assertRaises(ValueError, complex, "--")
324 self
.assertRaises(ValueError, complex, "(1+2j")
325 self
.assertRaises(ValueError, complex, "1+2j)")
326 self
.assertRaises(ValueError, complex, "1+(2j)")
327 self
.assertRaises(ValueError, complex, "(1+2j)123")
328 if test_support
.have_unicode
:
329 self
.assertRaises(ValueError, complex, unicode("x"))
330 self
.assertRaises(ValueError, complex, "1j+2")
331 self
.assertRaises(ValueError, complex, "1e1ej")
332 self
.assertRaises(ValueError, complex, "1e++1ej")
333 self
.assertRaises(ValueError, complex, ")1+2j(")
334 # the following three are accepted by Python 2.6
335 self
.assertRaises(ValueError, complex, "1..1j")
336 self
.assertRaises(ValueError, complex, "1.11.1j")
337 self
.assertRaises(ValueError, complex, "1e1.1j")
339 if test_support
.have_unicode
:
340 # check that complex accepts long unicode strings
341 self
.assertEqual(type(complex(unicode("1"*500))), complex)
343 class EvilExc(Exception):
347 def __complex__(self
):
350 self
.assertRaises(EvilExc
, complex, evilcomplex())
353 def __init__(self
, value
):
358 self
.assertAlmostEqual(complex(float2(42.)), 42)
359 self
.assertAlmostEqual(complex(real
=float2(17.), imag
=float2(23.)), 17+23j
)
360 self
.assertRaises(TypeError, complex, float2(None))
362 class complex0(complex):
363 """Test usage of __complex__() when inheriting from 'complex'"""
364 def __complex__(self
):
367 class complex1(complex):
368 """Test usage of __complex__() with a __new__() method"""
369 def __new__(self
, value
=0j
):
370 return complex.__new
__(self
, 2*value
)
371 def __complex__(self
):
374 class complex2(complex):
375 """Make sure that __complex__() calls fail if anything other than a
376 complex is returned"""
377 def __complex__(self
):
380 self
.assertAlmostEqual(complex(complex0(1j
)), 42j
)
381 self
.assertAlmostEqual(complex(complex1(1j
)), 2j
)
382 self
.assertRaises(TypeError, complex, complex2(1j
))
384 def test_subclass(self
):
385 class xcomplex(complex):
386 def __add__(self
,other
):
387 return xcomplex(complex(self
) + other
)
390 def __sub__(self
,other
):
391 return xcomplex(complex(self
) + other
)
394 def __mul__(self
,other
):
395 return xcomplex(complex(self
) * other
)
398 def __div__(self
,other
):
399 return xcomplex(complex(self
) / other
)
401 def __rdiv__(self
,other
):
402 return xcomplex(other
/ complex(self
))
404 __truediv__
= __div__
405 __rtruediv__
= __rdiv__
407 def __floordiv__(self
,other
):
408 return xcomplex(complex(self
) // other
)
410 def __rfloordiv__(self
,other
):
411 return xcomplex(other
// complex(self
))
413 def __pow__(self
,other
):
414 return xcomplex(complex(self
) ** other
)
416 def __rpow__(self
,other
):
417 return xcomplex(other
** complex(self
) )
419 def __mod__(self
,other
):
420 return xcomplex(complex(self
) % other
)
422 def __rmod__(self
,other
):
423 return xcomplex(other
% complex(self
))
425 infix_binops
= ('+', '-', '*', '**', '%', '//', '/')
426 xcomplex_values
= (xcomplex(1), xcomplex(123.0),
427 xcomplex(-10+2j
), xcomplex(3+187j
),
429 test_values
= (1, 123.0, 10-19j
, xcomplex(1+2j
),
430 xcomplex(1+87j
), xcomplex(10+90j
))
432 for op
in infix_binops
:
433 for x
in xcomplex_values
:
434 for y
in test_values
:
437 self
.assertTrue(type(eval(a
)) is type(eval(b
)) is xcomplex
)
440 for x
in xrange(-30, 30):
441 self
.assertEqual(hash(x
), hash(complex(x
, 0)))
442 x
/= 3.0 # now check against floating point
443 self
.assertEqual(hash(x
), hash(complex(x
, 0.)))
446 nums
= [complex(x
/3., y
/7.) for x
in xrange(-9,9) for y
in xrange(-9,9)]
448 self
.assertAlmostEqual((num
.real
**2 + num
.imag
**2) ** 0.5, abs(num
))
451 self
.assertEqual(repr(1+6j
), '(1+6j)')
452 self
.assertEqual(repr(1-6j
), '(1-6j)')
454 self
.assertNotEqual(repr(-(1+0j
)), '(-1+-0j)')
456 self
.assertEqual(1-6j
,complex(repr(1-6j
)))
457 self
.assertEqual(1+6j
,complex(repr(1+6j
)))
458 self
.assertEqual(-6j
,complex(repr(-6j
)))
459 self
.assertEqual(6j
,complex(repr(6j
)))
461 self
.assertEqual(repr(complex(1., INF
)), "(1+infj)")
462 self
.assertEqual(repr(complex(1., -INF
)), "(1-infj)")
463 self
.assertEqual(repr(complex(INF
, 1)), "(inf+1j)")
464 self
.assertEqual(repr(complex(-INF
, INF
)), "(-inf+infj)")
465 self
.assertEqual(repr(complex(NAN
, 1)), "(nan+1j)")
466 self
.assertEqual(repr(complex(1, NAN
)), "(1+nanj)")
467 self
.assertEqual(repr(complex(NAN
, NAN
)), "(nan+nanj)")
469 self
.assertEqual(repr(complex(0, INF
)), "infj")
470 self
.assertEqual(repr(complex(0, -INF
)), "-infj")
471 self
.assertEqual(repr(complex(0, NAN
)), "nanj")
474 self
.assertEqual(-(1+6j
), -1-6j
)
482 fo
= open(test_support
.TESTFN
, "wb")
485 fo
= open(test_support
.TESTFN
, "rb")
486 self
.assertEqual(fo
.read(), "%s %s\n" % (a
, b
))
488 if (fo
is not None) and (not fo
.closed
):
490 test_support
.unlink(test_support
.TESTFN
)
492 def test_getnewargs(self
):
493 self
.assertEqual((1+2j
).__getnewargs
__(), (1.0, 2.0))
494 self
.assertEqual((1-2j
).__getnewargs
__(), (1.0, -2.0))
495 self
.assertEqual((2j
).__getnewargs
__(), (0.0, 2.0))
496 self
.assertEqual((-0j
).__getnewargs
__(), (0.0, -0.0))
497 self
.assertEqual(complex(0, INF
).__getnewargs
__(), (0.0, INF
))
498 self
.assertEqual(complex(INF
, 0).__getnewargs
__(), (INF
, 0.0))
500 if float.__getformat
__("double").startswith("IEEE"):
501 def test_plus_minus_0j(self
):
502 # test that -0j and 0j literals are not identified
504 self
.assertEquals(atan2(z1
.imag
, -1.), atan2(0., -1.))
505 self
.assertEquals(atan2(z2
.imag
, -1.), atan2(-0., -1.))
507 @unittest.skipUnless(float.__getformat
__("double").startswith("IEEE"),
508 "test requires IEEE 754 doubles")
509 def test_overflow(self
):
510 self
.assertEqual(complex("1e500"), complex(INF
, 0.0))
511 self
.assertEqual(complex("-1e500j"), complex(0.0, -INF
))
512 self
.assertEqual(complex("-1e500+1.8e308j"), complex(-INF
, INF
))
514 @unittest.skipUnless(float.__getformat
__("double").startswith("IEEE"),
515 "test requires IEEE 754 doubles")
516 def test_repr_roundtrip(self
):
517 vals
= [0.0, 1e-500, 1e-315, 1e-200, 0.0123, 3.1415, 1e50
, INF
, NAN
]
518 vals
+= [-v
for v
in vals
]
520 # complex(repr(z)) should recover z exactly, even for complex
521 # numbers involving an infinity, nan, or negative zero
525 roundtrip
= complex(repr(z
))
526 self
.assertFloatsAreIdentical(z
.real
, roundtrip
.real
)
527 self
.assertFloatsAreIdentical(z
.imag
, roundtrip
.imag
)
529 # if we predefine some constants, then eval(repr(z)) should
530 # also work, except that it might change the sign of zeros
531 inf
, nan
= float('inf'), float('nan')
532 infj
, nanj
= complex(0.0, inf
), complex(0.0, nan
)
536 roundtrip
= eval(repr(z
))
537 # adding 0.0 has no effect beside changing -0.0 to 0.0
538 self
.assertFloatsAreIdentical(0.0 + z
.real
,
539 0.0 + roundtrip
.real
)
540 self
.assertFloatsAreIdentical(0.0 + z
.imag
,
541 0.0 + roundtrip
.imag
)
543 def test_format(self
):
544 # empty format string is same as str()
545 self
.assertEqual(format(1+3j
, ''), str(1+3j
))
546 self
.assertEqual(format(1.5+3.5j
, ''), str(1.5+3.5j
))
547 self
.assertEqual(format(3j
, ''), str(3j
))
548 self
.assertEqual(format(3.2j
, ''), str(3.2j
))
549 self
.assertEqual(format(3+0j
, ''), str(3+0j
))
550 self
.assertEqual(format(3.2+0j
, ''), str(3.2+0j
))
552 # empty presentation type should still be analogous to str,
553 # even when format string is nonempty (issue #5920).
554 self
.assertEqual(format(3.2+0j
, '-'), str(3.2+0j
))
555 self
.assertEqual(format(3.2+0j
, '<'), str(3.2+0j
))
557 self
.assertEqual(format(z
, ''), str(z
))
558 self
.assertEqual(format(z
, '-'), str(z
))
559 self
.assertEqual(format(z
, '<'), str(z
))
560 self
.assertEqual(format(z
, '10'), str(z
))
562 self
.assertEqual(format(1+3j
, 'g'), '1+3j')
563 self
.assertEqual(format(3j
, 'g'), '0+3j')
564 self
.assertEqual(format(1.5+3.5j
, 'g'), '1.5+3.5j')
566 self
.assertEqual(format(1.5+3.5j
, '+g'), '+1.5+3.5j')
567 self
.assertEqual(format(1.5-3.5j
, '+g'), '+1.5-3.5j')
568 self
.assertEqual(format(1.5-3.5j
, '-g'), '1.5-3.5j')
569 self
.assertEqual(format(1.5+3.5j
, ' g'), ' 1.5+3.5j')
570 self
.assertEqual(format(1.5-3.5j
, ' g'), ' 1.5-3.5j')
571 self
.assertEqual(format(-1.5+3.5j
, ' g'), '-1.5+3.5j')
572 self
.assertEqual(format(-1.5-3.5j
, ' g'), '-1.5-3.5j')
574 self
.assertEqual(format(-1.5-3.5e-20j
, 'g'), '-1.5-3.5e-20j')
575 self
.assertEqual(format(-1.5-3.5j
, 'f'), '-1.500000-3.500000j')
576 self
.assertEqual(format(-1.5-3.5j
, 'F'), '-1.500000-3.500000j')
577 self
.assertEqual(format(-1.5-3.5j
, 'e'), '-1.500000e+00-3.500000e+00j')
578 self
.assertEqual(format(-1.5-3.5j
, '.2e'), '-1.50e+00-3.50e+00j')
579 self
.assertEqual(format(-1.5-3.5j
, '.2E'), '-1.50E+00-3.50E+00j')
580 self
.assertEqual(format(-1.5e10
-3.5e5j
, '.2G'), '-1.5E+10-3.5E+05j')
582 self
.assertEqual(format(1.5+3j
, '<20g'), '1.5+3j ')
583 self
.assertEqual(format(1.5+3j
, '*<20g'), '1.5+3j**************')
584 self
.assertEqual(format(1.5+3j
, '>20g'), ' 1.5+3j')
585 self
.assertEqual(format(1.5+3j
, '^20g'), ' 1.5+3j ')
586 self
.assertEqual(format(1.5+3j
, '<20'), '(1.5+3j) ')
587 self
.assertEqual(format(1.5+3j
, '>20'), ' (1.5+3j)')
588 self
.assertEqual(format(1.5+3j
, '^20'), ' (1.5+3j) ')
589 self
.assertEqual(format(1.123-3.123j
, '^20.2'), ' (1.1-3.1j) ')
591 self
.assertEqual(format(1.5+3j
, '20.2f'), ' 1.50+3.00j')
592 self
.assertEqual(format(1.5+3j
, '>20.2f'), ' 1.50+3.00j')
593 self
.assertEqual(format(1.5+3j
, '<20.2f'), '1.50+3.00j ')
594 self
.assertEqual(format(1.5e20
+3j
, '<20.2f'), '150000000000000000000.00+3.00j')
595 self
.assertEqual(format(1.5e20
+3j
, '>40.2f'), ' 150000000000000000000.00+3.00j')
596 self
.assertEqual(format(1.5e20
+3j
, '^40,.2f'), ' 150,000,000,000,000,000,000.00+3.00j ')
597 self
.assertEqual(format(1.5e21
+3j
, '^40,.2f'), ' 1,500,000,000,000,000,000,000.00+3.00j ')
598 self
.assertEqual(format(1.5e21
+3000j
, ',.2f'), '1,500,000,000,000,000,000,000.00+3,000.00j')
600 # alternate is invalid
601 self
.assertRaises(ValueError, (1.5+0.5j
).__format
__, '#f')
603 # zero padding is invalid
604 self
.assertRaises(ValueError, (1.5+0.5j
).__format
__, '010f')
606 # '=' alignment is invalid
607 self
.assertRaises(ValueError, (1.5+3j
).__format
__, '=20')
609 # integer presentation types are an error
611 self
.assertRaises(ValueError, (1.5+0.5j
).__format
__, t
)
613 # make sure everything works in ''.format()
614 self
.assertEqual('*{0:.3f}*'.format(3.14159+2.71828j
), '*3.142+2.718j*')
616 # issue 3382: 'f' and 'F' with inf's and nan's
617 self
.assertEqual('{0:f}'.format(INF
+0j
), 'inf+0.000000j')
618 self
.assertEqual('{0:F}'.format(INF
+0j
), 'INF+0.000000j')
619 self
.assertEqual('{0:f}'.format(-INF
+0j
), '-inf+0.000000j')
620 self
.assertEqual('{0:F}'.format(-INF
+0j
), '-INF+0.000000j')
621 self
.assertEqual('{0:f}'.format(complex(INF
, INF
)), 'inf+infj')
622 self
.assertEqual('{0:F}'.format(complex(INF
, INF
)), 'INF+INFj')
623 self
.assertEqual('{0:f}'.format(complex(INF
, -INF
)), 'inf-infj')
624 self
.assertEqual('{0:F}'.format(complex(INF
, -INF
)), 'INF-INFj')
625 self
.assertEqual('{0:f}'.format(complex(-INF
, INF
)), '-inf+infj')
626 self
.assertEqual('{0:F}'.format(complex(-INF
, INF
)), '-INF+INFj')
627 self
.assertEqual('{0:f}'.format(complex(-INF
, -INF
)), '-inf-infj')
628 self
.assertEqual('{0:F}'.format(complex(-INF
, -INF
)), '-INF-INFj')
630 self
.assertEqual('{0:f}'.format(complex(NAN
, 0)), 'nan+0.000000j')
631 self
.assertEqual('{0:F}'.format(complex(NAN
, 0)), 'NAN+0.000000j')
632 self
.assertEqual('{0:f}'.format(complex(NAN
, NAN
)), 'nan+nanj')
633 self
.assertEqual('{0:F}'.format(complex(NAN
, NAN
)), 'NAN+NANj')
636 with test_support
.check_warnings(("complex divmod.., // and % are "
637 "deprecated", DeprecationWarning)):
638 test_support
.run_unittest(ComplexTest
)
640 if __name__
== "__main__":