home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 June / maximum-cd-2011-06.iso / DiscContents / LibO_3.3.1_Win_x86_install_multi.exe / libreoffice1.cab / test_complex.py < prev    next >
Encoding:
Python Source  |  2011-02-15  |  15.0 KB  |  396 lines
  1. import unittest, os
  2. from test import test_support
  3.  
  4. import warnings
  5. warnings.filterwarnings(
  6.     "ignore",
  7.     category=DeprecationWarning,
  8.     message=".*complex divmod.*are deprecated"
  9. )
  10.  
  11. from random import random
  12. from math import atan2
  13.  
  14. INF = float("inf")
  15. NAN = float("nan")
  16. # These tests ensure that complex math does the right thing
  17.  
  18. class ComplexTest(unittest.TestCase):
  19.  
  20.     def assertAlmostEqual(self, a, b):
  21.         if isinstance(a, complex):
  22.             if isinstance(b, complex):
  23.                 unittest.TestCase.assertAlmostEqual(self, a.real, b.real)
  24.                 unittest.TestCase.assertAlmostEqual(self, a.imag, b.imag)
  25.             else:
  26.                 unittest.TestCase.assertAlmostEqual(self, a.real, b)
  27.                 unittest.TestCase.assertAlmostEqual(self, a.imag, 0.)
  28.         else:
  29.             if isinstance(b, complex):
  30.                 unittest.TestCase.assertAlmostEqual(self, a, b.real)
  31.                 unittest.TestCase.assertAlmostEqual(self, 0., b.imag)
  32.             else:
  33.                 unittest.TestCase.assertAlmostEqual(self, a, b)
  34.  
  35.     def assertCloseAbs(self, x, y, eps=1e-9):
  36.         """Return true iff floats x and y "are close\""""
  37.         # put the one with larger magnitude second
  38.         if abs(x) > abs(y):
  39.             x, y = y, x
  40.         if y == 0:
  41.             return abs(x) < eps
  42.         if x == 0:
  43.             return abs(y) < eps
  44.         # check that relative difference < eps
  45.         self.assert_(abs((x-y)/y) < eps)
  46.  
  47.     def assertClose(self, x, y, eps=1e-9):
  48.         """Return true iff complexes x and y "are close\""""
  49.         self.assertCloseAbs(x.real, y.real, eps)
  50.         self.assertCloseAbs(x.imag, y.imag, eps)
  51.  
  52.     def assertIs(self, a, b):
  53.         self.assert_(a is b)
  54.  
  55.     def check_div(self, x, y):
  56.         """Compute complex z=x*y, and check that z/x==y and z/y==x."""
  57.         z = x * y
  58.         if x != 0:
  59.             q = z / x
  60.             self.assertClose(q, y)
  61.             q = z.__div__(x)
  62.             self.assertClose(q, y)
  63.             q = z.__truediv__(x)
  64.             self.assertClose(q, y)
  65.         if y != 0:
  66.             q = z / y
  67.             self.assertClose(q, x)
  68.             q = z.__div__(y)
  69.             self.assertClose(q, x)
  70.             q = z.__truediv__(y)
  71.             self.assertClose(q, x)
  72.  
  73.     def test_div(self):
  74.         simple_real = [float(i) for i in xrange(-5, 6)]
  75.         simple_complex = [complex(x, y) for x in simple_real for y in simple_real]
  76.         for x in simple_complex:
  77.             for y in simple_complex:
  78.                 self.check_div(x, y)
  79.  
  80.         # A naive complex division algorithm (such as in 2.0) is very prone to
  81.         # nonsense errors for these (overflows and underflows).
  82.         self.check_div(complex(1e200, 1e200), 1+0j)
  83.         self.check_div(complex(1e-200, 1e-200), 1+0j)
  84.  
  85.         # Just for fun.
  86.         for i in xrange(100):
  87.             self.check_div(complex(random(), random()),
  88.                            complex(random(), random()))
  89.  
  90.         self.assertRaises(ZeroDivisionError, complex.__div__, 1+1j, 0+0j)
  91.         # FIXME: The following currently crashes on Alpha
  92.         # self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j)
  93.  
  94.     def test_truediv(self):
  95.         self.assertAlmostEqual(complex.__truediv__(2+0j, 1+1j), 1-1j)
  96.         self.assertRaises(ZeroDivisionError, complex.__truediv__, 1+1j, 0+0j)
  97.  
  98.     def test_floordiv(self):
  99.         self.assertAlmostEqual(complex.__floordiv__(3+0j, 1.5+0j), 2)
  100.         self.assertRaises(ZeroDivisionError, complex.__floordiv__, 3+0j, 0+0j)
  101.  
  102.     def test_coerce(self):
  103.         self.assertRaises(OverflowError, complex.__coerce__, 1+1j, 1L<<10000)
  104.  
  105.     def test_richcompare(self):
  106.         self.assertRaises(OverflowError, complex.__eq__, 1+1j, 1L<<10000)
  107.         self.assertEqual(complex.__lt__(1+1j, None), NotImplemented)
  108.         self.assertIs(complex.__eq__(1+1j, 1+1j), True)
  109.         self.assertIs(complex.__eq__(1+1j, 2+2j), False)
  110.         self.assertIs(complex.__ne__(1+1j, 1+1j), False)
  111.         self.assertIs(complex.__ne__(1+1j, 2+2j), True)
  112.         self.assertRaises(TypeError, complex.__lt__, 1+1j, 2+2j)
  113.         self.assertRaises(TypeError, complex.__le__, 1+1j, 2+2j)
  114.         self.assertRaises(TypeError, complex.__gt__, 1+1j, 2+2j)
  115.         self.assertRaises(TypeError, complex.__ge__, 1+1j, 2+2j)
  116.  
  117.     def test_mod(self):
  118.         self.assertRaises(ZeroDivisionError, (1+1j).__mod__, 0+0j)
  119.  
  120.         a = 3.33+4.43j
  121.         try:
  122.             a % 0
  123.         except ZeroDivisionError:
  124.             pass
  125.         else:
  126.             self.fail("modulo parama can't be 0")
  127.  
  128.     def test_divmod(self):
  129.         self.assertRaises(ZeroDivisionError, divmod, 1+1j, 0+0j)
  130.  
  131.     def test_pow(self):
  132.         self.assertAlmostEqual(pow(1+1j, 0+0j), 1.0)
  133.         self.assertAlmostEqual(pow(0+0j, 2+0j), 0.0)
  134.         self.assertRaises(ZeroDivisionError, pow, 0+0j, 1j)
  135.         self.assertAlmostEqual(pow(1j, -1), 1/1j)
  136.         self.assertAlmostEqual(pow(1j, 200), 1)
  137.         self.assertRaises(ValueError, pow, 1+1j, 1+1j, 1+1j)
  138.  
  139.         a = 3.33+4.43j
  140.         self.assertEqual(a ** 0j, 1)
  141.         self.assertEqual(a ** 0.+0.j, 1)
  142.  
  143.         self.assertEqual(3j ** 0j, 1)
  144.         self.assertEqual(3j ** 0, 1)
  145.  
  146.         try:
  147.             0j ** a
  148.         except ZeroDivisionError:
  149.             pass
  150.         else:
  151.             self.fail("should fail 0.0 to negative or complex power")
  152.  
  153.         try:
  154.             0j ** (3-2j)
  155.         except ZeroDivisionError:
  156.             pass
  157.         else:
  158.             self.fail("should fail 0.0 to negative or complex power")
  159.  
  160.         # The following is used to exercise certain code paths
  161.         self.assertEqual(a ** 105, a ** 105)
  162.         self.assertEqual(a ** -105, a ** -105)
  163.         self.assertEqual(a ** -30, a ** -30)
  164.  
  165.         self.assertEqual(0.0j ** 0, 1)
  166.  
  167.         b = 5.1+2.3j
  168.         self.assertRaises(ValueError, pow, a, b, 0)
  169.  
  170.     def test_boolcontext(self):
  171.         for i in xrange(100):
  172.             self.assert_(complex(random() + 1e-6, random() + 1e-6))
  173.         self.assert_(not complex(0.0, 0.0))
  174.  
  175.     def test_conjugate(self):
  176.         self.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j)
  177.  
  178.     def test_constructor(self):
  179.         class OS:
  180.             def __init__(self, value): self.value = value
  181.             def __complex__(self): return self.value
  182.         class NS(object):
  183.             def __init__(self, value): self.value = value
  184.             def __complex__(self): return self.value
  185.         self.assertEqual(complex(OS(1+10j)), 1+10j)
  186.         self.assertEqual(complex(NS(1+10j)), 1+10j)
  187.         self.assertRaises(TypeError, complex, OS(None))
  188.         self.assertRaises(TypeError, complex, NS(None))
  189.  
  190.         self.assertAlmostEqual(complex("1+10j"), 1+10j)
  191.         self.assertAlmostEqual(complex(10), 10+0j)
  192.         self.assertAlmostEqual(complex(10.0), 10+0j)
  193.         self.assertAlmostEqual(complex(10L), 10+0j)
  194.         self.assertAlmostEqual(complex(10+0j), 10+0j)
  195.         self.assertAlmostEqual(complex(1,10), 1+10j)
  196.         self.assertAlmostEqual(complex(1,10L), 1+10j)
  197.         self.assertAlmostEqual(complex(1,10.0), 1+10j)
  198.         self.assertAlmostEqual(complex(1L,10), 1+10j)
  199.         self.assertAlmostEqual(complex(1L,10L), 1+10j)
  200.         self.assertAlmostEqual(complex(1L,10.0), 1+10j)
  201.         self.assertAlmostEqual(complex(1.0,10), 1+10j)
  202.         self.assertAlmostEqual(complex(1.0,10L), 1+10j)
  203.         self.assertAlmostEqual(complex(1.0,10.0), 1+10j)
  204.         self.assertAlmostEqual(complex(3.14+0j), 3.14+0j)
  205.         self.assertAlmostEqual(complex(3.14), 3.14+0j)
  206.         self.assertAlmostEqual(complex(314), 314.0+0j)
  207.         self.assertAlmostEqual(complex(314L), 314.0+0j)
  208.         self.assertAlmostEqual(complex(3.14+0j, 0j), 3.14+0j)
  209.         self.assertAlmostEqual(complex(3.14, 0.0), 3.14+0j)
  210.         self.assertAlmostEqual(complex(314, 0), 314.0+0j)
  211.         self.assertAlmostEqual(complex(314L, 0L), 314.0+0j)
  212.         self.assertAlmostEqual(complex(0j, 3.14j), -3.14+0j)
  213.         self.assertAlmostEqual(complex(0.0, 3.14j), -3.14+0j)
  214.         self.assertAlmostEqual(complex(0j, 3.14), 3.14j)
  215.         self.assertAlmostEqual(complex(0.0, 3.14), 3.14j)
  216.         self.assertAlmostEqual(complex("1"), 1+0j)
  217.         self.assertAlmostEqual(complex("1j"), 1j)
  218.         self.assertAlmostEqual(complex(),  0)
  219.         self.assertAlmostEqual(complex("-1"), -1)
  220.         self.assertAlmostEqual(complex("+1"), +1)
  221.         self.assertAlmostEqual(complex("(1+2j)"), 1+2j)
  222.         self.assertAlmostEqual(complex("(1.3+2.2j)"), 1.3+2.2j)
  223.  
  224.         class complex2(complex): pass
  225.         self.assertAlmostEqual(complex(complex2(1+1j)), 1+1j)
  226.         self.assertAlmostEqual(complex(real=17, imag=23), 17+23j)
  227.         self.assertAlmostEqual(complex(real=17+23j), 17+23j)
  228.         self.assertAlmostEqual(complex(real=17+23j, imag=23), 17+46j)
  229.         self.assertAlmostEqual(complex(real=1+2j, imag=3+4j), -3+5j)
  230.  
  231.         # check that the sign of a zero in the real or imaginary part
  232.         # is preserved when constructing from two floats.  (These checks
  233.         # are harmless on systems without support for signed zeros.)
  234.         def split_zeros(x):
  235.             """Function that produces different results for 0. and -0."""
  236.             return atan2(x, -1.)
  237.  
  238.         self.assertEqual(split_zeros(complex(1., 0.).imag), split_zeros(0.))
  239.         self.assertEqual(split_zeros(complex(1., -0.).imag), split_zeros(-0.))
  240.         self.assertEqual(split_zeros(complex(0., 1.).real), split_zeros(0.))
  241.         self.assertEqual(split_zeros(complex(-0., 1.).real), split_zeros(-0.))
  242.  
  243.         c = 3.14 + 1j
  244.         self.assert_(complex(c) is c)
  245.         del c
  246.  
  247.         self.assertRaises(TypeError, complex, "1", "1")
  248.         self.assertRaises(TypeError, complex, 1, "1")
  249.  
  250.         self.assertEqual(complex("  3.14+J  "), 3.14+1j)
  251.         if test_support.have_unicode:
  252.             self.assertEqual(complex(unicode("  3.14+J  ")), 3.14+1j)
  253.  
  254.         # SF bug 543840:  complex(string) accepts strings with \0
  255.         # Fixed in 2.3.
  256.         self.assertRaises(ValueError, complex, '1+1j\0j')
  257.  
  258.         self.assertRaises(TypeError, int, 5+3j)
  259.         self.assertRaises(TypeError, long, 5+3j)
  260.         self.assertRaises(TypeError, float, 5+3j)
  261.         self.assertRaises(ValueError, complex, "")
  262.         self.assertRaises(TypeError, complex, None)
  263.         self.assertRaises(ValueError, complex, "\0")
  264.         self.assertRaises(ValueError, complex, "3\09")
  265.         self.assertRaises(TypeError, complex, "1", "2")
  266.         self.assertRaises(TypeError, complex, "1", 42)
  267.         self.assertRaises(TypeError, complex, 1, "2")
  268.         self.assertRaises(ValueError, complex, "1+")
  269.         self.assertRaises(ValueError, complex, "1+1j+1j")
  270.         self.assertRaises(ValueError, complex, "--")
  271.         self.assertRaises(ValueError, complex, "(1+2j")
  272.         self.assertRaises(ValueError, complex, "1+2j)")
  273.         self.assertRaises(ValueError, complex, "1+(2j)")
  274.         self.assertRaises(ValueError, complex, "(1+2j)123")
  275.         if test_support.have_unicode:
  276.             self.assertRaises(ValueError, complex, unicode("1"*500))
  277.             self.assertRaises(ValueError, complex, unicode("x"))
  278.  
  279.         class EvilExc(Exception):
  280.             pass
  281.  
  282.         class evilcomplex:
  283.             def __complex__(self):
  284.                 raise EvilExc
  285.  
  286.         self.assertRaises(EvilExc, complex, evilcomplex())
  287.  
  288.         class float2:
  289.             def __init__(self, value):
  290.                 self.value = value
  291.             def __float__(self):
  292.                 return self.value
  293.  
  294.         self.assertAlmostEqual(complex(float2(42.)), 42)
  295.         self.assertAlmostEqual(complex(real=float2(17.), imag=float2(23.)), 17+23j)
  296.         self.assertRaises(TypeError, complex, float2(None))
  297.  
  298.         class complex0(complex):
  299.             """Test usage of __complex__() when inheriting from 'complex'"""
  300.             def __complex__(self):
  301.                 return 42j
  302.  
  303.         class complex1(complex):
  304.             """Test usage of __complex__() with a __new__() method"""
  305.             def __new__(self, value=0j):
  306.                 return complex.__new__(self, 2*value)
  307.             def __complex__(self):
  308.                 return self
  309.  
  310.         class complex2(complex):
  311.             """Make sure that __complex__() calls fail if anything other than a
  312.             complex is returned"""
  313.             def __complex__(self):
  314.                 return None
  315.  
  316.         self.assertAlmostEqual(complex(complex0(1j)), 42j)
  317.         self.assertAlmostEqual(complex(complex1(1j)), 2j)
  318.         self.assertRaises(TypeError, complex, complex2(1j))
  319.  
  320.     def test_hash(self):
  321.         for x in xrange(-30, 30):
  322.             self.assertEqual(hash(x), hash(complex(x, 0)))
  323.             x /= 3.0    # now check against floating point
  324.             self.assertEqual(hash(x), hash(complex(x, 0.)))
  325.  
  326.     def test_abs(self):
  327.         nums = [complex(x/3., y/7.) for x in xrange(-9,9) for y in xrange(-9,9)]
  328.         for num in nums:
  329.             self.assertAlmostEqual((num.real**2 + num.imag**2)  ** 0.5, abs(num))
  330.  
  331.     def test_repr(self):
  332.         self.assertEqual(repr(1+6j), '(1+6j)')
  333.         self.assertEqual(repr(1-6j), '(1-6j)')
  334.  
  335.         self.assertNotEqual(repr(-(1+0j)), '(-1+-0j)')
  336.  
  337.         self.assertEqual(1-6j,complex(repr(1-6j)))
  338.         self.assertEqual(1+6j,complex(repr(1+6j)))
  339.         self.assertEqual(-6j,complex(repr(-6j)))
  340.         self.assertEqual(6j,complex(repr(6j)))
  341.  
  342.         self.assertEqual(repr(complex(1., INF)), "(1+inf*j)")
  343.         self.assertEqual(repr(complex(1., -INF)), "(1-inf*j)")
  344.         self.assertEqual(repr(complex(INF, 1)), "(inf+1j)")
  345.         self.assertEqual(repr(complex(-INF, INF)), "(-inf+inf*j)")
  346.         self.assertEqual(repr(complex(NAN, 1)), "(nan+1j)")
  347.         self.assertEqual(repr(complex(1, NAN)), "(1+nan*j)")
  348.         self.assertEqual(repr(complex(NAN, NAN)), "(nan+nan*j)")
  349.  
  350.         self.assertEqual(repr(complex(0, INF)), "inf*j")
  351.         self.assertEqual(repr(complex(0, -INF)), "-inf*j")
  352.         self.assertEqual(repr(complex(0, NAN)), "nan*j")
  353.  
  354.     def test_neg(self):
  355.         self.assertEqual(-(1+6j), -1-6j)
  356.  
  357.     def test_file(self):
  358.         a = 3.33+4.43j
  359.         b = 5.1+2.3j
  360.  
  361.         fo = None
  362.         try:
  363.             fo = open(test_support.TESTFN, "wb")
  364.             print >>fo, a, b
  365.             fo.close()
  366.             fo = open(test_support.TESTFN, "rb")
  367.             self.assertEqual(fo.read(), "%s %s\n" % (a, b))
  368.         finally:
  369.             if (fo is not None) and (not fo.closed):
  370.                 fo.close()
  371.             try:
  372.                 os.remove(test_support.TESTFN)
  373.             except (OSError, IOError):
  374.                 pass
  375.  
  376.     def test_getnewargs(self):
  377.         self.assertEqual((1+2j).__getnewargs__(), (1.0, 2.0))
  378.         self.assertEqual((1-2j).__getnewargs__(), (1.0, -2.0))
  379.         self.assertEqual((2j).__getnewargs__(), (0.0, 2.0))
  380.         self.assertEqual((-0j).__getnewargs__(), (0.0, -0.0))
  381.         self.assertEqual(complex(0, INF).__getnewargs__(), (0.0, INF))
  382.         self.assertEqual(complex(INF, 0).__getnewargs__(), (INF, 0.0))
  383.  
  384.     if float.__getformat__("double").startswith("IEEE"):
  385.         def test_plus_minus_0j(self):
  386.             # test that -0j and 0j literals are not identified
  387.             z1, z2 = 0j, -0j
  388.             self.assertEquals(atan2(z1.imag, -1.), atan2(0., -1.))
  389.             self.assertEquals(atan2(z2.imag, -1.), atan2(-0., -1.))
  390.  
  391. def test_main():
  392.     test_support.run_unittest(ComplexTest)
  393.  
  394. if __name__ == "__main__":
  395.     test_main()
  396.