/Lib/test/test_complex.py

http://unladen-swallow.googlecode.com/ · Python · 398 lines · 339 code · 45 blank · 14 comment · 27 complexity · 2d3b675df939f2cdd180b82aa5fc4a3f MD5 · raw file

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