cpython-lru_cache-weakref: Lib/test/test

annotate Lib/test/test_complex.py @ 59028:73cd83706bc4 3.1

Merged revisions 78333 via svnmerge from svn+ssh://pythondev@svn.python.org/python/branches/py3k ................ r78333 | eric.smith | 2010-02-22 13:54:44 -0500 (Mon, 22 Feb 2010) | 9 lines Merged revisions 78329 via svnmerge from svn+ssh://pythondev@svn.python.org/python/trunk ........ r78329 | eric.smith | 2010-02-22 13:33:47 -0500 (Mon, 22 Feb 2010) | 1 line Issue #7988: Fix default alignment to be right aligned for complex.__format__. Now it matches other numeric types. ........ ................

author	Eric Smith <eric@trueblade.com>
date	Mon, 22 Feb 2010 19:26:06 +0000
parents	0bb232078b8c
children	e6f1b3d1040a

rev	line source
30071 735ec0869492 Remove useless import. Walter Dörwald <walter@livinglogic.de> parents: 30070 diff changeset	1 import unittest, os
47201 9c930a32cebb #2621 rename test.test_support to test.support Benjamin Peterson <benjamin@python.org> parents: 45371 diff changeset	2 from test import support
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	3
17066 2c1be7924b04 SF bug [ #409448 ] Complex division is braindead Tim Peters <tim.peters@gmail.com> parents: diff changeset	4 from random import random
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	5 from math import atan2, isnan, copysign
17066 2c1be7924b04 SF bug [ #409448 ] Complex division is braindead Tim Peters <tim.peters@gmail.com> parents: diff changeset	6
45371 7c4c46342137 Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617,60619-60621,60623-60625,60627-60629,60631,60633,60635,60647,60650,60652,60654,60656,60658-60659,60664-60666,60668-60670,60672,60676,60678,60680-60683,60685-60686,60688,60690,60692-60694,60697-60700,60705-60706,60708,60711,60714,60720,60724-60730,60732,60736,60742,60744,60746,60748,60750-60751,60753,60756-60757,60759-60761,60763-60764,60766,60769-60770,60774-60784,60787-60845 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45082 diff changeset	7 INF = float("inf")
7c4c46342137 Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617,60619-60621,60623-60625,60627-60629,60631,60633,60635,60647,60650,60652,60654,60656,60658-60659,60664-60666,60668-60670,60672,60676,60678,60680-60683,60685-60686,60688,60690,60692-60694,60697-60700,60705-60706,60708,60711,60714,60720,60724-60730,60732,60736,60742,60744,60746,60748,60750-60751,60753,60756-60757,60759-60761,60763-60764,60766,60769-60770,60774-60784,60787-60845 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45082 diff changeset	8 NAN = float("nan")
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	9 # These tests ensure that complex math does the right thing
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	10
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	11 class ComplexTest(unittest.TestCase):
21401 6da6091a31ee Add a comment explaining what these tests are for, and where to look for Fred Drake <fdrake@acm.org> parents: 19791 diff changeset	12
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	13 def assertAlmostEqual(self, a, b):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	14 if isinstance(a, complex):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	15 if isinstance(b, complex):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	16 unittest.TestCase.assertAlmostEqual(self, a.real, b.real)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	17 unittest.TestCase.assertAlmostEqual(self, a.imag, b.imag)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	18 else:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	19 unittest.TestCase.assertAlmostEqual(self, a.real, b)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	20 unittest.TestCase.assertAlmostEqual(self, a.imag, 0.)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	21 else:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	22 if isinstance(b, complex):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	23 unittest.TestCase.assertAlmostEqual(self, a, b.real)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	24 unittest.TestCase.assertAlmostEqual(self, 0., b.imag)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	25 else:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	26 unittest.TestCase.assertAlmostEqual(self, a, b)
17066 2c1be7924b04 SF bug [ #409448 ] Complex division is braindead Tim Peters <tim.peters@gmail.com> parents: diff changeset	27
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	28 def assertCloseAbs(self, x, y, eps=1e-9):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	29 """Return true iff floats x and y "are close\""""
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	30 # put the one with larger magnitude second
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	31 if abs(x) > abs(y):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	32 x, y = y, x
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	33 if y == 0:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	34 return abs(x) < eps
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	35 if x == 0:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	36 return abs(y) < eps
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	37 # check that relative difference < eps
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 54225 diff changeset	38 self.assertTrue(abs((x-y)/y) < eps)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	39
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	40 def assertFloatsAreIdentical(self, x, y):
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	41 """assert that floats x and y are identical, in the sense that:
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	42 (1) both x and y are nans, or
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	43 (2) both x and y are infinities, with the same sign, or
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	44 (3) both x and y are zeros, with the same sign, or
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	45 (4) x and y are both finite and nonzero, and x == y
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	46
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	47 """
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	48 msg = 'floats {!r} and {!r} are not identical'
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	49
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	50 if isnan(x) or isnan(y):
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	51 if isnan(x) and isnan(y):
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	52 return
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	53 elif x == y:
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	54 if x != 0.0:
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	55 return
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	56 # both zero; check that signs match
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	57 elif copysign(1.0, x) == copysign(1.0, y):
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	58 return
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	59 else:
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	60 msg += ': zeros have different signs'
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	61 self.fail(msg.format(x, y))
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	62
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	63 def assertClose(self, x, y, eps=1e-9):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	64 """Return true iff complexes x and y "are close\""""
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	65 self.assertCloseAbs(x.real, y.real, eps)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	66 self.assertCloseAbs(x.imag, y.imag, eps)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	67
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	68 def assertIs(self, a, b):
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 54225 diff changeset	69 self.assertTrue(a is b)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	70
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	71 def check_div(self, x, y):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	72 """Compute complex z=x*y, and check that z/x==y and z/y==x."""
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	73 z = x * y
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	74 if x != 0:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	75 q = z / x
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	76 self.assertClose(q, y)
30070 061d86fc11bb Check both __div__ and __truediv__ in division tests. Walter Dörwald <walter@livinglogic.de> parents: 29867 diff changeset	77 q = z.__truediv__(x)
061d86fc11bb Check both __div__ and __truediv__ in division tests. Walter Dörwald <walter@livinglogic.de> parents: 29867 diff changeset	78 self.assertClose(q, y)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	79 if y != 0:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	80 q = z / y
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	81 self.assertClose(q, x)
30070 061d86fc11bb Check both __div__ and __truediv__ in division tests. Walter Dörwald <walter@livinglogic.de> parents: 29867 diff changeset	82 q = z.__truediv__(y)
061d86fc11bb Check both __div__ and __truediv__ in division tests. Walter Dörwald <walter@livinglogic.de> parents: 29867 diff changeset	83 self.assertClose(q, x)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	84
37191 4bfe8afe8f65 Get rid of remnants of integer division Neal Norwitz <nnorwitz@gmail.com> parents: 35586 diff changeset	85 def test_truediv(self):
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41575 diff changeset	86 simple_real = [float(i) for i in range(-5, 6)]
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	87 simple_complex = [complex(x, y) for x in simple_real for y in simple_real]
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	88 for x in simple_complex:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	89 for y in simple_complex:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	90 self.check_div(x, y)
19791 c97dda238b36 Reverting to rev 1.2. Apparently gcc doesn't use the extended-precision Tim Peters <tim.peters@gmail.com> parents: 19790 diff changeset	91
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	92 # A naive complex division algorithm (such as in 2.0) is very prone to
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	93 # nonsense errors for these (overflows and underflows).
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	94 self.check_div(complex(1e200, 1e200), 1+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	95 self.check_div(complex(1e-200, 1e-200), 1+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	96
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	97 # Just for fun.
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41575 diff changeset	98 for i in range(100):
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	99 self.check_div(complex(random(), random()),
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	100 complex(random(), random()))
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	101
37191 4bfe8afe8f65 Get rid of remnants of integer division Neal Norwitz <nnorwitz@gmail.com> parents: 35586 diff changeset	102 self.assertRaises(ZeroDivisionError, complex.__truediv__, 1+1j, 0+0j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	103 # FIXME: The following currently crashes on Alpha
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	104 # self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	105
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	106 def test_truediv(self):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	107 self.assertAlmostEqual(complex.__truediv__(2+0j, 1+1j), 1-1j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	108 self.assertRaises(ZeroDivisionError, complex.__truediv__, 1+1j, 0+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	109
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	110 def test_floordiv(self):
42435 f6cc76e4ca25 Make test_complex pass again now that floordiv and mod are illegal. Guido van Rossum <guido@python.org> parents: 41904 diff changeset	111 self.assertRaises(TypeError, complex.__floordiv__, 3+0j, 1.5+0j)
f6cc76e4ca25 Make test_complex pass again now that floordiv and mod are illegal. Guido van Rossum <guido@python.org> parents: 41904 diff changeset	112 self.assertRaises(TypeError, complex.__floordiv__, 3+0j, 0+0j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	113
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	114 def test_richcompare(self):
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	115 self.assertRaises(OverflowError, complex.__eq__, 1+1j, 1<<10000)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	116 self.assertEqual(complex.__lt__(1+1j, None), NotImplemented)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	117 self.assertIs(complex.__eq__(1+1j, 1+1j), True)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	118 self.assertIs(complex.__eq__(1+1j, 2+2j), False)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	119 self.assertIs(complex.__ne__(1+1j, 1+1j), False)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	120 self.assertIs(complex.__ne__(1+1j, 2+2j), True)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	121 self.assertRaises(TypeError, complex.__lt__, 1+1j, 2+2j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	122 self.assertRaises(TypeError, complex.__le__, 1+1j, 2+2j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	123 self.assertRaises(TypeError, complex.__gt__, 1+1j, 2+2j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	124 self.assertRaises(TypeError, complex.__ge__, 1+1j, 2+2j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	125
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	126 def test_mod(self):
42435 f6cc76e4ca25 Make test_complex pass again now that floordiv and mod are illegal. Guido van Rossum <guido@python.org> parents: 41904 diff changeset	127 # % is no longer supported on complex numbers
f6cc76e4ca25 Make test_complex pass again now that floordiv and mod are illegal. Guido van Rossum <guido@python.org> parents: 41904 diff changeset	128 self.assertRaises(TypeError, (1+1j).__mod__, 0+0j)
f6cc76e4ca25 Make test_complex pass again now that floordiv and mod are illegal. Guido van Rossum <guido@python.org> parents: 41904 diff changeset	129 self.assertRaises(TypeError, lambda: (3.33+4.43j) % 0)
43284 1f9eee08ab35 Check in some documentation tweaks for PEP 3141, add some tests, and implement Jeffrey Yasskin <jyasskin@gmail.com> parents: 42911 diff changeset	130 self.assertRaises(TypeError, (1+1j).__mod__, 4.3j)
29867 199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	131
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	132 def test_divmod(self):
42435 f6cc76e4ca25 Make test_complex pass again now that floordiv and mod are illegal. Guido van Rossum <guido@python.org> parents: 41904 diff changeset	133 self.assertRaises(TypeError, divmod, 1+1j, 1+0j)
f6cc76e4ca25 Make test_complex pass again now that floordiv and mod are illegal. Guido van Rossum <guido@python.org> parents: 41904 diff changeset	134 self.assertRaises(TypeError, divmod, 1+1j, 0+0j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	135
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	136 def test_pow(self):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	137 self.assertAlmostEqual(pow(1+1j, 0+0j), 1.0)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	138 self.assertAlmostEqual(pow(0+0j, 2+0j), 0.0)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	139 self.assertRaises(ZeroDivisionError, pow, 0+0j, 1j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	140 self.assertAlmostEqual(pow(1j, -1), 1/1j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	141 self.assertAlmostEqual(pow(1j, 200), 1)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	142 self.assertRaises(ValueError, pow, 1+1j, 1+1j, 1+1j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	143
29867 199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	144 a = 3.33+4.43j
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	145 self.assertEqual(a ** 0j, 1)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	146 self.assertEqual(a ** 0.+0.j, 1)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	147
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	148 self.assertEqual(3j ** 0j, 1)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	149 self.assertEqual(3j ** 0, 1)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	150
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	151 try:
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	152 0j ** a
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	153 except ZeroDivisionError:
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	154 pass
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	155 else:
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	156 self.fail("should fail 0.0 to negative or complex power")
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	157
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	158 try:
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	159 0j ** (3-2j)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	160 except ZeroDivisionError:
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	161 pass
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	162 else:
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	163 self.fail("should fail 0.0 to negative or complex power")
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	164
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	165 # The following is used to exercise certain code paths
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	166 self.assertEqual(a 105, a 105)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	167 self.assertEqual(a -105, a -105)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	168 self.assertEqual(a -30, a -30)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	169
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	170 self.assertEqual(0.0j ** 0, 1)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	171
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	172 b = 5.1+2.3j
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	173 self.assertRaises(ValueError, pow, a, b, 0)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	174
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	175 def test_boolcontext(self):
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41575 diff changeset	176 for i in range(100):
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 54225 diff changeset	177 self.assertTrue(complex(random() + 1e-6, random() + 1e-6))
0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 54225 diff changeset	178 self.assertTrue(not complex(0.0, 0.0))
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	179
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	180 def test_conjugate(self):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	181 self.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j)
17066 2c1be7924b04 SF bug [ #409448 ] Complex division is braindead Tim Peters <tim.peters@gmail.com> parents: diff changeset	182
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	183 def test_constructor(self):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	184 class OS:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	185 def __init__(self, value): self.value = value
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	186 def __complex__(self): return self.value
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	187 class NS(object):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	188 def __init__(self, value): self.value = value
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	189 def __complex__(self): return self.value
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	190 self.assertEqual(complex(OS(1+10j)), 1+10j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	191 self.assertEqual(complex(NS(1+10j)), 1+10j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	192 self.assertRaises(TypeError, complex, OS(None))
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	193 self.assertRaises(TypeError, complex, NS(None))
17066 2c1be7924b04 SF bug [ #409448 ] Complex division is braindead Tim Peters <tim.peters@gmail.com> parents: diff changeset	194
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	195 self.assertAlmostEqual(complex("1+10j"), 1+10j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	196 self.assertAlmostEqual(complex(10), 10+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	197 self.assertAlmostEqual(complex(10.0), 10+0j)
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	198 self.assertAlmostEqual(complex(10), 10+0j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	199 self.assertAlmostEqual(complex(10+0j), 10+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	200 self.assertAlmostEqual(complex(1,10), 1+10j)
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	201 self.assertAlmostEqual(complex(1,10), 1+10j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	202 self.assertAlmostEqual(complex(1,10.0), 1+10j)
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	203 self.assertAlmostEqual(complex(1,10), 1+10j)
1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	204 self.assertAlmostEqual(complex(1,10), 1+10j)
1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	205 self.assertAlmostEqual(complex(1,10.0), 1+10j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	206 self.assertAlmostEqual(complex(1.0,10), 1+10j)
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	207 self.assertAlmostEqual(complex(1.0,10), 1+10j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	208 self.assertAlmostEqual(complex(1.0,10.0), 1+10j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	209 self.assertAlmostEqual(complex(3.14+0j), 3.14+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	210 self.assertAlmostEqual(complex(3.14), 3.14+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	211 self.assertAlmostEqual(complex(314), 314.0+0j)
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	212 self.assertAlmostEqual(complex(314), 314.0+0j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	213 self.assertAlmostEqual(complex(3.14+0j, 0j), 3.14+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	214 self.assertAlmostEqual(complex(3.14, 0.0), 3.14+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	215 self.assertAlmostEqual(complex(314, 0), 314.0+0j)
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	216 self.assertAlmostEqual(complex(314, 0), 314.0+0j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	217 self.assertAlmostEqual(complex(0j, 3.14j), -3.14+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	218 self.assertAlmostEqual(complex(0.0, 3.14j), -3.14+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	219 self.assertAlmostEqual(complex(0j, 3.14), 3.14j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	220 self.assertAlmostEqual(complex(0.0, 3.14), 3.14j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	221 self.assertAlmostEqual(complex("1"), 1+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	222 self.assertAlmostEqual(complex("1j"), 1j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	223 self.assertAlmostEqual(complex(), 0)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	224 self.assertAlmostEqual(complex("-1"), -1)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	225 self.assertAlmostEqual(complex("+1"), +1)
41554 06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	226 self.assertAlmostEqual(complex("(1+2j)"), 1+2j)
06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	227 self.assertAlmostEqual(complex("(1.3+2.2j)"), 1.3+2.2j)
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	228 self.assertAlmostEqual(complex("3.14+1J"), 3.14+1j)
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	229 self.assertAlmostEqual(complex(" ( +3.14-6J )"), 3.14-6j)
53343 06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	230 self.assertAlmostEqual(complex(" ( +3.14-J )"), 3.14-1j)
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	231 self.assertAlmostEqual(complex(" ( +3.14+j )"), 3.14+1j)
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	232 self.assertAlmostEqual(complex("J"), 1j)
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	233 self.assertAlmostEqual(complex("( j )"), 1j)
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	234 self.assertAlmostEqual(complex("+J"), 1j)
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	235 self.assertAlmostEqual(complex("( -j)"), -1j)
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	236 self.assertAlmostEqual(complex('1e-500'), 0.0 + 0.0j)
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	237 self.assertAlmostEqual(complex('-1e-500j'), 0.0 - 0.0j)
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	238 self.assertAlmostEqual(complex('-1e-500+1e-500j'), -0.0 + 0.0j)
17066 2c1be7924b04 SF bug [ #409448 ] Complex division is braindead Tim Peters <tim.peters@gmail.com> parents: diff changeset	239
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	240 class complex2(complex): pass
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	241 self.assertAlmostEqual(complex(complex2(1+1j)), 1+1j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	242 self.assertAlmostEqual(complex(real=17, imag=23), 17+23j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	243 self.assertAlmostEqual(complex(real=17+23j), 17+23j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	244 self.assertAlmostEqual(complex(real=17+23j, imag=23), 17+46j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	245 self.assertAlmostEqual(complex(real=1+2j, imag=3+4j), -3+5j)
21593 ff70e5634ae9 SF Patch #494873 add tests for complex numbers including calls to int()/long() Neal Norwitz <nnorwitz@gmail.com> parents: 21401 diff changeset	246
44045 530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	247 # check that the sign of a zero in the real or imaginary part
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	248 # is preserved when constructing from two floats. (These checks
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	249 # are harmless on systems without support for signed zeros.)
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	250 def split_zeros(x):
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	251 """Function that produces different results for 0. and -0."""
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	252 return atan2(x, -1.)
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	253
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	254 self.assertEqual(split_zeros(complex(1., 0.).imag), split_zeros(0.))
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	255 self.assertEqual(split_zeros(complex(1., -0.).imag), split_zeros(-0.))
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	256 self.assertEqual(split_zeros(complex(0., 1.).real), split_zeros(0.))
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	257 self.assertEqual(split_zeros(complex(-0., 1.).real), split_zeros(-0.))
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	258
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	259 c = 3.14 + 1j
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 54225 diff changeset	260 self.assertTrue(complex(c) is c)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	261 del c
21593 ff70e5634ae9 SF Patch #494873 add tests for complex numbers including calls to int()/long() Neal Norwitz <nnorwitz@gmail.com> parents: 21401 diff changeset	262
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	263 self.assertRaises(TypeError, complex, "1", "1")
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	264 self.assertRaises(TypeError, complex, 1, "1")
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	265
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	266 # SF bug 543840: complex(string) accepts strings with \0
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	267 # Fixed in 2.3.
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	268 self.assertRaises(ValueError, complex, '1+1j\0j')
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	269
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	270 self.assertRaises(TypeError, int, 5+3j)
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	271 self.assertRaises(TypeError, int, 5+3j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	272 self.assertRaises(TypeError, float, 5+3j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	273 self.assertRaises(ValueError, complex, "")
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	274 self.assertRaises(TypeError, complex, None)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	275 self.assertRaises(ValueError, complex, "\0")
41554 06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	276 self.assertRaises(ValueError, complex, "3\09")
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	277 self.assertRaises(TypeError, complex, "1", "2")
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	278 self.assertRaises(TypeError, complex, "1", 42)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	279 self.assertRaises(TypeError, complex, 1, "2")
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	280 self.assertRaises(ValueError, complex, "1+")
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	281 self.assertRaises(ValueError, complex, "1+1j+1j")
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	282 self.assertRaises(ValueError, complex, "--")
41554 06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	283 self.assertRaises(ValueError, complex, "(1+2j")
06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	284 self.assertRaises(ValueError, complex, "1+2j)")
06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	285 self.assertRaises(ValueError, complex, "1+(2j)")
06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	286 self.assertRaises(ValueError, complex, "(1+2j)123")
41821 ae691227fd34 Remove have_unicode checks and merge those tests into the Walter Dörwald <walter@livinglogic.de> parents: 41642 diff changeset	287 self.assertRaises(ValueError, complex, "1"*500)
ae691227fd34 Remove have_unicode checks and merge those tests into the Walter Dörwald <walter@livinglogic.de> parents: 41642 diff changeset	288 self.assertRaises(ValueError, complex, "x")
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	289 self.assertRaises(ValueError, complex, "1j+2")
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	290 self.assertRaises(ValueError, complex, "1e1ej")
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	291 self.assertRaises(ValueError, complex, "1e++1ej")
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	292 self.assertRaises(ValueError, complex, ")1+2j(")
53343 06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	293 # the following three are accepted by Python 2.6
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	294 self.assertRaises(ValueError, complex, "1..1j")
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	295 self.assertRaises(ValueError, complex, "1.11.1j")
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	296 self.assertRaises(ValueError, complex, "1e1.1j")
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	297
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	298 class EvilExc(Exception):
29668 36a17904a3ed Whitespace normalization. Tim Peters <tim.peters@gmail.com> parents: 29532 diff changeset	299 pass
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	300
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	301 class evilcomplex:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	302 def __complex__(self):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	303 raise EvilExc
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	304
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	305 self.assertRaises(EvilExc, complex, evilcomplex())
21593 ff70e5634ae9 SF Patch #494873 add tests for complex numbers including calls to int()/long() Neal Norwitz <nnorwitz@gmail.com> parents: 21401 diff changeset	306
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	307 class float2:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	308 def __init__(self, value):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	309 self.value = value
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	310 def __float__(self):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	311 return self.value
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	312
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	313 self.assertAlmostEqual(complex(float2(42.)), 42)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	314 self.assertAlmostEqual(complex(real=float2(17.), imag=float2(23.)), 17+23j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	315 self.assertRaises(TypeError, complex, float2(None))
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	316
34931 9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	317 class complex0(complex):
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	318 """Test usage of __complex__() when inheriting from 'complex'"""
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	319 def __complex__(self):
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	320 return 42j
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	321
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	322 class complex1(complex):
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	323 """Test usage of __complex__() with a __new__() method"""
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	324 def __new__(self, value=0j):
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	325 return complex.__new__(self, 2*value)
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	326 def __complex__(self):
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	327 return self
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	328
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	329 class complex2(complex):
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	330 """Make sure that __complex__() calls fail if anything other than a
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	331 complex is returned"""
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	332 def __complex__(self):
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	333 return None
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	334
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	335 self.assertAlmostEqual(complex(complex0(1j)), 42j)
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	336 self.assertAlmostEqual(complex(complex1(1j)), 2j)
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	337 self.assertRaises(TypeError, complex, complex2(1j))
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	338
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	339 def test_hash(self):
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41575 diff changeset	340 for x in range(-30, 30):
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	341 self.assertEqual(hash(x), hash(complex(x, 0)))
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	342 x /= 3.0 # now check against floating point
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	343 self.assertEqual(hash(x), hash(complex(x, 0.)))
21593 ff70e5634ae9 SF Patch #494873 add tests for complex numbers including calls to int()/long() Neal Norwitz <nnorwitz@gmail.com> parents: 21401 diff changeset	344
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	345 def test_abs(self):
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41575 diff changeset	346 nums = [complex(x/3., y/7.) for x in range(-9,9) for y in range(-9,9)]
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	347 for num in nums:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	348 self.assertAlmostEqual((num.real2 + num.imag2) ** 0.5, abs(num))
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	349
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	350 def test_repr(self):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	351 self.assertEqual(repr(1+6j), '(1+6j)')
33233 77d3642eb87b Fix repr for negative imaginary part. Fixes #1013908. Martin v. Löwis <martin@v.loewis.de> parents: 30071 diff changeset	352 self.assertEqual(repr(1-6j), '(1-6j)')
17066 2c1be7924b04 SF bug [ #409448 ] Complex division is braindead Tim Peters <tim.peters@gmail.com> parents: diff changeset	353
35586 e6119d577cd3 Test case for latest complexobject fix. Georg Brandl <georg@python.org> parents: 34931 diff changeset	354 self.assertNotEqual(repr(-(1+0j)), '(-1+-0j)')
e6119d577cd3 Test case for latest complexobject fix. Georg Brandl <georg@python.org> parents: 34931 diff changeset	355
41554 06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	356 self.assertEqual(1-6j,complex(repr(1-6j)))
06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	357 self.assertEqual(1+6j,complex(repr(1+6j)))
06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	358 self.assertEqual(-6j,complex(repr(-6j)))
06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	359 self.assertEqual(6j,complex(repr(6j)))
06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	360
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	361 self.assertEqual(repr(complex(1., INF)), "(1+infj)")
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	362 self.assertEqual(repr(complex(1., -INF)), "(1-infj)")
45371 7c4c46342137 Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617,60619-60621,60623-60625,60627-60629,60631,60633,60635,60647,60650,60652,60654,60656,60658-60659,60664-60666,60668-60670,60672,60676,60678,60680-60683,60685-60686,60688,60690,60692-60694,60697-60700,60705-60706,60708,60711,60714,60720,60724-60730,60732,60736,60742,60744,60746,60748,60750-60751,60753,60756-60757,60759-60761,60763-60764,60766,60769-60770,60774-60784,60787-60845 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45082 diff changeset	363 self.assertEqual(repr(complex(INF, 1)), "(inf+1j)")
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	364 self.assertEqual(repr(complex(-INF, INF)), "(-inf+infj)")
45371 7c4c46342137 Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617,60619-60621,60623-60625,60627-60629,60631,60633,60635,60647,60650,60652,60654,60656,60658-60659,60664-60666,60668-60670,60672,60676,60678,60680-60683,60685-60686,60688,60690,60692-60694,60697-60700,60705-60706,60708,60711,60714,60720,60724-60730,60732,60736,60742,60744,60746,60748,60750-60751,60753,60756-60757,60759-60761,60763-60764,60766,60769-60770,60774-60784,60787-60845 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45082 diff changeset	365 self.assertEqual(repr(complex(NAN, 1)), "(nan+1j)")
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	366 self.assertEqual(repr(complex(1, NAN)), "(1+nanj)")
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	367 self.assertEqual(repr(complex(NAN, NAN)), "(nan+nanj)")
45371 7c4c46342137 Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617,60619-60621,60623-60625,60627-60629,60631,60633,60635,60647,60650,60652,60654,60656,60658-60659,60664-60666,60668-60670,60672,60676,60678,60680-60683,60685-60686,60688,60690,60692-60694,60697-60700,60705-60706,60708,60711,60714,60720,60724-60730,60732,60736,60742,60744,60746,60748,60750-60751,60753,60756-60757,60759-60761,60763-60764,60766,60769-60770,60774-60784,60787-60845 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45082 diff changeset	368
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	369 self.assertEqual(repr(complex(0, INF)), "infj")
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	370 self.assertEqual(repr(complex(0, -INF)), "-infj")
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	371 self.assertEqual(repr(complex(0, NAN)), "nanj")
45371 7c4c46342137 Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617,60619-60621,60623-60625,60627-60629,60631,60633,60635,60647,60650,60652,60654,60656,60658-60659,60664-60666,60668-60670,60672,60676,60678,60680-60683,60685-60686,60688,60690,60692-60694,60697-60700,60705-60706,60708,60711,60714,60720,60724-60730,60732,60736,60742,60744,60746,60748,60750-60751,60753,60756-60757,60759-60761,60763-60764,60766,60769-60770,60774-60784,60787-60845 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45082 diff changeset	372
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	373 def test_neg(self):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	374 self.assertEqual(-(1+6j), -1-6j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	375
29867 199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	376 def test_file(self):
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	377 a = 3.33+4.43j
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	378 b = 5.1+2.3j
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	379
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	380 fo = None
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	381 try:
47201 9c930a32cebb #2621 rename test.test_support to test.support Benjamin Peterson <benjamin@python.org> parents: 45371 diff changeset	382 fo = open(support.TESTFN, "w")
40775 4cdf21a0dbbc Fix most trivially-findable print statements. Guido van Rossum <guido@python.org> parents: 40644 diff changeset	383 print(a, b, file=fo)
29867 199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	384 fo.close()
47201 9c930a32cebb #2621 rename test.test_support to test.support Benjamin Peterson <benjamin@python.org> parents: 45371 diff changeset	385 fo = open(support.TESTFN, "r")
42911 cb28e14ee808 Changes in anticipation of stricter str vs. bytes enforcement. Guido van Rossum <guido@python.org> parents: 42902 diff changeset	386 self.assertEqual(fo.read(), ("%s %s\n" % (a, b)))
29867 199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	387 finally:
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	388 if (fo is not None) and (not fo.closed):
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	389 fo.close()
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	390 try:
47201 9c930a32cebb #2621 rename test.test_support to test.support Benjamin Peterson <benjamin@python.org> parents: 45371 diff changeset	391 os.remove(support.TESTFN)
29867 199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	392 except (OSError, IOError):
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	393 pass
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	394
47555 7d824fd131ad Merged revisions 63829-63831,63858,63865,63879,63882,63948,63970-63972,63976,63989,64014-64015,64021-64022,64063-64065,64067 via svnmerge from Georg Brandl <georg@python.org> parents: 47201 diff changeset	395 def test_getnewargs(self):
7d824fd131ad Merged revisions 63829-63831,63858,63865,63879,63882,63948,63970-63972,63976,63989,64014-64015,64021-64022,64063-64065,64067 via svnmerge from Georg Brandl <georg@python.org> parents: 47201 diff changeset	396 self.assertEqual((1+2j).__getnewargs__(), (1.0, 2.0))
7d824fd131ad Merged revisions 63829-63831,63858,63865,63879,63882,63948,63970-63972,63976,63989,64014-64015,64021-64022,64063-64065,64067 via svnmerge from Georg Brandl <georg@python.org> parents: 47201 diff changeset	397 self.assertEqual((1-2j).__getnewargs__(), (1.0, -2.0))
7d824fd131ad Merged revisions 63829-63831,63858,63865,63879,63882,63948,63970-63972,63976,63989,64014-64015,64021-64022,64063-64065,64067 via svnmerge from Georg Brandl <georg@python.org> parents: 47201 diff changeset	398 self.assertEqual((2j).__getnewargs__(), (0.0, 2.0))
7d824fd131ad Merged revisions 63829-63831,63858,63865,63879,63882,63948,63970-63972,63976,63989,64014-64015,64021-64022,64063-64065,64067 via svnmerge from Georg Brandl <georg@python.org> parents: 47201 diff changeset	399 self.assertEqual((-0j).__getnewargs__(), (0.0, -0.0))
7d824fd131ad Merged revisions 63829-63831,63858,63865,63879,63882,63948,63970-63972,63976,63989,64014-64015,64021-64022,64063-64065,64067 via svnmerge from Georg Brandl <georg@python.org> parents: 47201 diff changeset	400 self.assertEqual(complex(0, INF).__getnewargs__(), (0.0, INF))
7d824fd131ad Merged revisions 63829-63831,63858,63865,63879,63882,63948,63970-63972,63976,63989,64014-64015,64021-64022,64063-64065,64067 via svnmerge from Georg Brandl <georg@python.org> parents: 47201 diff changeset	401 self.assertEqual(complex(INF, 0).__getnewargs__(), (INF, 0.0))
7d824fd131ad Merged revisions 63829-63831,63858,63865,63879,63882,63948,63970-63972,63976,63989,64014-64015,64021-64022,64063-64065,64067 via svnmerge from Georg Brandl <georg@python.org> parents: 47201 diff changeset	402
45082 d7540031b959 Merged revisions 60475-60479,60481-60488 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44045 diff changeset	403 if float.__getformat__("double").startswith("IEEE"):
d7540031b959 Merged revisions 60475-60479,60481-60488 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44045 diff changeset	404 def test_plus_minus_0j(self):
d7540031b959 Merged revisions 60475-60479,60481-60488 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44045 diff changeset	405 # test that -0j and 0j literals are not identified
d7540031b959 Merged revisions 60475-60479,60481-60488 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44045 diff changeset	406 z1, z2 = 0j, -0j
d7540031b959 Merged revisions 60475-60479,60481-60488 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44045 diff changeset	407 self.assertEquals(atan2(z1.imag, -1.), atan2(0., -1.))
d7540031b959 Merged revisions 60475-60479,60481-60488 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44045 diff changeset	408 self.assertEquals(atan2(z2.imag, -1.), atan2(-0., -1.))
d7540031b959 Merged revisions 60475-60479,60481-60488 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44045 diff changeset	409
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	410 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	411 "test requires IEEE 754 doubles")
54225 670fa0c0ff9a Issue #5829: complex('1e500') shouldn't raise OverflowError Mark Dickinson <dickinsm@gmail.com> parents: 53849 diff changeset	412 def test_overflow(self):
670fa0c0ff9a Issue #5829: complex('1e500') shouldn't raise OverflowError Mark Dickinson <dickinsm@gmail.com> parents: 53849 diff changeset	413 self.assertEqual(complex("1e500"), complex(INF, 0.0))
670fa0c0ff9a Issue #5829: complex('1e500') shouldn't raise OverflowError Mark Dickinson <dickinsm@gmail.com> parents: 53849 diff changeset	414 self.assertEqual(complex("-1e500j"), complex(0.0, -INF))
670fa0c0ff9a Issue #5829: complex('1e500') shouldn't raise OverflowError Mark Dickinson <dickinsm@gmail.com> parents: 53849 diff changeset	415 self.assertEqual(complex("-1e500+1.8e308j"), complex(-INF, INF))
670fa0c0ff9a Issue #5829: complex('1e500') shouldn't raise OverflowError Mark Dickinson <dickinsm@gmail.com> parents: 53849 diff changeset	416
670fa0c0ff9a Issue #5829: complex('1e500') shouldn't raise OverflowError Mark Dickinson <dickinsm@gmail.com> parents: 53849 diff changeset	417 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
670fa0c0ff9a Issue #5829: complex('1e500') shouldn't raise OverflowError Mark Dickinson <dickinsm@gmail.com> parents: 53849 diff changeset	418 "test requires IEEE 754 doubles")
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	419 def test_repr_roundtrip(self):
53377 a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	420 vals = [0.0, 1e-500, 1e-315, 1e-200, 0.0123, 3.1415, 1e50, INF, NAN]
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	421 vals += [-v for v in vals]
53377 a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	422
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	423 # complex(repr(z)) should recover z exactly, even for complex
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	424 # numbers involving an infinity, nan, or negative zero
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	425 for x in vals:
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	426 for y in vals:
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	427 z = complex(x, y)
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	428 roundtrip = complex(repr(z))
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	429 self.assertFloatsAreIdentical(z.real, roundtrip.real)
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	430 self.assertFloatsAreIdentical(z.imag, roundtrip.imag)
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	431
53377 a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	432 # if we predefine some constants, then eval(repr(z)) should
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	433 # also work, except that it might change the sign of zeros
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	434 inf, nan = float('inf'), float('nan')
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	435 infj, nanj = complex(0.0, inf), complex(0.0, nan)
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	436 for x in vals:
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	437 for y in vals:
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	438 z = complex(x, y)
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	439 roundtrip = eval(repr(z))
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	440 # adding 0.0 has no effect beside changing -0.0 to 0.0
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	441 self.assertFloatsAreIdentical(0.0 + z.real,
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	442 0.0 + roundtrip.real)
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	443 self.assertFloatsAreIdentical(0.0 + z.imag,
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	444 0.0 + roundtrip.imag)
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	445
53632 2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	446 def test_format(self):
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	447 # empty format string is same as str()
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	448 self.assertEqual(format(1+3j, ''), str(1+3j))
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	449 self.assertEqual(format(1.5+3.5j, ''), str(1.5+3.5j))
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	450 self.assertEqual(format(3j, ''), str(3j))
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	451 self.assertEqual(format(3.2j, ''), str(3.2j))
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	452 self.assertEqual(format(3+0j, ''), str(3+0j))
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	453 self.assertEqual(format(3.2+0j, ''), str(3.2+0j))
53377 a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	454
53787 c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	455 # empty presentation type should still be analogous to str,
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	456 # even when format string is nonempty (issue #5920).
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	457 self.assertEqual(format(3.2+0j, '-'), str(3.2+0j))
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	458 self.assertEqual(format(3.2+0j, '<'), str(3.2+0j))
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	459 z = 4/7. - 100j/7.
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	460 self.assertEqual(format(z, ''), str(z))
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	461 self.assertEqual(format(z, '-'), str(z))
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	462 self.assertEqual(format(z, '<'), str(z))
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	463 self.assertEqual(format(z, '10'), str(z))
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	464
53632 2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	465 self.assertEqual(format(1+3j, 'g'), '1+3j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	466 self.assertEqual(format(3j, 'g'), '0+3j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	467 self.assertEqual(format(1.5+3.5j, 'g'), '1.5+3.5j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	468
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	469 self.assertEqual(format(1.5+3.5j, '+g'), '+1.5+3.5j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	470 self.assertEqual(format(1.5-3.5j, '+g'), '+1.5-3.5j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	471 self.assertEqual(format(1.5-3.5j, '-g'), '1.5-3.5j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	472 self.assertEqual(format(1.5+3.5j, ' g'), ' 1.5+3.5j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	473 self.assertEqual(format(1.5-3.5j, ' g'), ' 1.5-3.5j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	474 self.assertEqual(format(-1.5+3.5j, ' g'), '-1.5+3.5j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	475 self.assertEqual(format(-1.5-3.5j, ' g'), '-1.5-3.5j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	476
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	477 self.assertEqual(format(-1.5-3.5e-20j, 'g'), '-1.5-3.5e-20j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	478 self.assertEqual(format(-1.5-3.5j, 'f'), '-1.500000-3.500000j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	479 self.assertEqual(format(-1.5-3.5j, 'F'), '-1.500000-3.500000j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	480 self.assertEqual(format(-1.5-3.5j, 'e'), '-1.500000e+00-3.500000e+00j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	481 self.assertEqual(format(-1.5-3.5j, '.2e'), '-1.50e+00-3.50e+00j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	482 self.assertEqual(format(-1.5-3.5j, '.2E'), '-1.50E+00-3.50E+00j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	483 self.assertEqual(format(-1.5e10-3.5e5j, '.2G'), '-1.5E+10-3.5E+05j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	484
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	485 self.assertEqual(format(1.5+3j, '<20g'), '1.5+3j ')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	486 self.assertEqual(format(1.5+3j, '<20g'), '1.5+3j*************')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	487 self.assertEqual(format(1.5+3j, '>20g'), ' 1.5+3j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	488 self.assertEqual(format(1.5+3j, '^20g'), ' 1.5+3j ')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	489 self.assertEqual(format(1.5+3j, '<20'), '(1.5+3j) ')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	490 self.assertEqual(format(1.5+3j, '>20'), ' (1.5+3j)')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	491 self.assertEqual(format(1.5+3j, '^20'), ' (1.5+3j) ')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	492 self.assertEqual(format(1.123-3.123j, '^20.2'), ' (1.1-3.1j) ')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	493
59028 73cd83706bc4 Merged revisions 78333 via svnmerge from Eric Smith <eric@trueblade.com> parents: 55593 diff changeset	494 self.assertEqual(format(1.5+3j, '20.2f'), ' 1.50+3.00j')
73cd83706bc4 Merged revisions 78333 via svnmerge from Eric Smith <eric@trueblade.com> parents: 55593 diff changeset	495 self.assertEqual(format(1.5+3j, '>20.2f'), ' 1.50+3.00j')
53632 2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	496 self.assertEqual(format(1.5+3j, '<20.2f'), '1.50+3.00j ')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	497 self.assertEqual(format(1.5e20+3j, '<20.2f'), '150000000000000000000.00+3.00j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	498 self.assertEqual(format(1.5e20+3j, '>40.2f'), ' 150000000000000000000.00+3.00j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	499 self.assertEqual(format(1.5e20+3j, '^40,.2f'), ' 150,000,000,000,000,000,000.00+3.00j ')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	500 self.assertEqual(format(1.5e21+3j, '^40,.2f'), ' 1,500,000,000,000,000,000,000.00+3.00j ')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	501 self.assertEqual(format(1.5e21+3000j, ',.2f'), '1,500,000,000,000,000,000,000.00+3,000.00j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	502
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	503 # alternate is invalid
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	504 self.assertRaises(ValueError, (1.5+0.5j).__format__, '#f')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	505
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	506 # zero padding is invalid
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	507 self.assertRaises(ValueError, (1.5+0.5j).__format__, '010f')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	508
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	509 # '=' alignment is invalid
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	510 self.assertRaises(ValueError, (1.5+3j).__format__, '=20')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	511
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	512 # integer presentation types are an error
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	513 for t in 'bcdoxX':
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	514 self.assertRaises(ValueError, (1.5+0.5j).__format__, t)
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	515
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	516 # make sure everything works in ''.format()
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	517 self.assertEqual('{0:.3f}'.format(3.14159+2.71828j), '3.142+2.718j')
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	518
53849 04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	519 # issue 3382
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	520 self.assertEqual(format(complex(NAN, NAN), 'f'), 'nan+nanj')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	521 self.assertEqual(format(complex(1, NAN), 'f'), '1.000000+nanj')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	522 self.assertEqual(format(complex(NAN, 1), 'f'), 'nan+1.000000j')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	523 self.assertEqual(format(complex(NAN, -1), 'f'), 'nan-1.000000j')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	524 self.assertEqual(format(complex(NAN, NAN), 'F'), 'NAN+NANj')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	525 self.assertEqual(format(complex(1, NAN), 'F'), '1.000000+NANj')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	526 self.assertEqual(format(complex(NAN, 1), 'F'), 'NAN+1.000000j')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	527 self.assertEqual(format(complex(NAN, -1), 'F'), 'NAN-1.000000j')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	528 self.assertEqual(format(complex(INF, INF), 'f'), 'inf+infj')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	529 self.assertEqual(format(complex(1, INF), 'f'), '1.000000+infj')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	530 self.assertEqual(format(complex(INF, 1), 'f'), 'inf+1.000000j')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	531 self.assertEqual(format(complex(INF, -1), 'f'), 'inf-1.000000j')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	532 self.assertEqual(format(complex(INF, INF), 'F'), 'INF+INFj')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	533 self.assertEqual(format(complex(1, INF), 'F'), '1.000000+INFj')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	534 self.assertEqual(format(complex(INF, 1), 'F'), 'INF+1.000000j')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	535 self.assertEqual(format(complex(INF, -1), 'F'), 'INF-1.000000j')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	536
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	537 def test_main():
47201 9c930a32cebb #2621 rename test.test_support to test.support Benjamin Peterson <benjamin@python.org> parents: 45371 diff changeset	538 support.run_unittest(ComplexTest)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	539
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	540 if __name__ == "__main__":
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	541 test_main()

Mercurial > cpython-lru_cache-weakref

annotate Lib/test/test_complex.py @ 59028:73cd83706bc4 3.1