| import errno | |
| import unittest | |
| import sys | |
| from test import support | |
| from test.support import import_helper | |
| from test.support.testcase import ComplexesAreIdenticalMixin | |
| from test.support.numbers import ( | |
| VALID_UNDERSCORE_LITERALS, | |
| INVALID_UNDERSCORE_LITERALS, | |
| ) | |
| from random import random | |
| from math import isnan, copysign | |
| import cmath | |
| import operator | |
| INF = float("inf") | |
| NAN = float("nan") | |
| DBL_MAX = sys.float_info.max | |
| # These tests ensure that complex math does the right thing | |
| ZERO_DIVISION = ( | |
| (1+1j, 0+0j), | |
| (1+1j, 0.0), | |
| (1+1j, 0), | |
| (1.0, 0+0j), | |
| (1, 0+0j), | |
| ) | |
| class WithIndex: | |
| def __init__(self, value): | |
| self.value = value | |
| def __index__(self): | |
| return self.value | |
| class WithFloat: | |
| def __init__(self, value): | |
| self.value = value | |
| def __float__(self): | |
| return self.value | |
| class ComplexSubclass(complex): | |
| pass | |
| class OtherComplexSubclass(complex): | |
| pass | |
| class MyInt: | |
| def __init__(self, value): | |
| self.value = value | |
| def __int__(self): | |
| return self.value | |
| class WithComplex: | |
| def __init__(self, value): | |
| self.value = value | |
| def __complex__(self): | |
| return self.value | |
| class ComplexTest(ComplexesAreIdenticalMixin, unittest.TestCase): | |
| def assertAlmostEqual(self, a, b): | |
| if isinstance(a, complex): | |
| if isinstance(b, complex): | |
| unittest.TestCase.assertAlmostEqual(self, a.real, b.real) | |
| unittest.TestCase.assertAlmostEqual(self, a.imag, b.imag) | |
| else: | |
| unittest.TestCase.assertAlmostEqual(self, a.real, b) | |
| unittest.TestCase.assertAlmostEqual(self, a.imag, 0.) | |
| else: | |
| if isinstance(b, complex): | |
| unittest.TestCase.assertAlmostEqual(self, a, b.real) | |
| unittest.TestCase.assertAlmostEqual(self, 0., b.imag) | |
| else: | |
| unittest.TestCase.assertAlmostEqual(self, a, b) | |
| def assertClose(self, x, y, eps=1e-9): | |
| """Return true iff complexes x and y "are close".""" | |
| # put the one with larger magnitude second | |
| if abs(x) > abs(y): | |
| x, y = y, x | |
| if y == 0: | |
| return abs(x) < eps | |
| if x == 0: | |
| return abs(y) < eps | |
| # check that relative difference < eps | |
| self.assertTrue(abs(x-y)/abs(y) < eps) | |
| def assertSameSign(self, x, y): | |
| if copysign(1., x) != copysign(1., y): | |
| self.fail(f'{x!r} and {y!r} have different signs') | |
| def check_div(self, x, y): | |
| """Compute complex z=x*y, and check that z/x==y and z/y==x.""" | |
| z = x * y | |
| if x: | |
| self.assertClose(z / x, y) | |
| if y: | |
| self.assertClose(z / y, x) | |
| def test_truediv(self): | |
| simple_real = [float(i) for i in range(-5, 6)] | |
| simple_complex = [complex(x, y) for x in simple_real for y in simple_real] | |
| for x in simple_complex: | |
| for y in simple_complex: | |
| self.check_div(x, y) | |
| # A naive complex division algorithm (such as in 2.0) is very prone to | |
| # nonsense errors for these (overflows and underflows). | |
| self.check_div(complex(1e200, 1e200), 1+0j) | |
| self.check_div(complex(1e-200, 1e-200), 1+0j) | |
| # Smith's algorithm has several sources of inaccuracy | |
| # for components of the result. In examples below, | |
| # it's cancellation of digits in computation of sum. | |
| self.check_div(1e-09+1j, 1+1j) | |
| self.check_div(8.289760544677449e-09+0.13257307440728516j, | |
| 0.9059966714925808+0.5054864708672686j) | |
| # Just for fun. | |
| for i in range(100): | |
| x = complex(random(), random()) | |
| y = complex(random(), random()) | |
| self.check_div(x, y) | |
| y = complex(1e10*y.real, y.imag) | |
| self.check_div(x, y) | |
| self.assertAlmostEqual(complex.__truediv__(2+0j, 1+1j), 1-1j) | |
| self.assertRaises(TypeError, operator.truediv, 1j, None) | |
| self.assertRaises(TypeError, operator.truediv, None, 1j) | |
| for denom_real, denom_imag in [(0, NAN), (NAN, 0), (NAN, NAN)]: | |
| z = complex(0, 0) / complex(denom_real, denom_imag) | |
| self.assertTrue(isnan(z.real)) | |
| self.assertTrue(isnan(z.imag)) | |
| z = float(0) / complex(denom_real, denom_imag) | |
| self.assertTrue(isnan(z.real)) | |
| self.assertTrue(isnan(z.imag)) | |
| self.assertComplexesAreIdentical(complex(INF, NAN) / 2, | |
| complex(INF, NAN)) | |
| self.assertComplexesAreIdentical(complex(INF, 1)/(0.0+1j), | |
| complex(NAN, -INF)) | |
| # test recover of infs if numerator has infs and denominator is finite | |
| self.assertComplexesAreIdentical(complex(INF, -INF)/(1+0j), | |
| complex(INF, -INF)) | |
| self.assertComplexesAreIdentical(complex(INF, INF)/(0.0+1j), | |
| complex(INF, -INF)) | |
| self.assertComplexesAreIdentical(complex(NAN, INF)/complex(2**1000, 2**-1000), | |
| complex(INF, INF)) | |
| self.assertComplexesAreIdentical(complex(INF, NAN)/complex(2**1000, 2**-1000), | |
| complex(INF, -INF)) | |
| # test recover of zeros if denominator is infinite | |
| self.assertComplexesAreIdentical((1+1j)/complex(INF, INF), (0.0+0j)) | |
| self.assertComplexesAreIdentical((1+1j)/complex(INF, -INF), (0.0+0j)) | |
| self.assertComplexesAreIdentical((1+1j)/complex(-INF, INF), | |
| complex(0.0, -0.0)) | |
| self.assertComplexesAreIdentical((1+1j)/complex(-INF, -INF), | |
| complex(-0.0, 0)) | |
| self.assertComplexesAreIdentical((INF+1j)/complex(INF, INF), | |
| complex(NAN, NAN)) | |
| self.assertComplexesAreIdentical(complex(1, INF)/complex(INF, INF), | |
| complex(NAN, NAN)) | |
| self.assertComplexesAreIdentical(complex(INF, 1)/complex(1, INF), | |
| complex(NAN, NAN)) | |
| # mixed types | |
| self.assertEqual((1+1j)/float(2), 0.5+0.5j) | |
| self.assertEqual(float(1)/(1+2j), 0.2-0.4j) | |
| self.assertEqual(float(1)/(-1+2j), -0.2-0.4j) | |
| self.assertEqual(float(1)/(1-2j), 0.2+0.4j) | |
| self.assertEqual(float(1)/(2+1j), 0.4-0.2j) | |
| self.assertEqual(float(1)/(-2+1j), -0.4-0.2j) | |
| self.assertEqual(float(1)/(2-1j), 0.4+0.2j) | |
| self.assertComplexesAreIdentical(INF/(1+0j), | |
| complex(INF, NAN)) | |
| self.assertComplexesAreIdentical(INF/(0.0+1j), | |
| complex(NAN, -INF)) | |
| self.assertComplexesAreIdentical(INF/complex(2**1000, 2**-1000), | |
| complex(INF, NAN)) | |
| self.assertComplexesAreIdentical(INF/complex(NAN, NAN), | |
| complex(NAN, NAN)) | |
| self.assertComplexesAreIdentical(float(1)/complex(INF, INF), (0.0-0j)) | |
| self.assertComplexesAreIdentical(float(1)/complex(INF, -INF), (0.0+0j)) | |
| self.assertComplexesAreIdentical(float(1)/complex(-INF, INF), | |
| complex(-0.0, -0.0)) | |
| self.assertComplexesAreIdentical(float(1)/complex(-INF, -INF), | |
| complex(-0.0, 0)) | |
| self.assertComplexesAreIdentical(float(1)/complex(INF, NAN), | |
| complex(0.0, -0.0)) | |
| self.assertComplexesAreIdentical(float(1)/complex(-INF, NAN), | |
| complex(-0.0, -0.0)) | |
| self.assertComplexesAreIdentical(float(1)/complex(NAN, INF), | |
| complex(0.0, -0.0)) | |
| self.assertComplexesAreIdentical(float(INF)/complex(NAN, INF), | |
| complex(NAN, NAN)) | |
| def test_truediv_zero_division(self): | |
| for a, b in ZERO_DIVISION: | |
| with self.assertRaises(ZeroDivisionError): | |
| a / b | |
| def test_floordiv(self): | |
| with self.assertRaises(TypeError): | |
| (1+1j) // (1+0j) | |
| with self.assertRaises(TypeError): | |
| (1+1j) // 1.0 | |
| with self.assertRaises(TypeError): | |
| (1+1j) // 1 | |
| with self.assertRaises(TypeError): | |
| 1.0 // (1+0j) | |
| with self.assertRaises(TypeError): | |
| 1 // (1+0j) | |
| def test_floordiv_zero_division(self): | |
| for a, b in ZERO_DIVISION: | |
| with self.assertRaises(TypeError): | |
| a // b | |
| def test_richcompare(self): | |
| self.assertIs(complex.__eq__(1+1j, 1<<10000), False) | |
| self.assertIs(complex.__lt__(1+1j, None), NotImplemented) | |
| self.assertIs(complex.__eq__(1+1j, None), NotImplemented) | |
| self.assertIs(complex.__eq__(1+1j, 1+1j), True) | |
| self.assertIs(complex.__eq__(1+1j, 2+2j), False) | |
| self.assertIs(complex.__ne__(1+1j, 1+1j), False) | |
| self.assertIs(complex.__ne__(1+1j, 2+2j), True) | |
| for i in range(1, 100): | |
| f = i / 100.0 | |
| self.assertIs(complex.__eq__(f+0j, f), True) | |
| self.assertIs(complex.__ne__(f+0j, f), False) | |
| self.assertIs(complex.__eq__(complex(f, f), f), False) | |
| self.assertIs(complex.__ne__(complex(f, f), f), True) | |
| self.assertIs(complex.__lt__(1+1j, 2+2j), NotImplemented) | |
| self.assertIs(complex.__le__(1+1j, 2+2j), NotImplemented) | |
| self.assertIs(complex.__gt__(1+1j, 2+2j), NotImplemented) | |
| self.assertIs(complex.__ge__(1+1j, 2+2j), NotImplemented) | |
| self.assertRaises(TypeError, operator.lt, 1+1j, 2+2j) | |
| self.assertRaises(TypeError, operator.le, 1+1j, 2+2j) | |
| self.assertRaises(TypeError, operator.gt, 1+1j, 2+2j) | |
| self.assertRaises(TypeError, operator.ge, 1+1j, 2+2j) | |
| self.assertIs(operator.eq(1+1j, 1+1j), True) | |
| self.assertIs(operator.eq(1+1j, 2+2j), False) | |
| self.assertIs(operator.ne(1+1j, 1+1j), False) | |
| self.assertIs(operator.ne(1+1j, 2+2j), True) | |
| self.assertIs(operator.eq(1+1j, 2.0), False) | |
| def test_richcompare_boundaries(self): | |
| def check(n, deltas, is_equal, imag = 0.0): | |
| for delta in deltas: | |
| i = n + delta | |
| z = complex(i, imag) | |
| self.assertIs(complex.__eq__(z, i), is_equal(delta)) | |
| self.assertIs(complex.__ne__(z, i), not is_equal(delta)) | |
| # For IEEE-754 doubles the following should hold: | |
| # x in [2 ** (52 + i), 2 ** (53 + i + 1)] -> x mod 2 ** i == 0 | |
| # where the interval is representable, of course. | |
| for i in range(1, 10): | |
| pow = 52 + i | |
| mult = 2 ** i | |
| check(2 ** pow, range(1, 101), lambda delta: delta % mult == 0) | |
| check(2 ** pow, range(1, 101), lambda delta: False, float(i)) | |
| check(2 ** 53, range(-100, 0), lambda delta: True) | |
| def test_add(self): | |
| self.assertEqual(1j + int(+1), complex(+1, 1)) | |
| self.assertEqual(1j + int(-1), complex(-1, 1)) | |
| self.assertComplexesAreIdentical(complex(-0.0, -0.0) + (-0.0), | |
| complex(-0.0, -0.0)) | |
| self.assertComplexesAreIdentical((-0.0) + complex(-0.0, -0.0), | |
| complex(-0.0, -0.0)) | |
| self.assertRaises(OverflowError, operator.add, 1j, 10**1000) | |
| self.assertRaises(TypeError, operator.add, 1j, None) | |
| self.assertRaises(TypeError, operator.add, None, 1j) | |
| def test_sub(self): | |
| self.assertEqual(1j - int(+1), complex(-1, 1)) | |
| self.assertEqual(1j - int(-1), complex(1, 1)) | |
| self.assertComplexesAreIdentical(complex(-0.0, -0.0) - 0.0, | |
| complex(-0.0, -0.0)) | |
| self.assertComplexesAreIdentical(-0.0 - complex(0.0, 0.0), | |
| complex(-0.0, -0.0)) | |
| self.assertComplexesAreIdentical(complex(1, 2) - complex(2, 1), | |
| complex(-1, 1)) | |
| self.assertComplexesAreIdentical(complex(2, 1) - complex(1, 2), | |
| complex(1, -1)) | |
| self.assertRaises(OverflowError, operator.sub, 1j, 10**1000) | |
| self.assertRaises(TypeError, operator.sub, 1j, None) | |
| self.assertRaises(TypeError, operator.sub, None, 1j) | |
| def test_mul(self): | |
| self.assertEqual(1j * int(20), complex(0, 20)) | |
| self.assertEqual(1j * int(-1), complex(0, -1)) | |
| for c, r in [(2, complex(INF, 2)), (INF, complex(INF, INF)), | |
| (0, complex(NAN, 0)), (-0.0, complex(NAN, -0.0)), | |
| (NAN, complex(NAN, NAN))]: | |
| with self.subTest(c=c, r=r): | |
| self.assertComplexesAreIdentical(complex(INF, 1) * c, r) | |
| self.assertComplexesAreIdentical(c * complex(INF, 1), r) | |
| self.assertRaises(OverflowError, operator.mul, 1j, 10**1000) | |
| self.assertRaises(TypeError, operator.mul, 1j, None) | |
| self.assertRaises(TypeError, operator.mul, None, 1j) | |
| for z, w, r in [(1e300+1j, complex(INF, INF), complex(NAN, INF)), | |
| (1e300+1j, complex(NAN, INF), complex(-INF, INF)), | |
| (1e300+1j, complex(INF, NAN), complex(INF, INF)), | |
| (complex(INF, 1), complex(NAN, INF), complex(NAN, INF)), | |
| (complex(INF, 1), complex(INF, NAN), complex(INF, NAN)), | |
| (complex(NAN, 1), complex(1, INF), complex(-INF, NAN)), | |
| (complex(1, NAN), complex(1, INF), complex(NAN, INF)), | |
| (complex(1e200, NAN), complex(1e200, NAN), complex(INF, NAN)), | |
| (complex(1e200, NAN), complex(NAN, 1e200), complex(NAN, INF)), | |
| (complex(NAN, 1e200), complex(1e200, NAN), complex(NAN, INF)), | |
| (complex(NAN, 1e200), complex(NAN, 1e200), complex(-INF, NAN)), | |
| (complex(NAN, NAN), complex(NAN, NAN), complex(NAN, NAN))]: | |
| with self.subTest(z=z, w=w, r=r): | |
| self.assertComplexesAreIdentical(z * w, r) | |
| self.assertComplexesAreIdentical(w * z, r) | |
| def test_mod(self): | |
| # % is no longer supported on complex numbers | |
| with self.assertRaises(TypeError): | |
| (1+1j) % (1+0j) | |
| with self.assertRaises(TypeError): | |
| (1+1j) % 1.0 | |
| with self.assertRaises(TypeError): | |
| (1+1j) % 1 | |
| with self.assertRaises(TypeError): | |
| 1.0 % (1+0j) | |
| with self.assertRaises(TypeError): | |
| 1 % (1+0j) | |
| def test_mod_zero_division(self): | |
| for a, b in ZERO_DIVISION: | |
| with self.assertRaises(TypeError): | |
| a % b | |
| def test_divmod(self): | |
| self.assertRaises(TypeError, divmod, 1+1j, 1+0j) | |
| self.assertRaises(TypeError, divmod, 1+1j, 1.0) | |
| self.assertRaises(TypeError, divmod, 1+1j, 1) | |
| self.assertRaises(TypeError, divmod, 1.0, 1+0j) | |
| self.assertRaises(TypeError, divmod, 1, 1+0j) | |
| def test_divmod_zero_division(self): | |
| for a, b in ZERO_DIVISION: | |
| self.assertRaises(TypeError, divmod, a, b) | |
| def test_pow(self): | |
| self.assertAlmostEqual(pow(1+1j, 0+0j), 1.0) | |
| self.assertAlmostEqual(pow(0+0j, 2+0j), 0.0) | |
| self.assertEqual(pow(0+0j, 2000+0j), 0.0) | |
| self.assertEqual(pow(0, 0+0j), 1.0) | |
| self.assertEqual(pow(-1, 0+0j), 1.0) | |
| self.assertRaises(ZeroDivisionError, pow, 0+0j, 1j) | |
| self.assertRaises(ZeroDivisionError, pow, 0+0j, -1000) | |
| self.assertAlmostEqual(pow(1j, -1), 1/1j) | |
| self.assertAlmostEqual(pow(1j, 200), 1) | |
| self.assertRaises(ValueError, pow, 1+1j, 1+1j, 1+1j) | |
| self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j) | |
| self.assertRaises(OverflowError, pow, 1e200+1j, 5) | |
| self.assertRaises(TypeError, pow, 1j, None) | |
| self.assertRaises(TypeError, pow, None, 1j) | |
| self.assertAlmostEqual(pow(1j, 0.5), 0.7071067811865476+0.7071067811865475j) | |
| # gh-156886: an infinite phase is not a zero base. | |
| for base, exp in [(complex(INF), 1j), | |
| (complex(INF, 1), 1j), | |
| (1e300, 1e308j), | |
| (complex(2), complex(0, INF))]: | |
| with self.subTest(base=base, exponent=exp): | |
| r = base ** exp | |
| self.assertTrue(isnan(r.real)) | |
| self.assertTrue(isnan(r.imag)) | |
| a = 3.33+4.43j | |
| self.assertEqual(a ** 0j, 1) | |
| self.assertEqual(a ** 0.+0.j, 1) | |
| self.assertEqual(3j ** 0j, 1) | |
| self.assertEqual(3j ** 0, 1) | |
| try: | |
| 0j ** a | |
| except ZeroDivisionError: | |
| pass | |
| else: | |
| self.fail("should fail 0.0 to negative or complex power") | |
| try: | |
| 0j ** (3-2j) | |
| except ZeroDivisionError: | |
| pass | |
| else: | |
| self.fail("should fail 0.0 to negative or complex power") | |
| # The following is used to exercise certain code paths | |
| self.assertEqual(a ** 105, a ** 105) | |
| self.assertEqual(a ** -105, a ** -105) | |
| self.assertEqual(a ** -30, a ** -30) | |
| self.assertEqual(0.0j ** 0, 1) | |
| b = 5.1+2.3j | |
| self.assertRaises(ValueError, pow, a, b, 0) | |
| # Check some boundary conditions; some of these used to invoke | |
| # undefined behaviour (https://bugs.python.org/issue44698). We're | |
| # not actually checking the results of these operations, just making | |
| # sure they don't crash (for example when using clang's | |
| # UndefinedBehaviourSanitizer). | |
| values = (sys.maxsize, sys.maxsize+1, sys.maxsize-1, | |
| -sys.maxsize, -sys.maxsize+1, -sys.maxsize+1) | |
| for real in values: | |
| for imag in values: | |
| with self.subTest(real=real, imag=imag): | |
| c = complex(real, imag) | |
| try: | |
| c ** real | |
| except OverflowError: | |
| pass | |
| try: | |
| c ** c | |
| except OverflowError: | |
| pass | |
| # gh-113841: possible undefined division by 0 in _Py_c_pow() | |
| x, y = 9j, 33j**3 | |
| with self.assertRaises(OverflowError): | |
| x**y | |
| def test_pow_with_small_integer_exponents(self): | |
| # Check that small integer exponents are handled identically | |
| # regardless of their type. | |
| values = [ | |
| complex(5.0, 12.0), | |
| complex(5.0e100, 12.0e100), | |
| complex(-4.0, INF), | |
| complex(INF, 0.0), | |
| ] | |
| exponents = [-19, -5, -3, -2, -1, 0, 1, 2, 3, 5, 19] | |
| for value in values: | |
| for exponent in exponents: | |
| with self.subTest(value=value, exponent=exponent): | |
| try: | |
| int_pow = value**exponent | |
| except OverflowError: | |
| int_pow = "overflow" | |
| try: | |
| float_pow = value**float(exponent) | |
| except OverflowError: | |
| float_pow = "overflow" | |
| try: | |
| complex_pow = value**complex(exponent) | |
| except OverflowError: | |
| complex_pow = "overflow" | |
| self.assertEqual(str(float_pow), str(int_pow)) | |
| self.assertEqual(str(complex_pow), str(int_pow)) | |
| # Check that complex numbers with special components | |
| # are correctly handled. | |
| values = [complex(x, y) | |
| for x in [5, -5, +0.0, -0.0, INF, -INF, NAN] | |
| for y in [12, -12, +0.0, -0.0, INF, -INF, NAN]] | |
| for c in values: | |
| with self.subTest(value=c): | |
| self.assertComplexesAreIdentical(c**0, complex(1, +0.0)) | |
| self.assertComplexesAreIdentical(c**1, c) | |
| self.assertComplexesAreIdentical(c**2, c*c) | |
| self.assertComplexesAreIdentical(c**3, c*(c*c)) | |
| self.assertComplexesAreIdentical(c**3, (c*c)*c) | |
| if not c: | |
| continue | |
| for n in range(1, 9): | |
| with self.subTest(exponent=-n): | |
| self.assertComplexesAreIdentical(c**-n, 1/(c**n)) | |
| # Special cases for complex division. | |
| for x in [+2, -2]: | |
| for y in [+0.0, -0.0]: | |
| c = complex(x, y) | |
| with self.subTest(value=c): | |
| self.assertComplexesAreIdentical(c**-1, complex(1/x, -y)) | |
| c = complex(y, x) | |
| with self.subTest(value=c): | |
| self.assertComplexesAreIdentical(c**-1, complex(y, -1/x)) | |
| for x in [+INF, -INF]: | |
| for y in [+1, -1]: | |
| c = complex(x, y) | |
| with self.subTest(value=c): | |
| self.assertComplexesAreIdentical(c**-1, complex(1/x, -0.0*y)) | |
| self.assertComplexesAreIdentical(c**-2, complex(0.0, -y/x)) | |
| c = complex(y, x) | |
| with self.subTest(value=c): | |
| self.assertComplexesAreIdentical(c**-1, complex(+0.0*y, -1/x)) | |
| self.assertComplexesAreIdentical(c**-2, complex(-0.0, -y/x)) | |
| # Test that zeroes has the same sign as small non-zero values. | |
| eps = 1e-11 | |
| pairs = [(complex(x, y), complex(x, copysign(0.0, y))) | |
| for x in [+1, -1] for y in [+eps, -eps]] | |
| pairs += [(complex(y, x), complex(copysign(0.0, y), x)) | |
| for x in [+1, -1] for y in [+eps, -eps]] | |
| for c1, c2 in pairs: | |
| for n in exponents: | |
| with self.subTest(value=c1, exponent=n): | |
| r1 = c1**n | |
| r2 = c2**n | |
| self.assertClose(r1, r2) | |
| self.assertSameSign(r1.real, r2.real) | |
| self.assertSameSign(r1.imag, r2.imag) | |
| self.assertNotEqual(r1.real, 0.0) | |
| if n != 0: | |
| self.assertNotEqual(r1.imag, 0.0) | |
| self.assertTrue(r2.real == 0.0 or r2.imag == 0.0) | |
| def test_boolcontext(self): | |
| for i in range(100): | |
| self.assertTrue(complex(random() + 1e-6, random() + 1e-6)) | |
| self.assertTrue(not complex(0.0, 0.0)) | |
| self.assertTrue(1j) | |
| def test_conjugate(self): | |
| self.assertEqual(complex(5.3, 9.8).conjugate(), 5.3-9.8j) | |
| def test_constructor(self): | |
| def check(z, x, y): | |
| self.assertIs(type(z), complex) | |
| self.assertFloatsAreIdentical(z.real, x) | |
| self.assertFloatsAreIdentical(z.imag, y) | |
| check(complex(), 0.0, 0.0) | |
| check(complex(10), 10.0, 0.0) | |
| check(complex(4.25), 4.25, 0.0) | |
| check(complex(4.25+0j), 4.25, 0.0) | |
| check(complex(4.25+0.5j), 4.25, 0.5) | |
| check(complex(ComplexSubclass(4.25+0.5j)), 4.25, 0.5) | |
| check(complex(WithComplex(4.25+0.5j)), 4.25, 0.5) | |
| check(complex(1, 10), 1.0, 10.0) | |
| check(complex(1, 10.0), 1.0, 10.0) | |
| check(complex(1, 4.25), 1.0, 4.25) | |
| check(complex(1.0, 10), 1.0, 10.0) | |
| check(complex(4.25, 10), 4.25, 10.0) | |
| check(complex(1.0, 10.0), 1.0, 10.0) | |
| check(complex(4.25, 0.5), 4.25, 0.5) | |
| with self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'real' must be a real number, not complex"): | |
| check(complex(4.25+0j, 0), 4.25, 0.0) | |
| with self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'real' must be a real number, not .*ComplexSubclass"): | |
| check(complex(ComplexSubclass(4.25+0j), 0), 4.25, 0.0) | |
| with self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'real' must be a real number, not .*WithComplex"): | |
| check(complex(WithComplex(4.25+0j), 0), 4.25, 0.0) | |
| with self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'real' must be a real number, not complex"): | |
| check(complex(4.25j, 0), 0.0, 4.25) | |
| with self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'real' must be a real number, not complex"): | |
| check(complex(0j, 4.25), 0.0, 4.25) | |
| with self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'imag' must be a real number, not complex"): | |
| check(complex(0, 4.25+0j), 0.0, 4.25) | |
| with self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'imag' must be a real number, not .*ComplexSubclass"): | |
| check(complex(0, ComplexSubclass(4.25+0j)), 0.0, 4.25) | |
| with self.assertRaisesRegex(TypeError, | |
| "argument 'imag' must be a real number, not .*WithComplex"): | |
| complex(0, WithComplex(4.25+0j)) | |
| with self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'imag' must be a real number, not complex"): | |
| check(complex(0.0, 4.25j), -4.25, 0.0) | |
| with (self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'real' must be a real number, not complex"), | |
| self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'imag' must be a real number, not complex")): | |
| check(complex(4.25+0j, 0j), 4.25, 0.0) | |
| with (self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'real' must be a real number, not complex"), | |
| self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'imag' must be a real number, not complex")): | |
| check(complex(4.25j, 0j), 0.0, 4.25) | |
| with (self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'real' must be a real number, not complex"), | |
| self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'imag' must be a real number, not complex")): | |
| check(complex(0j, 4.25+0j), 0.0, 4.25) | |
| with (self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'real' must be a real number, not complex"), | |
| self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'imag' must be a real number, not complex")): | |
| check(complex(0j, 4.25j), -4.25, 0.0) | |
| check(complex(real=4.25), 4.25, 0.0) | |
| with self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'real' must be a real number, not complex"): | |
| check(complex(real=4.25+0j), 4.25, 0.0) | |
| with self.assertWarnsRegex(DeprecationWarning, | |
| "argument 'real' must be a real number, not complex"): | |
| check(complex(real=4.25+1.5j), 4.25, 1.5) | |
| check(complex(imag=1.5), 0.0, 1.5) | |
| check(complex(real=4.25, imag=1.5), 4.25, 1.5) | |
| check(complex(4.25, imag=1.5), 4.25, 1.5) | |
| # check that the sign of a zero in the real or imaginary part | |
| # is preserved when constructing from two floats. | |
| for x in 1.0, -1.0: | |
| for y in 0.0, -0.0: | |
| check(complex(x, y), x, y) | |
| check(complex(y, x), y, x) | |
| c = complex(4.25, 1.5) | |
| self.assertIs(complex(c), c) | |
| c2 = ComplexSubclass(c) | |
| self.assertEqual(c2, c) | |
| self.assertIs(type(c2), ComplexSubclass) | |
| del c, c2 | |
| self.assertRaisesRegex(TypeError, | |
| "argument must be a string or a number, not dict", | |
| complex, {}) | |
| self.assertRaisesRegex(TypeError, | |
| "argument must be a string or a number, not NoneType", | |
| complex, None) | |
| self.assertRaisesRegex(TypeError, | |
| "argument 'real' must be a real number, not dict", | |
| complex, {1:2}, 0) | |
| self.assertRaisesRegex(TypeError, | |
| "argument 'real' must be a real number, not str", | |
| complex, '1', 0) | |
| self.assertRaisesRegex(TypeError, | |
| "argument 'imag' must be a real number, not dict", | |
| complex, 0, {1:2}) | |
| self.assertRaisesRegex(TypeError, | |
| "argument 'imag' must be a real number, not str", | |
| complex, 0, '1') | |
| self.assertRaises(TypeError, complex, WithComplex(1.5)) | |
| self.assertRaises(TypeError, complex, WithComplex(1)) | |
| self.assertRaises(TypeError, complex, WithComplex(None)) | |
| self.assertRaises(TypeError, complex, WithComplex(4.25+0j), object()) | |
| self.assertRaises(TypeError, complex, WithComplex(1.5), object()) | |
| self.assertRaises(TypeError, complex, WithComplex(1), object()) | |
| self.assertRaises(TypeError, complex, WithComplex(None), object()) | |
| class EvilExc(Exception): | |
| pass | |
| class evilcomplex: | |
| def __complex__(self): | |
| raise EvilExc | |
| self.assertRaises(EvilExc, complex, evilcomplex()) | |
| check(complex(WithFloat(4.25)), 4.25, 0.0) | |
| check(complex(WithFloat(4.25), 1.5), 4.25, 1.5) | |
| check(complex(1.5, WithFloat(4.25)), 1.5, 4.25) | |
| self.assertRaises(TypeError, complex, WithFloat(42)) | |
| self.assertRaises(TypeError, complex, WithFloat(42), 1.5) | |
| self.assertRaises(TypeError, complex, 1.5, WithFloat(42)) | |
| self.assertRaises(TypeError, complex, WithFloat(None)) | |
| self.assertRaises(TypeError, complex, WithFloat(None), 1.5) | |
| self.assertRaises(TypeError, complex, 1.5, WithFloat(None)) | |
| check(complex(WithIndex(42)), 42.0, 0.0) | |
| check(complex(WithIndex(42), 1.5), 42.0, 1.5) | |
| check(complex(1.5, WithIndex(42)), 1.5, 42.0) | |
| self.assertRaises(OverflowError, complex, WithIndex(2**2000)) | |
| self.assertRaises(OverflowError, complex, WithIndex(2**2000), 1.5) | |
| self.assertRaises(OverflowError, complex, 1.5, WithIndex(2**2000)) | |
| self.assertRaises(TypeError, complex, WithIndex(None)) | |
| self.assertRaises(TypeError, complex, WithIndex(None), 1.5) | |
| self.assertRaises(TypeError, complex, 1.5, WithIndex(None)) | |
| class MyInt: | |
| def __int__(self): | |
| return 42 | |
| self.assertRaises(TypeError, complex, MyInt()) | |
| self.assertRaises(TypeError, complex, MyInt(), 1.5) | |
| self.assertRaises(TypeError, complex, 1.5, MyInt()) | |
| class complex0(complex): | |
| """Test usage of __complex__() when inheriting from 'complex'""" | |
| def __complex__(self): | |
| return 42j | |
| class complex1(complex): | |
| """Test usage of __complex__() with a __new__() method""" | |
| def __new__(self, value=0j): | |
| return complex.__new__(self, 2*value) | |
| def __complex__(self): | |
| return self | |
| class complex2(complex): | |
| """Make sure that __complex__() calls fail if anything other than a | |
| complex is returned""" | |
| def __complex__(self): | |
| return None | |
| check(complex(complex0(1j)), 0.0, 42.0) | |
| with self.assertWarns(DeprecationWarning): | |
| check(complex(complex1(1j)), 0.0, 2.0) | |
| self.assertRaises(TypeError, complex, complex2(1j)) | |
| def test___complex__(self): | |
| z = 3 + 4j | |
| self.assertEqual(z.__complex__(), z) | |
| self.assertEqual(type(z.__complex__()), complex) | |
| z = ComplexSubclass(3 + 4j) | |
| self.assertEqual(z.__complex__(), 3 + 4j) | |
| self.assertEqual(type(z.__complex__()), complex) | |
| @support.requires_IEEE_754 | |
| def test_constructor_special_numbers(self): | |
| for x in 0.0, -0.0, INF, -INF, NAN: | |
| for y in 0.0, -0.0, INF, -INF, NAN: | |
| with self.subTest(x=x, y=y): | |
| z = complex(x, y) | |
| self.assertFloatsAreIdentical(z.real, x) | |
| self.assertFloatsAreIdentical(z.imag, y) | |
| z = ComplexSubclass(x, y) | |
| self.assertIs(type(z), ComplexSubclass) | |
| self.assertFloatsAreIdentical(z.real, x) | |
| self.assertFloatsAreIdentical(z.imag, y) | |
| z = complex(ComplexSubclass(x, y)) | |
| self.assertIs(type(z), complex) | |
| self.assertFloatsAreIdentical(z.real, x) | |
| self.assertFloatsAreIdentical(z.imag, y) | |
| z = ComplexSubclass(complex(x, y)) | |
| self.assertIs(type(z), ComplexSubclass) | |
| self.assertFloatsAreIdentical(z.real, x) | |
| self.assertFloatsAreIdentical(z.imag, y) | |
| def test_constructor_from_string(self): | |
| def check(z, x, y): | |
| self.assertIs(type(z), complex) | |
| self.assertFloatsAreIdentical(z.real, x) | |
| self.assertFloatsAreIdentical(z.imag, y) | |
| check(complex("1"), 1.0, 0.0) | |
| check(complex("1j"), 0.0, 1.0) | |
| check(complex("-1"), -1.0, 0.0) | |
| check(complex("+1"), 1.0, 0.0) | |
| check(complex("1+2j"), 1.0, 2.0) | |
| check(complex("(1+2j)"), 1.0, 2.0) | |
| check(complex("(1.5+4.25j)"), 1.5, 4.25) | |
| check(complex("4.25+1J"), 4.25, 1.0) | |
| check(complex(" ( +4.25-6J )"), 4.25, -6.0) | |
| check(complex(" ( +4.25-J )"), 4.25, -1.0) | |
| check(complex(" ( +4.25+j )"), 4.25, 1.0) | |
| check(complex("J"), 0.0, 1.0) | |
| check(complex("( j )"), 0.0, 1.0) | |
| check(complex("+J"), 0.0, 1.0) | |
| check(complex("( -j)"), 0.0, -1.0) | |
| check(complex('1-1j'), 1.0, -1.0) | |
| check(complex('1J'), 0.0, 1.0) | |
| check(complex('1e-500'), 0.0, 0.0) | |
| check(complex('-1e-500j'), 0.0, -0.0) | |
| check(complex('1e-500+1e-500j'), 0.0, 0.0) | |
| check(complex('-1e-500+1e-500j'), -0.0, 0.0) | |
| check(complex('1e-500-1e-500j'), 0.0, -0.0) | |
| check(complex('-1e-500-1e-500j'), -0.0, -0.0) | |
| # SF bug 543840: complex(string) accepts strings with \0 | |
| # Fixed in 2.3. | |
| self.assertRaises(ValueError, complex, '1+1j\0j') | |
| self.assertRaises(ValueError, complex, "") | |
| self.assertRaises(ValueError, complex, "\0") | |
| self.assertRaises(ValueError, complex, "3\09") | |
| self.assertRaises(ValueError, complex, "1+") | |
| self.assertRaises(ValueError, complex, "1+1j+1j") | |
| self.assertRaises(ValueError, complex, "--") | |
| self.assertRaises(ValueError, complex, "(1+2j") | |
| self.assertRaises(ValueError, complex, "1+2j)") | |
| self.assertRaises(ValueError, complex, "1+(2j)") | |
| self.assertRaises(ValueError, complex, "(1+2j)123") | |
| self.assertRaises(ValueError, complex, "x") | |
| self.assertRaises(ValueError, complex, "1j+2") | |
| self.assertRaises(ValueError, complex, "1e1ej") | |
| self.assertRaises(ValueError, complex, "1e++1ej") | |
| self.assertRaises(ValueError, complex, ")1+2j(") | |
| # the following three are accepted by Python 2.6 | |
| self.assertRaises(ValueError, complex, "1..1j") | |
| self.assertRaises(ValueError, complex, "1.11.1j") | |
| self.assertRaises(ValueError, complex, "1e1.1j") | |
| # check that complex accepts long unicode strings | |
| self.assertIs(type(complex("1"*500)), complex) | |
| # check whitespace processing | |
| self.assertEqual(complex('\N{EM SPACE}(\N{EN SPACE}1+1j ) '), 1+1j) | |
| # Invalid unicode string | |
| # See bpo-34087 | |
| self.assertRaises(ValueError, complex, '\u3053\u3093\u306b\u3061\u306f') | |
| def test_constructor_negative_nans_from_string(self): | |
| self.assertEqual(copysign(1., complex("-nan").real), -1.) | |
| self.assertEqual(copysign(1., complex("-nanj").imag), -1.) | |
| self.assertEqual(copysign(1., complex("-nan-nanj").real), -1.) | |
| self.assertEqual(copysign(1., complex("-nan-nanj").imag), -1.) | |
| def test_underscores(self): | |
| # check underscores | |
| for lit in VALID_UNDERSCORE_LITERALS: | |
| if not any(ch in lit for ch in 'xXoObB'): | |
| self.assertEqual(complex(lit), eval(lit)) | |
| self.assertEqual(complex(lit), complex(lit.replace('_', ''))) | |
| for lit in INVALID_UNDERSCORE_LITERALS: | |
| if lit in ('0_7', '09_99'): # octals are not recognized here | |
| continue | |
| if not any(ch in lit for ch in 'xXoObB'): | |
| self.assertRaises(ValueError, complex, lit) | |
| def test_from_number(self, cls=complex): | |
| def eq(actual, expected): | |
| self.assertEqual(actual, expected) | |
| self.assertIs(type(actual), cls) | |
| eq(cls.from_number(3.14), 3.14+0j) | |
| eq(cls.from_number(3.14j), 3.14j) | |
| eq(cls.from_number(314), 314.0+0j) | |
| eq(cls.from_number(OtherComplexSubclass(3.14, 2.72)), 3.14+2.72j) | |
| eq(cls.from_number(WithComplex(3.14+2.72j)), 3.14+2.72j) | |
| eq(cls.from_number(WithFloat(3.14)), 3.14+0j) | |
| eq(cls.from_number(WithIndex(314)), 314.0+0j) | |
| cNAN = complex(NAN, NAN) | |
| x = cls.from_number(cNAN) | |
| self.assertTrue(x != x) | |
| self.assertIs(type(x), cls) | |
| if cls is complex: | |
| self.assertIs(cls.from_number(cNAN), cNAN) | |
| self.assertRaises(TypeError, cls.from_number, '3.14') | |
| self.assertRaises(TypeError, cls.from_number, b'3.14') | |
| self.assertRaises(TypeError, cls.from_number, MyInt(314)) | |
| self.assertRaises(TypeError, cls.from_number, {}) | |
| self.assertRaises(TypeError, cls.from_number) | |
| def test_from_number_subclass(self): | |
| self.test_from_number(ComplexSubclass) | |
| def test_hash(self): | |
| for x in range(-30, 30): | |
| self.assertEqual(hash(x), hash(complex(x, 0))) | |
| x /= 3.0 # now check against floating-point | |
| self.assertEqual(hash(x), hash(complex(x, 0.))) | |
| self.assertNotEqual(hash(2000005 - 1j), -1) | |
| def test_abs(self): | |
| nums = [complex(x/3., y/7.) for x in range(-9,9) for y in range(-9,9)] | |
| for num in nums: | |
| self.assertAlmostEqual((num.real**2 + num.imag**2) ** 0.5, abs(num)) | |
| for x in 0.0, -0.0, INF, -INF, NAN: | |
| for y in 0.0, -0.0, INF, -INF, NAN: | |
| with self.subTest(x=x, y=y): | |
| z = complex(x, y) | |
| r = abs(z) | |
| if cmath.isfinite(z): | |
| self.assertFloatsAreIdentical(r, 0.0) | |
| elif cmath.isinf(z): | |
| self.assertEqual(r, INF) | |
| else: | |
| self.assertTrue(cmath.isnan(z)) | |
| self.assertTrue(isnan(r)) | |
| self.assertRaises(OverflowError, abs, complex(DBL_MAX, DBL_MAX)) | |
| def test_abs_errno_handling(self): | |
| _testcapi = import_helper.import_module('_testcapi') | |
| z = complex('nan') | |
| _testcapi.set_errno(errno.ERANGE) | |
| try: | |
| self.assertTrue(isnan(abs(z))) | |
| finally: | |
| _testcapi.set_errno(0) | |
| def test_repr_str(self): | |
| def test(v, expected, test_fn=self.assertEqual): | |
| test_fn(repr(v), expected) | |
| test_fn(str(v), expected) | |
| test(1+6j, '(1+6j)') | |
| test(1-6j, '(1-6j)') | |
| test(-(1+0j), '(-1+-0j)', test_fn=self.assertNotEqual) | |
| test(complex(1., INF), "(1+infj)") | |
| test(complex(1., -INF), "(1-infj)") | |
| test(complex(INF, 1), "(inf+1j)") | |
| test(complex(-INF, INF), "(-inf+infj)") | |
| test(complex(NAN, 1), "(nan+1j)") | |
| test(complex(1, NAN), "(1+nanj)") | |
| test(complex(NAN, NAN), "(nan+nanj)") | |
| test(complex(-NAN, -NAN), "(nan+nanj)") | |
| test(complex(0, INF), "infj") | |
| test(complex(0, -INF), "-infj") | |
| test(complex(0, NAN), "nanj") | |
| self.assertEqual(1-6j,complex(repr(1-6j))) | |
| self.assertEqual(1+6j,complex(repr(1+6j))) | |
| self.assertEqual(-6j,complex(repr(-6j))) | |
| self.assertEqual(6j,complex(repr(6j))) | |
| @support.requires_IEEE_754 | |
| def test_negative_zero_repr_str(self): | |
| def test(v, expected, test_fn=self.assertEqual): | |
| test_fn(repr(v), expected) | |
| test_fn(str(v), expected) | |
| test(complex(0., 1.), "1j") | |
| test(complex(-0., 1.), "(-0+1j)") | |
| test(complex(0., -1.), "-1j") | |
| test(complex(-0., -1.), "(-0-1j)") | |
| test(complex(0., 0.), "0j") | |
| test(complex(0., -0.), "-0j") | |
| test(complex(-0., 0.), "(-0+0j)") | |
| test(complex(-0., -0.), "(-0-0j)") | |
| def test_pos(self): | |
| self.assertEqual(+(1+6j), 1+6j) | |
| self.assertEqual(+ComplexSubclass(1, 6), 1+6j) | |
| self.assertIs(type(+ComplexSubclass(1, 6)), complex) | |
| def test_neg(self): | |
| self.assertEqual(-(1+6j), -1-6j) | |
| def test_getnewargs(self): | |
| self.assertEqual((1+2j).__getnewargs__(), (1.0, 2.0)) | |
| self.assertEqual((1-2j).__getnewargs__(), (1.0, -2.0)) | |
| self.assertEqual((2j).__getnewargs__(), (0.0, 2.0)) | |
| self.assertEqual((-0j).__getnewargs__(), (0.0, -0.0)) | |
| self.assertEqual(complex(0, INF).__getnewargs__(), (0.0, INF)) | |
| self.assertEqual(complex(INF, 0).__getnewargs__(), (INF, 0.0)) | |
| @support.requires_IEEE_754 | |
| def test_plus_minus_0j(self): | |
| # test that -0j and 0j literals are not identified | |
| z1, z2 = 0j, -0j | |
| self.assertFloatsAreIdentical(z1.imag, 0.0) | |
| self.assertFloatsAreIdentical(z2.imag, -0.0) | |
| @support.requires_IEEE_754 | |
| def test_negated_imaginary_literal(self): | |
| z0 = -0j | |
| z1 = -7j | |
| z2 = -1e1000j | |
| # Note: In versions of Python < 3.2, a negated imaginary literal | |
| # accidentally ended up with real part 0.0 instead of -0.0, thanks to a | |
| # modification during CST -> AST translation (see issue #9011). That's | |
| # fixed in Python 3.2. | |
| self.assertFloatsAreIdentical(z0.real, -0.0) | |
| self.assertFloatsAreIdentical(z0.imag, -0.0) | |
| self.assertFloatsAreIdentical(z1.real, -0.0) | |
| self.assertFloatsAreIdentical(z1.imag, -7.0) | |
| self.assertFloatsAreIdentical(z2.real, -0.0) | |
| self.assertFloatsAreIdentical(z2.imag, -INF) | |
| @support.requires_IEEE_754 | |
| def test_overflow(self): | |
| self.assertEqual(complex("1e500"), complex(INF, 0.0)) | |
| self.assertEqual(complex("-1e500j"), complex(0.0, -INF)) | |
| self.assertEqual(complex("-1e500+1.8e308j"), complex(-INF, INF)) | |
| @support.requires_IEEE_754 | |
| def test_repr_roundtrip(self): | |
| vals = [0.0, 1e-500, 1e-315, 1e-200, 0.0123, 3.1415, 1e50, INF, NAN] | |
| vals += [-v for v in vals] | |
| # complex(repr(z)) should recover z exactly, even for complex | |
| # numbers involving an infinity, nan, or negative zero | |
| for x in vals: | |
| for y in vals: | |
| z = complex(x, y) | |
| roundtrip = complex(repr(z)) | |
| self.assertComplexesAreIdentical(z, roundtrip) | |
| # if we predefine some constants, then eval(repr(z)) should | |
| # also work, except that it might change the sign of zeros | |
| inf, nan = float('inf'), float('nan') | |
| infj, nanj = complex(0.0, inf), complex(0.0, nan) | |
| for x in vals: | |
| for y in vals: | |
| z = complex(x, y) | |
| roundtrip = eval(repr(z)) | |
| # adding 0.0 has no effect beside changing -0.0 to 0.0 | |
| self.assertFloatsAreIdentical(0.0 + z.real, | |
| 0.0 + roundtrip.real) | |
| self.assertFloatsAreIdentical(0.0 + z.imag, | |
| 0.0 + roundtrip.imag) | |
| def test_format(self): | |
| # empty format string is same as str() | |
| self.assertEqual(format(1+3j, ''), str(1+3j)) | |
| self.assertEqual(format(1.5+3.5j, ''), str(1.5+3.5j)) | |
| self.assertEqual(format(3j, ''), str(3j)) | |
| self.assertEqual(format(3.2j, ''), str(3.2j)) | |
| self.assertEqual(format(3+0j, ''), str(3+0j)) | |
| self.assertEqual(format(3.2+0j, ''), str(3.2+0j)) | |
| # empty presentation type should still be analogous to str, | |
| # even when format string is nonempty (issue #5920). | |
| self.assertEqual(format(3.2+0j, '-'), str(3.2+0j)) | |
| self.assertEqual(format(3.2+0j, '<'), str(3.2+0j)) | |
| z = 4/7. - 100j/7. | |
| self.assertEqual(format(z, ''), str(z)) | |
| self.assertEqual(format(z, '-'), str(z)) | |
| self.assertEqual(format(z, '<'), str(z)) | |
| self.assertEqual(format(z, '10'), str(z)) | |
| z = complex(0.0, 3.0) | |
| self.assertEqual(format(z, ''), str(z)) | |
| self.assertEqual(format(z, '-'), str(z)) | |
| self.assertEqual(format(z, '<'), str(z)) | |
| self.assertEqual(format(z, '2'), str(z)) | |
| z = complex(-0.0, 2.0) | |
| self.assertEqual(format(z, ''), str(z)) | |
| self.assertEqual(format(z, '-'), str(z)) | |
| self.assertEqual(format(z, '<'), str(z)) | |
| self.assertEqual(format(z, '3'), str(z)) | |
| self.assertEqual(format(1+3j, 'g'), '1+3j') | |
| self.assertEqual(format(3j, 'g'), '0+3j') | |
| self.assertEqual(format(1.5+3.5j, 'g'), '1.5+3.5j') | |
| self.assertEqual(format(1.5+3.5j, '+g'), '+1.5+3.5j') | |
| self.assertEqual(format(1.5-3.5j, '+g'), '+1.5-3.5j') | |
| self.assertEqual(format(1.5-3.5j, '-g'), '1.5-3.5j') | |
| self.assertEqual(format(1.5+3.5j, ' g'), ' 1.5+3.5j') | |
| self.assertEqual(format(1.5-3.5j, ' g'), ' 1.5-3.5j') | |
| self.assertEqual(format(-1.5+3.5j, ' g'), '-1.5+3.5j') | |
| self.assertEqual(format(-1.5-3.5j, ' g'), '-1.5-3.5j') | |
| self.assertEqual(format(-1.5-3.5e-20j, 'g'), '-1.5-3.5e-20j') | |
| self.assertEqual(format(-1.5-3.5j, 'f'), '-1.500000-3.500000j') | |
| self.assertEqual(format(-1.5-3.5j, 'F'), '-1.500000-3.500000j') | |
| self.assertEqual(format(-1.5-3.5j, 'e'), '-1.500000e+00-3.500000e+00j') | |
| self.assertEqual(format(-1.5-3.5j, '.2e'), '-1.50e+00-3.50e+00j') | |
| self.assertEqual(format(-1.5-3.5j, '.2E'), '-1.50E+00-3.50E+00j') | |
| self.assertEqual(format(-1.5e10-3.5e5j, '.2G'), '-1.5E+10-3.5E+05j') | |
| self.assertEqual(format(1.5+3j, '<20g'), '1.5+3j ') | |
| self.assertEqual(format(1.5+3j, '*<20g'), '1.5+3j**************') | |
| self.assertEqual(format(1.5+3j, '>20g'), ' 1.5+3j') | |
| self.assertEqual(format(1.5+3j, '^20g'), ' 1.5+3j ') | |
| self.assertEqual(format(1.5+3j, '<20'), '(1.5+3j) ') | |
| self.assertEqual(format(1.5+3j, '>20'), ' (1.5+3j)') | |
| self.assertEqual(format(1.5+3j, '^20'), ' (1.5+3j) ') | |
| self.assertEqual(format(1.123-3.123j, '^20.2'), ' (1.1-3.1j) ') | |
| self.assertEqual(format(1.5+3j, '20.2f'), ' 1.50+3.00j') | |
| self.assertEqual(format(1.5+3j, '>20.2f'), ' 1.50+3.00j') | |
| self.assertEqual(format(1.5+3j, '<20.2f'), '1.50+3.00j ') | |
| self.assertEqual(format(1.5e20+3j, '<20.2f'), '150000000000000000000.00+3.00j') | |
| self.assertEqual(format(1.5e20+3j, '>40.2f'), ' 150000000000000000000.00+3.00j') | |
| self.assertEqual(format(1.5e20+3j, '^40,.2f'), ' 150,000,000,000,000,000,000.00+3.00j ') | |
| self.assertEqual(format(1.5e21+3j, '^40,.2f'), ' 1,500,000,000,000,000,000,000.00+3.00j ') | |
| self.assertEqual(format(1.5e21+3000j, ',.2f'), '1,500,000,000,000,000,000,000.00+3,000.00j') | |
| # Issue 7094: Alternate formatting (specified by #) | |
| self.assertEqual(format(1+1j, '.0e'), '1e+00+1e+00j') | |
| self.assertEqual(format(1+1j, '#.0e'), '1.e+00+1.e+00j') | |
| self.assertEqual(format(1+1j, '.0f'), '1+1j') | |
| self.assertEqual(format(1+1j, '#.0f'), '1.+1.j') | |
| self.assertEqual(format(1.1+1.1j, 'g'), '1.1+1.1j') | |
| self.assertEqual(format(1.1+1.1j, '#g'), '1.10000+1.10000j') | |
| # Alternate doesn't make a difference for these, they format the same with or without it | |
| self.assertEqual(format(1+1j, '.1e'), '1.0e+00+1.0e+00j') | |
| self.assertEqual(format(1+1j, '#.1e'), '1.0e+00+1.0e+00j') | |
| self.assertEqual(format(1+1j, '.1f'), '1.0+1.0j') | |
| self.assertEqual(format(1+1j, '#.1f'), '1.0+1.0j') | |
| # Misc. other alternate tests | |
| self.assertEqual(format((-1.5+0.5j), '#f'), '-1.500000+0.500000j') | |
| self.assertEqual(format((-1.5+0.5j), '#.0f'), '-2.+0.j') | |
| self.assertEqual(format((-1.5+0.5j), '#e'), '-1.500000e+00+5.000000e-01j') | |
| self.assertEqual(format((-1.5+0.5j), '#.0e'), '-2.e+00+5.e-01j') | |
| self.assertEqual(format((-1.5+0.5j), '#g'), '-1.50000+0.500000j') | |
| self.assertEqual(format((-1.5+0.5j), '.0g'), '-2+0.5j') | |
| self.assertEqual(format((-1.5+0.5j), '#.0g'), '-2.+0.5j') | |
| # zero padding is invalid | |
| self.assertRaises(ValueError, (1.5+0.5j).__format__, '010f') | |
| # '=' alignment is invalid | |
| self.assertRaises(ValueError, (1.5+3j).__format__, '=20') | |
| # integer presentation types are an error | |
| for t in 'bcdoxX': | |
| self.assertRaises(ValueError, (1.5+0.5j).__format__, t) | |
| # make sure everything works in ''.format() | |
| self.assertEqual('*{0:.3f}*'.format(3.14159+2.71828j), '*3.142+2.718j*') | |
| # issue 3382 | |
| self.assertEqual(format(complex(NAN, NAN), 'f'), 'nan+nanj') | |
| self.assertEqual(format(complex(1, NAN), 'f'), '1.000000+nanj') | |
| self.assertEqual(format(complex(NAN, 1), 'f'), 'nan+1.000000j') | |
| self.assertEqual(format(complex(NAN, -1), 'f'), 'nan-1.000000j') | |
| self.assertEqual(format(complex(NAN, NAN), 'F'), 'NAN+NANj') | |
| self.assertEqual(format(complex(1, NAN), 'F'), '1.000000+NANj') | |
| self.assertEqual(format(complex(NAN, 1), 'F'), 'NAN+1.000000j') | |
| self.assertEqual(format(complex(NAN, -1), 'F'), 'NAN-1.000000j') | |
| self.assertEqual(format(complex(INF, INF), 'f'), 'inf+infj') | |
| self.assertEqual(format(complex(1, INF), 'f'), '1.000000+infj') | |
| self.assertEqual(format(complex(INF, 1), 'f'), 'inf+1.000000j') | |
| self.assertEqual(format(complex(INF, -1), 'f'), 'inf-1.000000j') | |
| self.assertEqual(format(complex(INF, INF), 'F'), 'INF+INFj') | |
| self.assertEqual(format(complex(1, INF), 'F'), '1.000000+INFj') | |
| self.assertEqual(format(complex(INF, 1), 'F'), 'INF+1.000000j') | |
| self.assertEqual(format(complex(INF, -1), 'F'), 'INF-1.000000j') | |
| if __name__ == "__main__": | |
| unittest.main() |