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 

    13 # These tests ensure that complex math does the right thing

    14 

    15 class ComplexTest(unittest.TestCase):

    16 

    17     def assertAlmostEqual(self, a, b):

    18         if isinstance(a, complex):

    19             if isinstance(b, complex):

    20                 unittest.TestCase.assertAlmostEqual(self, a.real, b.real)

    21                 unittest.TestCase.assertAlmostEqual(self, a.imag, b.imag)

    22             else:

    23                 unittest.TestCase.assertAlmostEqual(self, a.real, b)

    24                 unittest.TestCase.assertAlmostEqual(self, a.imag, 0.)

    25         else:

    26             if isinstance(b, complex):

    27                 unittest.TestCase.assertAlmostEqual(self, a, b.real)

    28                 unittest.TestCase.assertAlmostEqual(self, 0., b.imag)

    29             else:

    30                 unittest.TestCase.assertAlmostEqual(self, a, b)

    31 

    32     def assertCloseAbs(self, x, y, eps=1e-9):

    33         """Return true iff floats x and y "are close\""""

    34         # put the one with larger magnitude second

    35         if abs(x) > abs(y):

    36             x, y = y, x

    37         if y == 0:

    38             return abs(x) < eps

    39         if x == 0:

    40             return abs(y) < eps

    41         # check that relative difference < eps

    42         self.assert_(abs((x-y)/y) < eps)

    43 

    44     def assertClose(self, x, y, eps=1e-9):

    45         """Return true iff complexes x and y "are close\""""

    46         self.assertCloseAbs(x.real, y.real, eps)

    47         self.assertCloseAbs(x.imag, y.imag, eps)

    48 

    49     def assertIs(self, a, b):

    50         self.assert_(a is b)

    51 

    52     def check_div(self, x, y):

    53         """Compute complex z=x*y, and check that z/x==y and z/y==x."""

    54         z = x * y

    55         if x != 0:

    56             q = z / x

    57             self.assertClose(q, y)

    58             q = z.__div__(x)

    59             self.assertClose(q, y)

    60             q = z.__truediv__(x)

    61             self.assertClose(q, y)

    62         if y != 0:

    63             q = z / y

    64             self.assertClose(q, x)

    65             q = z.__div__(y)

    66             self.assertClose(q, x)

    67             q = z.__truediv__(y)

    68             self.assertClose(q, x)

    69 

    70     def test_div(self):

    71         simple_real = [float(i) for i in xrange(-5, 6)]

    72         simple_complex = [complex(x, y) for x in simple_real for y in simple_real]

    73         for x in simple_complex:

    74             for y in simple_complex:

    75                 self.check_div(x, y)

    76 

    77         # A naive complex division algorithm (such as in 2.0) is very prone to

    78         # nonsense errors for these (overflows and underflows).

    79         self.check_div(complex(1e200, 1e200), 1+0j)

    80         self.check_div(complex(1e-200, 1e-200), 1+0j)

    81 

    82         # Just for fun.

    83         for i in xrange(100):

    84             self.check_div(complex(random(), random()),

    85                            complex(random(), random()))

    86 

    87         self.assertRaises(ZeroDivisionError, complex.__div__, 1+1j, 0+0j)

    88         # FIXME: The following currently crashes on Alpha

    89         # self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j)

    90 

    91     def test_truediv(self):

    92         self.assertAlmostEqual(complex.__truediv__(2+0j, 1+1j), 1-1j)

    93         self.assertRaises(ZeroDivisionError, complex.__truediv__, 1+1j, 0+0j)

    94 

    95     def test_floordiv(self):

    96         self.assertAlmostEqual(complex.__floordiv__(3+0j, 1.5+0j), 2)

    97         self.assertRaises(ZeroDivisionError, complex.__floordiv__, 3+0j, 0+0j)

    98 

    99     def test_coerce(self):

   100         self.assertRaises(OverflowError, complex.__coerce__, 1+1j, 1L<<10000)

   101 

   102     def test_richcompare(self):

   103         self.assertRaises(OverflowError, complex.__eq__, 1+1j, 1L<<10000)

   104         self.assertEqual(complex.__lt__(1+1j, None), NotImplemented)

   105         self.assertIs(complex.__eq__(1+1j, 1+1j), True)

   106         self.assertIs(complex.__eq__(1+1j, 2+2j), False)

   107         self.assertIs(complex.__ne__(1+1j, 1+1j), False)

   108         self.assertIs(complex.__ne__(1+1j, 2+2j), True)

   109         self.assertRaises(TypeError, complex.__lt__, 1+1j, 2+2j)

   110         self.assertRaises(TypeError, complex.__le__, 1+1j, 2+2j)

   111         self.assertRaises(TypeError, complex.__gt__, 1+1j, 2+2j)

   112         self.assertRaises(TypeError, complex.__ge__, 1+1j, 2+2j)

   113 

   114     def test_mod(self):

   115         self.assertRaises(ZeroDivisionError, (1+1j).__mod__, 0+0j)

   116 

   117         a = 3.33+4.43j

   118         try:

   119             a % 0

   120         except ZeroDivisionError:

   121             pass

   122         else:

   123             self.fail("modulo parama can't be 0")

   124 

   125     def test_divmod(self):

   126         self.assertRaises(ZeroDivisionError, divmod, 1+1j, 0+0j)

   127 

   128     def test_pow(self):

   129         self.assertAlmostEqual(pow(1+1j, 0+0j), 1.0)

   130         self.assertAlmostEqual(pow(0+0j, 2+0j), 0.0)

   131         self.assertRaises(ZeroDivisionError, pow, 0+0j, 1j)

   132         self.assertAlmostEqual(pow(1j, -1), 1/1j)

   133         self.assertAlmostEqual(pow(1j, 200), 1)

   134         self.assertRaises(ValueError, pow, 1+1j, 1+1j, 1+1j)

   135 

   136         a = 3.33+4.43j

   137         self.assertEqual(a ** 0j, 1)

   138         self.assertEqual(a ** 0.+0.j, 1)

   139 

   140         self.assertEqual(3j ** 0j, 1)

   141         self.assertEqual(3j ** 0, 1)

   142 

   143         try:

   144             0j ** a

   145         except ZeroDivisionError:

   146             pass

   147         else:

   148             self.fail("should fail 0.0 to negative or complex power")

   149 

   150         try:

   151             0j ** (3-2j)

   152         except ZeroDivisionError:

   153             pass

   154         else:

   155             self.fail("should fail 0.0 to negative or complex power")

   156 

   157         # The following is used to exercise certain code paths

   158         self.assertEqual(a ** 105, a ** 105)

   159         self.assertEqual(a ** -105, a ** -105)

   160         self.assertEqual(a ** -30, a ** -30)

   161 

   162         self.assertEqual(0.0j ** 0, 1)

   163 

   164         b = 5.1+2.3j

   165         self.assertRaises(ValueError, pow, a, b, 0)

   166 

   167     def test_boolcontext(self):

   168         for i in xrange(100):

   169             self.assert_(complex(random() + 1e-6, random() + 1e-6))

   170         self.assert_(not complex(0.0, 0.0))

   171 

   172     def test_conjugate(self):

   173         self.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j)

   174 

   175     def test_constructor(self):

   176         class OS:

   177             def __init__(self, value): self.value = value

   178             def __complex__(self): return self.value

   179         class NS(object):

   180             def __init__(self, value): self.value = value

   181             def __complex__(self): return self.value

   182         self.assertEqual(complex(OS(1+10j)), 1+10j)

   183         self.assertEqual(complex(NS(1+10j)), 1+10j)

   184         self.assertRaises(TypeError, complex, OS(None))

   185         self.assertRaises(TypeError, complex, NS(None))

   186 

   187         self.assertAlmostEqual(complex("1+10j"), 1+10j)

   188         self.assertAlmostEqual(complex(10), 10+0j)

   189         self.assertAlmostEqual(complex(10.0), 10+0j)

   190         self.assertAlmostEqual(complex(10L), 10+0j)

   191         self.assertAlmostEqual(complex(10+0j), 10+0j)

   192         self.assertAlmostEqual(complex(1,10), 1+10j)

   193         self.assertAlmostEqual(complex(1,10L), 1+10j)

   194         self.assertAlmostEqual(complex(1,10.0), 1+10j)

   195         self.assertAlmostEqual(complex(1L,10), 1+10j)

   196         self.assertAlmostEqual(complex(1L,10L), 1+10j)

   197         self.assertAlmostEqual(complex(1L,10.0), 1+10j)

   198         self.assertAlmostEqual(complex(1.0,10), 1+10j)

   199         self.assertAlmostEqual(complex(1.0,10L), 1+10j)

   200         self.assertAlmostEqual(complex(1.0,10.0), 1+10j)

   201         self.assertAlmostEqual(complex(3.14+0j), 3.14+0j)

   202         self.assertAlmostEqual(complex(3.14), 3.14+0j)

   203         self.assertAlmostEqual(complex(314), 314.0+0j)

   204         self.assertAlmostEqual(complex(314L), 314.0+0j)

   205         self.assertAlmostEqual(complex(3.14+0j, 0j), 3.14+0j)

   206         self.assertAlmostEqual(complex(3.14, 0.0), 3.14+0j)

   207         self.assertAlmostEqual(complex(314, 0), 314.0+0j)

   208         self.assertAlmostEqual(complex(314L, 0L), 314.0+0j)

   209         self.assertAlmostEqual(complex(0j, 3.14j), -3.14+0j)

   210         self.assertAlmostEqual(complex(0.0, 3.14j), -3.14+0j)

   211         self.assertAlmostEqual(complex(0j, 3.14), 3.14j)

   212         self.assertAlmostEqual(complex(0.0, 3.14), 3.14j)

   213         self.assertAlmostEqual(complex("1"), 1+0j)

   214         self.assertAlmostEqual(complex("1j"), 1j)

   215         self.assertAlmostEqual(complex(),  0)

   216         self.assertAlmostEqual(complex("-1"), -1)

   217         self.assertAlmostEqual(complex("+1"), +1)

   218 

   219         class complex2(complex): pass

   220         self.assertAlmostEqual(complex(complex2(1+1j)), 1+1j)

   221         self.assertAlmostEqual(complex(real=17, imag=23), 17+23j)

   222         self.assertAlmostEqual(complex(real=17+23j), 17+23j)

   223         self.assertAlmostEqual(complex(real=17+23j, imag=23), 17+46j)

   224         self.assertAlmostEqual(complex(real=1+2j, imag=3+4j), -3+5j)

   225 

   226         c = 3.14 + 1j

   227         self.assert_(complex(c) is c)

   228         del c

   229 

   230         self.assertRaises(TypeError, complex, "1", "1")

   231         self.assertRaises(TypeError, complex, 1, "1")

   232 

   233         self.assertEqual(complex("  3.14+J  "), 3.14+1j)

   234         if test_support.have_unicode:

   235             self.assertEqual(complex(unicode("  3.14+J  ")), 3.14+1j)

   236 

   237         # SF bug 543840:  complex(string) accepts strings with \0

   238         # Fixed in 2.3.

   239         self.assertRaises(ValueError, complex, '1+1j\0j')

   240 

   241         self.assertRaises(TypeError, int, 5+3j)

   242         self.assertRaises(TypeError, long, 5+3j)

   243         self.assertRaises(TypeError, float, 5+3j)

   244         self.assertRaises(ValueError, complex, "")

   245         self.assertRaises(TypeError, complex, None)

   246         self.assertRaises(ValueError, complex, "\0")

   247         self.assertRaises(TypeError, complex, "1", "2")

   248         self.assertRaises(TypeError, complex, "1", 42)

   249         self.assertRaises(TypeError, complex, 1, "2")

   250         self.assertRaises(ValueError, complex, "1+")

   251         self.assertRaises(ValueError, complex, "1+1j+1j")

   252         self.assertRaises(ValueError, complex, "--")

   253         if test_support.have_unicode:

   254             self.assertRaises(ValueError, complex, unicode("1"*500))

   255             self.assertRaises(ValueError, complex, unicode("x"))

   256 

   257         class EvilExc(Exception):

   258             pass

   259 

   260         class evilcomplex:

   261             def __complex__(self):

   262                 raise EvilExc

   263 

   264         self.assertRaises(EvilExc, complex, evilcomplex())

   265 

   266         class float2:

   267             def __init__(self, value):

   268                 self.value = value

   269             def __float__(self):

   270                 return self.value

   271 

   272         self.assertAlmostEqual(complex(float2(42.)), 42)

   273         self.assertAlmostEqual(complex(real=float2(17.), imag=float2(23.)), 17+23j)

   274         self.assertRaises(TypeError, complex, float2(None))

   275 

   276         class complex0(complex):

   277             """Test usage of __complex__() when inheriting from 'complex'"""

   278             def __complex__(self):

   279                 return 42j

   280 

   281         class complex1(complex):

   282             """Test usage of __complex__() with a __new__() method"""

   283             def __new__(self, value=0j):

   284                 return complex.__new__(self, 2*value)

   285             def __complex__(self):

   286                 return self

   287 

   288         class complex2(complex):

   289             """Make sure that __complex__() calls fail if anything other than a

   290             complex is returned"""

   291             def __complex__(self):

   292                 return None

   293 

   294         self.assertAlmostEqual(complex(complex0(1j)), 42j)

   295         self.assertAlmostEqual(complex(complex1(1j)), 2j)

   296         self.assertRaises(TypeError, complex, complex2(1j))

   297 

   298     def test_hash(self):

   299         for x in xrange(-30, 30):

   300             self.assertEqual(hash(x), hash(complex(x, 0)))

   301             x /= 3.0    # now check against floating point

   302             self.assertEqual(hash(x), hash(complex(x, 0.)))

   303 

   304     def test_abs(self):

   305         nums = [complex(x/3., y/7.) for x in xrange(-9,9) for y in xrange(-9,9)]

   306         for num in nums:

   307             self.assertAlmostEqual((num.real**2 + num.imag**2)  ** 0.5, abs(num))

   308 

   309     def test_repr(self):

   310         self.assertEqual(repr(1+6j), '(1+6j)')

   311         self.assertEqual(repr(1-6j), '(1-6j)')

   312 

   313         self.assertNotEqual(repr(-(1+0j)), '(-1+-0j)')

   314 

   315     def test_neg(self):

   316         self.assertEqual(-(1+6j), -1-6j)

   317 

   318     def test_file(self):

   319         a = 3.33+4.43j

   320         b = 5.1+2.3j

   321 

   322         fo = None

   323         try:

   324             fo = open(test_support.TESTFN, "wb")

   325             print >>fo, a, b

   326             fo.close()

   327             fo = open(test_support.TESTFN, "rb")

   328             self.assertEqual(fo.read(), "%s %s\n" % (a, b))

   329         finally:

   330             if (fo is not None) and (not fo.closed):

   331                 fo.close()

   332             try:

   333                 os.remove(test_support.TESTFN)

   334             except (OSError, IOError):

   335                 pass

   336 

   337 def test_main():

   338     test_support.run_unittest(ComplexTest)

   339 

   340 if __name__ == "__main__":

   341     test_main()