620 lines
25 KiB
Python
620 lines
25 KiB
Python
import unittest, os
|
|
from test import test_support
|
|
|
|
import warnings
|
|
warnings.filterwarnings(
|
|
"ignore",
|
|
category=DeprecationWarning,
|
|
message=".*complex divmod.*are deprecated"
|
|
)
|
|
|
|
from random import random
|
|
from math import atan2, isnan, copysign
|
|
|
|
INF = float("inf")
|
|
NAN = float("nan")
|
|
# These tests ensure that complex math does the right thing
|
|
|
|
class ComplexTest(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 assertCloseAbs(self, x, y, eps=1e-9):
|
|
"""Return true iff floats 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)/y) < eps)
|
|
|
|
def assertFloatsAreIdentical(self, x, y):
|
|
"""assert that floats x and y are identical, in the sense that:
|
|
(1) both x and y are nans, or
|
|
(2) both x and y are infinities, with the same sign, or
|
|
(3) both x and y are zeros, with the same sign, or
|
|
(4) x and y are both finite and nonzero, and x == y
|
|
|
|
"""
|
|
msg = 'floats {!r} and {!r} are not identical'
|
|
|
|
if isnan(x) or isnan(y):
|
|
if isnan(x) and isnan(y):
|
|
return
|
|
elif x == y:
|
|
if x != 0.0:
|
|
return
|
|
# both zero; check that signs match
|
|
elif copysign(1.0, x) == copysign(1.0, y):
|
|
return
|
|
else:
|
|
msg += ': zeros have different signs'
|
|
self.fail(msg.format(x, y))
|
|
|
|
def assertClose(self, x, y, eps=1e-9):
|
|
"""Return true iff complexes x and y "are close\""""
|
|
self.assertCloseAbs(x.real, y.real, eps)
|
|
self.assertCloseAbs(x.imag, y.imag, eps)
|
|
|
|
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 != 0:
|
|
q = z / x
|
|
self.assertClose(q, y)
|
|
q = z.__div__(x)
|
|
self.assertClose(q, y)
|
|
q = z.__truediv__(x)
|
|
self.assertClose(q, y)
|
|
if y != 0:
|
|
q = z / y
|
|
self.assertClose(q, x)
|
|
q = z.__div__(y)
|
|
self.assertClose(q, x)
|
|
q = z.__truediv__(y)
|
|
self.assertClose(q, x)
|
|
|
|
def test_div(self):
|
|
simple_real = [float(i) for i in xrange(-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)
|
|
|
|
# Just for fun.
|
|
for i in xrange(100):
|
|
self.check_div(complex(random(), random()),
|
|
complex(random(), random()))
|
|
|
|
self.assertRaises(ZeroDivisionError, complex.__div__, 1+1j, 0+0j)
|
|
# FIXME: The following currently crashes on Alpha
|
|
# self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j)
|
|
|
|
def test_truediv(self):
|
|
self.assertAlmostEqual(complex.__truediv__(2+0j, 1+1j), 1-1j)
|
|
self.assertRaises(ZeroDivisionError, complex.__truediv__, 1+1j, 0+0j)
|
|
|
|
def test_floordiv(self):
|
|
self.assertAlmostEqual(complex.__floordiv__(3+0j, 1.5+0j), 2)
|
|
self.assertRaises(ZeroDivisionError, complex.__floordiv__, 3+0j, 0+0j)
|
|
|
|
def test_coerce(self):
|
|
self.assertRaises(OverflowError, complex.__coerce__, 1+1j, 1L<<10000)
|
|
|
|
def test_richcompare(self):
|
|
self.assertRaises(OverflowError, complex.__eq__, 1+1j, 1L<<10000)
|
|
self.assertEqual(complex.__lt__(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)
|
|
self.assertRaises(TypeError, complex.__lt__, 1+1j, 2+2j)
|
|
self.assertRaises(TypeError, complex.__le__, 1+1j, 2+2j)
|
|
self.assertRaises(TypeError, complex.__gt__, 1+1j, 2+2j)
|
|
self.assertRaises(TypeError, complex.__ge__, 1+1j, 2+2j)
|
|
|
|
def test_mod(self):
|
|
self.assertRaises(ZeroDivisionError, (1+1j).__mod__, 0+0j)
|
|
|
|
a = 3.33+4.43j
|
|
try:
|
|
a % 0
|
|
except ZeroDivisionError:
|
|
pass
|
|
else:
|
|
self.fail("modulo parama can't be 0")
|
|
|
|
def test_divmod(self):
|
|
self.assertRaises(ZeroDivisionError, divmod, 1+1j, 0+0j)
|
|
|
|
def test_pow(self):
|
|
self.assertAlmostEqual(pow(1+1j, 0+0j), 1.0)
|
|
self.assertAlmostEqual(pow(0+0j, 2+0j), 0.0)
|
|
self.assertRaises(ZeroDivisionError, pow, 0+0j, 1j)
|
|
self.assertAlmostEqual(pow(1j, -1), 1/1j)
|
|
self.assertAlmostEqual(pow(1j, 200), 1)
|
|
self.assertRaises(ValueError, pow, 1+1j, 1+1j, 1+1j)
|
|
|
|
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)
|
|
|
|
def test_boolcontext(self):
|
|
for i in xrange(100):
|
|
self.assertTrue(complex(random() + 1e-6, random() + 1e-6))
|
|
self.assertTrue(not complex(0.0, 0.0))
|
|
|
|
def test_conjugate(self):
|
|
self.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j)
|
|
|
|
def test_constructor(self):
|
|
class OS:
|
|
def __init__(self, value): self.value = value
|
|
def __complex__(self): return self.value
|
|
class NS(object):
|
|
def __init__(self, value): self.value = value
|
|
def __complex__(self): return self.value
|
|
self.assertEqual(complex(OS(1+10j)), 1+10j)
|
|
self.assertEqual(complex(NS(1+10j)), 1+10j)
|
|
self.assertRaises(TypeError, complex, OS(None))
|
|
self.assertRaises(TypeError, complex, NS(None))
|
|
|
|
self.assertAlmostEqual(complex("1+10j"), 1+10j)
|
|
self.assertAlmostEqual(complex(10), 10+0j)
|
|
self.assertAlmostEqual(complex(10.0), 10+0j)
|
|
self.assertAlmostEqual(complex(10L), 10+0j)
|
|
self.assertAlmostEqual(complex(10+0j), 10+0j)
|
|
self.assertAlmostEqual(complex(1,10), 1+10j)
|
|
self.assertAlmostEqual(complex(1,10L), 1+10j)
|
|
self.assertAlmostEqual(complex(1,10.0), 1+10j)
|
|
self.assertAlmostEqual(complex(1L,10), 1+10j)
|
|
self.assertAlmostEqual(complex(1L,10L), 1+10j)
|
|
self.assertAlmostEqual(complex(1L,10.0), 1+10j)
|
|
self.assertAlmostEqual(complex(1.0,10), 1+10j)
|
|
self.assertAlmostEqual(complex(1.0,10L), 1+10j)
|
|
self.assertAlmostEqual(complex(1.0,10.0), 1+10j)
|
|
self.assertAlmostEqual(complex(3.14+0j), 3.14+0j)
|
|
self.assertAlmostEqual(complex(3.14), 3.14+0j)
|
|
self.assertAlmostEqual(complex(314), 314.0+0j)
|
|
self.assertAlmostEqual(complex(314L), 314.0+0j)
|
|
self.assertAlmostEqual(complex(3.14+0j, 0j), 3.14+0j)
|
|
self.assertAlmostEqual(complex(3.14, 0.0), 3.14+0j)
|
|
self.assertAlmostEqual(complex(314, 0), 314.0+0j)
|
|
self.assertAlmostEqual(complex(314L, 0L), 314.0+0j)
|
|
self.assertAlmostEqual(complex(0j, 3.14j), -3.14+0j)
|
|
self.assertAlmostEqual(complex(0.0, 3.14j), -3.14+0j)
|
|
self.assertAlmostEqual(complex(0j, 3.14), 3.14j)
|
|
self.assertAlmostEqual(complex(0.0, 3.14), 3.14j)
|
|
self.assertAlmostEqual(complex("1"), 1+0j)
|
|
self.assertAlmostEqual(complex("1j"), 1j)
|
|
self.assertAlmostEqual(complex(), 0)
|
|
self.assertAlmostEqual(complex("-1"), -1)
|
|
self.assertAlmostEqual(complex("+1"), +1)
|
|
self.assertAlmostEqual(complex("(1+2j)"), 1+2j)
|
|
self.assertAlmostEqual(complex("(1.3+2.2j)"), 1.3+2.2j)
|
|
self.assertAlmostEqual(complex("3.14+1J"), 3.14+1j)
|
|
self.assertAlmostEqual(complex(" ( +3.14-6J )"), 3.14-6j)
|
|
self.assertAlmostEqual(complex(" ( +3.14-J )"), 3.14-1j)
|
|
self.assertAlmostEqual(complex(" ( +3.14+j )"), 3.14+1j)
|
|
self.assertAlmostEqual(complex("J"), 1j)
|
|
self.assertAlmostEqual(complex("( j )"), 1j)
|
|
self.assertAlmostEqual(complex("+J"), 1j)
|
|
self.assertAlmostEqual(complex("( -j)"), -1j)
|
|
self.assertAlmostEqual(complex('1e-500'), 0.0 + 0.0j)
|
|
self.assertAlmostEqual(complex('-1e-500j'), 0.0 - 0.0j)
|
|
self.assertAlmostEqual(complex('-1e-500+1e-500j'), -0.0 + 0.0j)
|
|
|
|
class complex2(complex): pass
|
|
self.assertAlmostEqual(complex(complex2(1+1j)), 1+1j)
|
|
self.assertAlmostEqual(complex(real=17, imag=23), 17+23j)
|
|
self.assertAlmostEqual(complex(real=17+23j), 17+23j)
|
|
self.assertAlmostEqual(complex(real=17+23j, imag=23), 17+46j)
|
|
self.assertAlmostEqual(complex(real=1+2j, imag=3+4j), -3+5j)
|
|
|
|
# check that the sign of a zero in the real or imaginary part
|
|
# is preserved when constructing from two floats. (These checks
|
|
# are harmless on systems without support for signed zeros.)
|
|
def split_zeros(x):
|
|
"""Function that produces different results for 0. and -0."""
|
|
return atan2(x, -1.)
|
|
|
|
self.assertEqual(split_zeros(complex(1., 0.).imag), split_zeros(0.))
|
|
self.assertEqual(split_zeros(complex(1., -0.).imag), split_zeros(-0.))
|
|
self.assertEqual(split_zeros(complex(0., 1.).real), split_zeros(0.))
|
|
self.assertEqual(split_zeros(complex(-0., 1.).real), split_zeros(-0.))
|
|
|
|
c = 3.14 + 1j
|
|
self.assertTrue(complex(c) is c)
|
|
del c
|
|
|
|
self.assertRaises(TypeError, complex, "1", "1")
|
|
self.assertRaises(TypeError, complex, 1, "1")
|
|
|
|
if test_support.have_unicode:
|
|
self.assertEqual(complex(unicode(" 3.14+J ")), 3.14+1j)
|
|
|
|
# SF bug 543840: complex(string) accepts strings with \0
|
|
# Fixed in 2.3.
|
|
self.assertRaises(ValueError, complex, '1+1j\0j')
|
|
|
|
self.assertRaises(TypeError, int, 5+3j)
|
|
self.assertRaises(TypeError, long, 5+3j)
|
|
self.assertRaises(TypeError, float, 5+3j)
|
|
self.assertRaises(ValueError, complex, "")
|
|
self.assertRaises(TypeError, complex, None)
|
|
self.assertRaises(ValueError, complex, "\0")
|
|
self.assertRaises(ValueError, complex, "3\09")
|
|
self.assertRaises(TypeError, complex, "1", "2")
|
|
self.assertRaises(TypeError, complex, "1", 42)
|
|
self.assertRaises(TypeError, complex, 1, "2")
|
|
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")
|
|
if test_support.have_unicode:
|
|
self.assertRaises(ValueError, complex, unicode("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")
|
|
|
|
if test_support.have_unicode:
|
|
# check that complex accepts long unicode strings
|
|
self.assertEqual(type(complex(unicode("1"*500))), complex)
|
|
|
|
class EvilExc(Exception):
|
|
pass
|
|
|
|
class evilcomplex:
|
|
def __complex__(self):
|
|
raise EvilExc
|
|
|
|
self.assertRaises(EvilExc, complex, evilcomplex())
|
|
|
|
class float2:
|
|
def __init__(self, value):
|
|
self.value = value
|
|
def __float__(self):
|
|
return self.value
|
|
|
|
self.assertAlmostEqual(complex(float2(42.)), 42)
|
|
self.assertAlmostEqual(complex(real=float2(17.), imag=float2(23.)), 17+23j)
|
|
self.assertRaises(TypeError, complex, float2(None))
|
|
|
|
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
|
|
|
|
self.assertAlmostEqual(complex(complex0(1j)), 42j)
|
|
self.assertAlmostEqual(complex(complex1(1j)), 2j)
|
|
self.assertRaises(TypeError, complex, complex2(1j))
|
|
|
|
def test_subclass(self):
|
|
class xcomplex(complex):
|
|
def __add__(self,other):
|
|
return xcomplex(complex(self) + other)
|
|
__radd__ = __add__
|
|
|
|
def __sub__(self,other):
|
|
return xcomplex(complex(self) + other)
|
|
__rsub__ = __sub__
|
|
|
|
def __mul__(self,other):
|
|
return xcomplex(complex(self) * other)
|
|
__rmul__ = __mul__
|
|
|
|
def __div__(self,other):
|
|
return xcomplex(complex(self) / other)
|
|
|
|
def __rdiv__(self,other):
|
|
return xcomplex(other / complex(self))
|
|
|
|
__truediv__ = __div__
|
|
__rtruediv__ = __rdiv__
|
|
|
|
def __floordiv__(self,other):
|
|
return xcomplex(complex(self) // other)
|
|
|
|
def __rfloordiv__(self,other):
|
|
return xcomplex(other // complex(self))
|
|
|
|
def __pow__(self,other):
|
|
return xcomplex(complex(self) ** other)
|
|
|
|
def __rpow__(self,other):
|
|
return xcomplex(other ** complex(self) )
|
|
|
|
def __mod__(self,other):
|
|
return xcomplex(complex(self) % other)
|
|
|
|
def __rmod__(self,other):
|
|
return xcomplex(other % complex(self))
|
|
|
|
infix_binops = ('+', '-', '*', '**', '%', '//', '/')
|
|
xcomplex_values = (xcomplex(1), xcomplex(123.0),
|
|
xcomplex(-10+2j), xcomplex(3+187j),
|
|
xcomplex(3-78j))
|
|
test_values = (1, 123.0, 10-19j, xcomplex(1+2j),
|
|
xcomplex(1+87j), xcomplex(10+90j))
|
|
|
|
for op in infix_binops:
|
|
for x in xcomplex_values:
|
|
for y in test_values:
|
|
a = 'x %s y' % op
|
|
b = 'y %s x' % op
|
|
self.assertTrue(type(eval(a)) is type(eval(b)) is xcomplex)
|
|
|
|
def test_hash(self):
|
|
for x in xrange(-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.)))
|
|
|
|
def test_abs(self):
|
|
nums = [complex(x/3., y/7.) for x in xrange(-9,9) for y in xrange(-9,9)]
|
|
for num in nums:
|
|
self.assertAlmostEqual((num.real**2 + num.imag**2) ** 0.5, abs(num))
|
|
|
|
def test_repr(self):
|
|
self.assertEqual(repr(1+6j), '(1+6j)')
|
|
self.assertEqual(repr(1-6j), '(1-6j)')
|
|
|
|
self.assertNotEqual(repr(-(1+0j)), '(-1+-0j)')
|
|
|
|
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)))
|
|
|
|
self.assertEqual(repr(complex(1., INF)), "(1+infj)")
|
|
self.assertEqual(repr(complex(1., -INF)), "(1-infj)")
|
|
self.assertEqual(repr(complex(INF, 1)), "(inf+1j)")
|
|
self.assertEqual(repr(complex(-INF, INF)), "(-inf+infj)")
|
|
self.assertEqual(repr(complex(NAN, 1)), "(nan+1j)")
|
|
self.assertEqual(repr(complex(1, NAN)), "(1+nanj)")
|
|
self.assertEqual(repr(complex(NAN, NAN)), "(nan+nanj)")
|
|
|
|
self.assertEqual(repr(complex(0, INF)), "infj")
|
|
self.assertEqual(repr(complex(0, -INF)), "-infj")
|
|
self.assertEqual(repr(complex(0, NAN)), "nanj")
|
|
|
|
def test_neg(self):
|
|
self.assertEqual(-(1+6j), -1-6j)
|
|
|
|
def test_file(self):
|
|
a = 3.33+4.43j
|
|
b = 5.1+2.3j
|
|
|
|
fo = None
|
|
try:
|
|
fo = open(test_support.TESTFN, "wb")
|
|
print >>fo, a, b
|
|
fo.close()
|
|
fo = open(test_support.TESTFN, "rb")
|
|
self.assertEqual(fo.read(), "%s %s\n" % (a, b))
|
|
finally:
|
|
if (fo is not None) and (not fo.closed):
|
|
fo.close()
|
|
try:
|
|
os.remove(test_support.TESTFN)
|
|
except (OSError, IOError):
|
|
pass
|
|
|
|
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))
|
|
|
|
if float.__getformat__("double").startswith("IEEE"):
|
|
def test_plus_minus_0j(self):
|
|
# test that -0j and 0j literals are not identified
|
|
z1, z2 = 0j, -0j
|
|
self.assertEquals(atan2(z1.imag, -1.), atan2(0., -1.))
|
|
self.assertEquals(atan2(z2.imag, -1.), atan2(-0., -1.))
|
|
|
|
@unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
|
|
"test requires IEEE 754 doubles")
|
|
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))
|
|
|
|
@unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
|
|
"test requires IEEE 754 doubles")
|
|
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.assertFloatsAreIdentical(z.real, roundtrip.real)
|
|
self.assertFloatsAreIdentical(z.imag, roundtrip.imag)
|
|
|
|
# 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))
|
|
|
|
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')
|
|
|
|
# alternate is invalid
|
|
self.assertRaises(ValueError, (1.5+0.5j).__format__, '#f')
|
|
|
|
# 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: 'f' and 'F' with inf's and nan's
|
|
self.assertEqual('{0:f}'.format(INF+0j), 'inf+0.000000j')
|
|
self.assertEqual('{0:F}'.format(INF+0j), 'INF+0.000000j')
|
|
self.assertEqual('{0:f}'.format(-INF+0j), '-inf+0.000000j')
|
|
self.assertEqual('{0:F}'.format(-INF+0j), '-INF+0.000000j')
|
|
self.assertEqual('{0:f}'.format(complex(INF, INF)), 'inf+infj')
|
|
self.assertEqual('{0:F}'.format(complex(INF, INF)), 'INF+INFj')
|
|
self.assertEqual('{0:f}'.format(complex(INF, -INF)), 'inf-infj')
|
|
self.assertEqual('{0:F}'.format(complex(INF, -INF)), 'INF-INFj')
|
|
self.assertEqual('{0:f}'.format(complex(-INF, INF)), '-inf+infj')
|
|
self.assertEqual('{0:F}'.format(complex(-INF, INF)), '-INF+INFj')
|
|
self.assertEqual('{0:f}'.format(complex(-INF, -INF)), '-inf-infj')
|
|
self.assertEqual('{0:F}'.format(complex(-INF, -INF)), '-INF-INFj')
|
|
|
|
self.assertEqual('{0:f}'.format(complex(NAN, 0)), 'nan+0.000000j')
|
|
self.assertEqual('{0:F}'.format(complex(NAN, 0)), 'NAN+0.000000j')
|
|
self.assertEqual('{0:f}'.format(complex(NAN, NAN)), 'nan+nanj')
|
|
self.assertEqual('{0:F}'.format(complex(NAN, NAN)), 'NAN+NANj')
|
|
|
|
def test_main():
|
|
test_support.run_unittest(ComplexTest)
|
|
|
|
if __name__ == "__main__":
|
|
test_main()
|