diff -r ffa851df0825 -r 2fb8b9db1c86 symbian-qemu-0.9.1-12/python-2.6.1/Lib/test/test_complex.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/symbian-qemu-0.9.1-12/python-2.6.1/Lib/test/test_complex.py Fri Jul 31 15:01:17 2009 +0100 @@ -0,0 +1,395 @@ +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 + +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.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): + self.assert_(a is b) + + 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.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): + 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) + + 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.assert_(complex(c) is c) + del 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 + # 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("1"*500)) + self.assertRaises(ValueError, complex, unicode("x")) + + 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_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+inf*j)") + self.assertEqual(repr(complex(1., -INF)), "(1-inf*j)") + self.assertEqual(repr(complex(INF, 1)), "(inf+1j)") + self.assertEqual(repr(complex(-INF, INF)), "(-inf+inf*j)") + self.assertEqual(repr(complex(NAN, 1)), "(nan+1j)") + self.assertEqual(repr(complex(1, NAN)), "(1+nan*j)") + self.assertEqual(repr(complex(NAN, NAN)), "(nan+nan*j)") + + self.assertEqual(repr(complex(0, INF)), "inf*j") + self.assertEqual(repr(complex(0, -INF)), "-inf*j") + self.assertEqual(repr(complex(0, NAN)), "nan*j") + + 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.)) + +def test_main(): + test_support.run_unittest(ComplexTest) + +if __name__ == "__main__": + test_main()