source: python/trunk/Lib/test/test_complex.py

Last change on this file was 391, checked in by dmik, 11 years ago

python: Merge vendor 2.7.6 to trunk.
  • Property svn:eol-style set to native
File size: 26.9 KB
Line 
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
11class ComplexTest(unittest.TestCase):
12
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)
18 else:
19 unittest.TestCase.assertAlmostEqual(self, a.real, b)
20 unittest.TestCase.assertAlmostEqual(self, a.imag, 0.)
21 else:
22 if isinstance(b, complex):
23 unittest.TestCase.assertAlmostEqual(self, a, b.real)
24 unittest.TestCase.assertAlmostEqual(self, 0., b.imag)
25 else:
26 unittest.TestCase.assertAlmostEqual(self, a, b)
27
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
31 if abs(x) > abs(y):
32 x, y = y, x
33 if y == 0:
34 return abs(x) < eps
35 if x == 0:
36 return abs(y) < eps
37 # check that relative difference < eps
38 self.assertTrue(abs((x-y)/y) < eps)
39
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
46
47 """
48 msg = 'floats {!r} and {!r} are not identical'
49
50 if isnan(x) or isnan(y):
51 if isnan(x) and isnan(y):
52 return
53 elif x == y:
54 if x != 0.0:
55 return
56 # both zero; check that signs match
57 elif copysign(1.0, x) == copysign(1.0, y):
58 return
59 else:
60 msg += ': zeros have different signs'
61 self.fail(msg.format(x, y))
62
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)
67
68 def check_div(self, x, y):
69 """Compute complex z=x*y, and check that z/x==y and z/y==x."""
70 z = x * y
71 if x != 0:
72 q = z / x
73 self.assertClose(q, y)
74 q = z.__div__(x)
75 self.assertClose(q, y)
76 q = z.__truediv__(x)
77 self.assertClose(q, y)
78 if y != 0:
79 q = z / y
80 self.assertClose(q, x)
81 q = z.__div__(y)
82 self.assertClose(q, x)
83 q = z.__truediv__(y)
84 self.assertClose(q, x)
85
86 def test_div(self):
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:
91 self.check_div(x, y)
92
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)
97
98 # Just for fun.
99 for i in xrange(100):
100 self.check_div(complex(random(), random()),
101 complex(random(), random()))
102
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)
106
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)
110
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)
114
115 def test_coerce(self):
116 self.assertRaises(OverflowError, complex.__coerce__, 1+1j, 1L<<10000)
117
118 def test_no_implicit_coerce(self):
119 # Python 2.7 removed implicit coercion from the complex type
120 class A(object):
121 def __coerce__(self, other):
122 raise RuntimeError
123 __hash__ = None
124 def __cmp__(self, other):
125 return -1
126
127 a = A()
128 self.assertRaises(TypeError, lambda: a + 2.0j)
129 self.assertTrue(a < 2.0j)
130
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)
142
143 def test_richcompare_boundaries(self):
144 def check(n, deltas, is_equal, imag = 0.0):
145 for delta in deltas:
146 i = n + delta
147 z = complex(i, imag)
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):
154 pow = 52 + i
155 mult = 2 ** i
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)
159
160 def test_mod(self):
161 self.assertRaises(ZeroDivisionError, (1+1j).__mod__, 0+0j)
162
163 a = 3.33+4.43j
164 try:
165 a % 0
166 except ZeroDivisionError:
167 pass
168 else:
169 self.fail("modulo parama can't be 0")
170
171 def test_divmod(self):
172 self.assertRaises(ZeroDivisionError, divmod, 1+1j, 0+0j)
173
174 def test_pow(self):
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)
181
182 a = 3.33+4.43j
183 self.assertEqual(a ** 0j, 1)
184 self.assertEqual(a ** 0.+0.j, 1)
185
186 self.assertEqual(3j ** 0j, 1)
187 self.assertEqual(3j ** 0, 1)
188
189 try:
190 0j ** a
191 except ZeroDivisionError:
192 pass
193 else:
194 self.fail("should fail 0.0 to negative or complex power")
195
196 try:
197 0j ** (3-2j)
198 except ZeroDivisionError:
199 pass
200 else:
201 self.fail("should fail 0.0 to negative or complex power")
202
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)
207
208 self.assertEqual(0.0j ** 0, 1)
209
210 b = 5.1+2.3j
211 self.assertRaises(ValueError, pow, a, b, 0)
212
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))
217
218 def test_conjugate(self):
219 self.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j)
220
221 def test_constructor(self):
222 class OS:
223 def __init__(self, value): self.value = value
224 def __complex__(self): return self.value
225 class NS(object):
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))
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(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)
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 if test_support.have_unicode:
305 self.assertEqual(complex(unicode(" 3.14+J ")), 3.14+1j)
306
307 # SF bug 543840: complex(string) accepts strings with \0
308 # Fixed in 2.3.
309 self.assertRaises(ValueError, complex, '1+1j\0j')
310
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")
338
339 if test_support.have_unicode:
340 # check that complex accepts long unicode strings
341 self.assertEqual(type(complex(unicode("1"*500))), complex)
342
343 class EvilExc(Exception):
344 pass
345
346 class evilcomplex:
347 def __complex__(self):
348 raise EvilExc
349
350 self.assertRaises(EvilExc, complex, evilcomplex())
351
352 class float2:
353 def __init__(self, value):
354 self.value = value
355 def __float__(self):
356 return self.value
357
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))
361
362 class complex0(complex):
363 """Test usage of __complex__() when inheriting from 'complex'"""
364 def __complex__(self):
365 return 42j
366
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):
372 return self
373
374 class complex2(complex):
375 """Make sure that __complex__() calls fail if anything other than a
376 complex is returned"""
377 def __complex__(self):
378 return None
379
380 self.assertAlmostEqual(complex(complex0(1j)), 42j)
381 self.assertAlmostEqual(complex(complex1(1j)), 2j)
382 self.assertRaises(TypeError, complex, complex2(1j))
383
384 def test_subclass(self):
385 class xcomplex(complex):
386 def __add__(self,other):
387 return xcomplex(complex(self) + other)
388 __radd__ = __add__
389
390 def __sub__(self,other):
391 return xcomplex(complex(self) + other)
392 __rsub__ = __sub__
393
394 def __mul__(self,other):
395 return xcomplex(complex(self) * other)
396 __rmul__ = __mul__
397
398 def __div__(self,other):
399 return xcomplex(complex(self) / other)
400
401 def __rdiv__(self,other):
402 return xcomplex(other / complex(self))
403
404 __truediv__ = __div__
405 __rtruediv__ = __rdiv__
406
407 def __floordiv__(self,other):
408 return xcomplex(complex(self) // other)
409
410 def __rfloordiv__(self,other):
411 return xcomplex(other // complex(self))
412
413 def __pow__(self,other):
414 return xcomplex(complex(self) ** other)
415
416 def __rpow__(self,other):
417 return xcomplex(other ** complex(self) )
418
419 def __mod__(self,other):
420 return xcomplex(complex(self) % other)
421
422 def __rmod__(self,other):
423 return xcomplex(other % complex(self))
424
425 infix_binops = ('+', '-', '*', '**', '%', '//', '/')
426 xcomplex_values = (xcomplex(1), xcomplex(123.0),
427 xcomplex(-10+2j), xcomplex(3+187j),
428 xcomplex(3-78j))
429 test_values = (1, 123.0, 10-19j, xcomplex(1+2j),
430 xcomplex(1+87j), xcomplex(10+90j))
431
432 for op in infix_binops:
433 for x in xcomplex_values:
434 for y in test_values:
435 a = 'x %s y' % op
436 b = 'y %s x' % op
437 self.assertTrue(type(eval(a)) is type(eval(b)) is xcomplex)
438
439 def test_hash(self):
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.)))
444
445 def test_abs(self):
446 nums = [complex(x/3., y/7.) for x in xrange(-9,9) for y in xrange(-9,9)]
447 for num in nums:
448 self.assertAlmostEqual((num.real**2 + num.imag**2) ** 0.5, abs(num))
449
450 def test_repr(self):
451 self.assertEqual(repr(1+6j), '(1+6j)')
452 self.assertEqual(repr(1-6j), '(1-6j)')
453
454 self.assertNotEqual(repr(-(1+0j)), '(-1+-0j)')
455
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)))
460
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)")
468
469 self.assertEqual(repr(complex(0, INF)), "infj")
470 self.assertEqual(repr(complex(0, -INF)), "-infj")
471 self.assertEqual(repr(complex(0, NAN)), "nanj")
472
473 def test_neg(self):
474 self.assertEqual(-(1+6j), -1-6j)
475
476 def test_file(self):
477 a = 3.33+4.43j
478 b = 5.1+2.3j
479
480 fo = None
481 try:
482 fo = open(test_support.TESTFN, "wb")
483 print >>fo, a, b
484 fo.close()
485 fo = open(test_support.TESTFN, "rb")
486 self.assertEqual(fo.read(), "%s %s\n" % (a, b))
487 finally:
488 if (fo is not None) and (not fo.closed):
489 fo.close()
490 test_support.unlink(test_support.TESTFN)
491
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))
499
500 if float.__getformat__("double").startswith("IEEE"):
501 def test_plus_minus_0j(self):
502 # test that -0j and 0j literals are not identified
503 z1, z2 = 0j, -0j
504 self.assertEqual(atan2(z1.imag, -1.), atan2(0., -1.))
505 self.assertEqual(atan2(z2.imag, -1.), atan2(-0., -1.))
506
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))
513
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]
519
520 # complex(repr(z)) should recover z exactly, even for complex
521 # numbers involving an infinity, nan, or negative zero
522 for x in vals:
523 for y in vals:
524 z = complex(x, y)
525 roundtrip = complex(repr(z))
526 self.assertFloatsAreIdentical(z.real, roundtrip.real)
527 self.assertFloatsAreIdentical(z.imag, roundtrip.imag)
528
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)
533 for x in vals:
534 for y in vals:
535 z = complex(x, y)
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)
542
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))
551
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))
556 z = 4/7. - 100j/7.
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))
561 z = complex(0.0, 3.0)
562 self.assertEqual(format(z, ''), str(z))
563 self.assertEqual(format(z, '-'), str(z))
564 self.assertEqual(format(z, '<'), str(z))
565 self.assertEqual(format(z, '2'), str(z))
566 z = complex(-0.0, 2.0)
567 self.assertEqual(format(z, ''), str(z))
568 self.assertEqual(format(z, '-'), str(z))
569 self.assertEqual(format(z, '<'), str(z))
570 self.assertEqual(format(z, '3'), str(z))
571
572 self.assertEqual(format(1+3j, 'g'), '1+3j')
573 self.assertEqual(format(3j, 'g'), '0+3j')
574 self.assertEqual(format(1.5+3.5j, 'g'), '1.5+3.5j')
575
576 self.assertEqual(format(1.5+3.5j, '+g'), '+1.5+3.5j')
577 self.assertEqual(format(1.5-3.5j, '+g'), '+1.5-3.5j')
578 self.assertEqual(format(1.5-3.5j, '-g'), '1.5-3.5j')
579 self.assertEqual(format(1.5+3.5j, ' g'), ' 1.5+3.5j')
580 self.assertEqual(format(1.5-3.5j, ' g'), ' 1.5-3.5j')
581 self.assertEqual(format(-1.5+3.5j, ' g'), '-1.5+3.5j')
582 self.assertEqual(format(-1.5-3.5j, ' g'), '-1.5-3.5j')
583
584 self.assertEqual(format(-1.5-3.5e-20j, 'g'), '-1.5-3.5e-20j')
585 self.assertEqual(format(-1.5-3.5j, 'f'), '-1.500000-3.500000j')
586 self.assertEqual(format(-1.5-3.5j, 'F'), '-1.500000-3.500000j')
587 self.assertEqual(format(-1.5-3.5j, 'e'), '-1.500000e+00-3.500000e+00j')
588 self.assertEqual(format(-1.5-3.5j, '.2e'), '-1.50e+00-3.50e+00j')
589 self.assertEqual(format(-1.5-3.5j, '.2E'), '-1.50E+00-3.50E+00j')
590 self.assertEqual(format(-1.5e10-3.5e5j, '.2G'), '-1.5E+10-3.5E+05j')
591
592 self.assertEqual(format(1.5+3j, '<20g'), '1.5+3j ')
593 self.assertEqual(format(1.5+3j, '*<20g'), '1.5+3j**************')
594 self.assertEqual(format(1.5+3j, '>20g'), ' 1.5+3j')
595 self.assertEqual(format(1.5+3j, '^20g'), ' 1.5+3j ')
596 self.assertEqual(format(1.5+3j, '<20'), '(1.5+3j) ')
597 self.assertEqual(format(1.5+3j, '>20'), ' (1.5+3j)')
598 self.assertEqual(format(1.5+3j, '^20'), ' (1.5+3j) ')
599 self.assertEqual(format(1.123-3.123j, '^20.2'), ' (1.1-3.1j) ')
600
601 self.assertEqual(format(1.5+3j, '20.2f'), ' 1.50+3.00j')
602 self.assertEqual(format(1.5+3j, '>20.2f'), ' 1.50+3.00j')
603 self.assertEqual(format(1.5+3j, '<20.2f'), '1.50+3.00j ')
604 self.assertEqual(format(1.5e20+3j, '<20.2f'), '150000000000000000000.00+3.00j')
605 self.assertEqual(format(1.5e20+3j, '>40.2f'), ' 150000000000000000000.00+3.00j')
606 self.assertEqual(format(1.5e20+3j, '^40,.2f'), ' 150,000,000,000,000,000,000.00+3.00j ')
607 self.assertEqual(format(1.5e21+3j, '^40,.2f'), ' 1,500,000,000,000,000,000,000.00+3.00j ')
608 self.assertEqual(format(1.5e21+3000j, ',.2f'), '1,500,000,000,000,000,000,000.00+3,000.00j')
609
610 # alternate is invalid
611 self.assertRaises(ValueError, (1.5+0.5j).__format__, '#f')
612
613 # zero padding is invalid
614 self.assertRaises(ValueError, (1.5+0.5j).__format__, '010f')
615
616 # '=' alignment is invalid
617 self.assertRaises(ValueError, (1.5+3j).__format__, '=20')
618
619 # integer presentation types are an error
620 for t in 'bcdoxX':
621 self.assertRaises(ValueError, (1.5+0.5j).__format__, t)
622
623 # make sure everything works in ''.format()
624 self.assertEqual('*{0:.3f}*'.format(3.14159+2.71828j), '*3.142+2.718j*')
625
626 # issue 3382: 'f' and 'F' with inf's and nan's
627 self.assertEqual('{0:f}'.format(INF+0j), 'inf+0.000000j')
628 self.assertEqual('{0:F}'.format(INF+0j), 'INF+0.000000j')
629 self.assertEqual('{0:f}'.format(-INF+0j), '-inf+0.000000j')
630 self.assertEqual('{0:F}'.format(-INF+0j), '-INF+0.000000j')
631 self.assertEqual('{0:f}'.format(complex(INF, INF)), 'inf+infj')
632 self.assertEqual('{0:F}'.format(complex(INF, INF)), 'INF+INFj')
633 self.assertEqual('{0:f}'.format(complex(INF, -INF)), 'inf-infj')
634 self.assertEqual('{0:F}'.format(complex(INF, -INF)), 'INF-INFj')
635 self.assertEqual('{0:f}'.format(complex(-INF, INF)), '-inf+infj')
636 self.assertEqual('{0:F}'.format(complex(-INF, INF)), '-INF+INFj')
637 self.assertEqual('{0:f}'.format(complex(-INF, -INF)), '-inf-infj')
638 self.assertEqual('{0:F}'.format(complex(-INF, -INF)), '-INF-INFj')
639
640 self.assertEqual('{0:f}'.format(complex(NAN, 0)), 'nan+0.000000j')
641 self.assertEqual('{0:F}'.format(complex(NAN, 0)), 'NAN+0.000000j')
642 self.assertEqual('{0:f}'.format(complex(NAN, NAN)), 'nan+nanj')
643 self.assertEqual('{0:F}'.format(complex(NAN, NAN)), 'NAN+NANj')
644
645def test_main():
646 with test_support.check_warnings(("complex divmod.., // and % are "
647 "deprecated", DeprecationWarning)):
648 test_support.run_unittest(ComplexTest)
649
650if __name__ == "__main__":
651 test_main()
Note: See TracBrowser for help on using the repository browser.