from test
import test_support
category
=DeprecationWarning,
message
=".*complex divmod.*are deprecated"
from random
import random
# 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
)
unittest
.TestCase
.assertAlmostEqual(self
, a
.real
, b
)
unittest
.TestCase
.assertAlmostEqual(self
, a
.imag
, 0.)
if isinstance(b
, complex):
unittest
.TestCase
.assertAlmostEqual(self
, a
, b
.real
)
unittest
.TestCase
.assertAlmostEqual(self
, 0., b
.imag
)
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
# check that relative difference < eps
self.assert_(abs((x-y)/y) < eps)
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 assertIs(self
, a
, b
):
def check_div(self
, x
, y
):
"""Compute complex z=x*y, and check that z/x==y and z/y==x."""
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
]
# 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
)
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)
self
.assertAlmostEqual(complex.__truediv
__(2+0j
, 1+1j
), 1-1j
)
self
.assertRaises(ZeroDivisionError, complex.__truediv
__, 1+1j
, 0+0j
)
self
.assertAlmostEqual(complex.__floordiv
__(3+0j
, 1.5+0j
), 2)
self
.assertRaises(ZeroDivisionError, complex.__floordiv
__, 3+0j
, 0+0j
)
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
)
self
.assertRaises(ZeroDivisionError, (1+1j
).__mod
__, 0+0j
)
except ZeroDivisionError:
self
.fail("modulo parama can't be 0")
self
.assertRaises(ZeroDivisionError, divmod, 1+1j
, 0+0j
)
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
)
self
.assertEqual(a
** 0j
, 1)
self
.assertEqual(a
** 0.+0.j
, 1)
self
.assertEqual(3j
** 0j
, 1)
self
.assertEqual(3j
** 0, 1)
except ZeroDivisionError:
self
.fail("should fail 0.0 to negative or complex power")
except ZeroDivisionError:
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)
self
.assertRaises(ValueError, pow, a
, b
, 0)
def test_boolcontext(self
):
self
.assert_(complex(random() + 1e-6, random() + 1e-6))
self
.assert_(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
):
def __init__(self
, value
): self
.value
= value
def __complex__(self
): return self
.value
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)
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
)
self
.assert_(complex(c
) is c
)
self
.assertRaises(TypeError, complex, "1", "1")
self
.assertRaises(TypeError, complex, 1, "1")
self
.assertEqual(complex(" 3.14+J "), 3.14+1j
)
if test_support
.have_unicode
:
self
.assertEqual(complex(unicode(" 3.14+J ")), 3.14+1j
)
# SF bug 543840: complex(string) accepts strings with \0
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(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, "--")
if test_support
.have_unicode
:
self
.assertRaises(ValueError, complex, unicode("1"*500))
self
.assertRaises(ValueError, complex, unicode("x"))
class EvilExc(Exception):
self
.assertRaises(EvilExc
, complex, evilcomplex())
def __init__(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))
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.)))
nums
= [complex(x
/3., y
/7.) for x
in xrange(-9,9) for y
in xrange(-9,9)]
self
.assertAlmostEqual((num
.real
**2 + num
.imag
**2) ** 0.5, abs(num
))
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
), -1-6j
)
fo
= open(test_support
.TESTFN
, "wb")
fo
= open(test_support
.TESTFN
, "rb")
self
.assertEqual(fo
.read(), "%s %s\n" % (a
, b
))
if (fo
is not None) and (not fo
.closed
):
os
.remove(test_support
.TESTFN
)
except (OSError, IOError):
test_support
.run_unittest(ComplexTest
)
if __name__
== "__main__":