PageRenderTime 54ms CodeModel.GetById 16ms RepoModel.GetById 0ms app.codeStats 1ms

/lib-python/2.7/test/test_math.py

https://bitbucket.org/dac_io/pypy
Python | 1030 lines | 978 code | 21 blank | 31 comment | 41 complexity | 3b80c98ef401c245a0e023d1cf738c61 MD5 | raw file
    

  1. # Python test set -- math module
    2. 

  2. # XXXX Should not do tests around zero only
    3. 

  3. 

  4. from test.test_support import run_unittest, verbose
    5. 

  5. import unittest
    6. 

  6. import math
    7. 

  7. import os
    8. 

  8. import sys
    9. 

  9. import random
    10. 

  10. import struct
    11. 

  11. 

  12. eps = 1E-05
    13. 

  13. NAN = float('nan')
    14. 

  14. INF = float('inf')
    15. 

  15. NINF = float('-inf')
    16. 

  16. 

  17. # decorator for skipping tests on non-IEEE 754 platforms
    18. 

  18. requires_IEEE_754 = unittest.skipUnless(
    19. 

  19.     float.__getformat__("double").startswith("IEEE"),
    20. 

  20.     "test requires IEEE 754 doubles")
    21. 

  21. 

  22. # detect evidence of double-rounding: fsum is not always correctly
    23. 

  23. # rounded on machines that suffer from double rounding.
    24. 

  24. x, y = 1e16, 2.9999 # use temporary values to defeat peephole optimizer
    25. 

  25. HAVE_DOUBLE_ROUNDING = (x + y == 1e16 + 4)
    26. 

  26. 

  27. # locate file with test values
    28. 

  28. if __name__ == '__main__':
    29. 

  29.     file = sys.argv[0]
    30. 

  30. else:
    31. 

  31.     file = __file__
    32. 

  32. test_dir = os.path.dirname(file) or os.curdir
    33. 

  33. math_testcases = os.path.join(test_dir, 'math_testcases.txt')
    34. 

  34. test_file = os.path.join(test_dir, 'cmath_testcases.txt')
    35. 

  35. 

  36. def to_ulps(x):
    37. 

  37.     """Convert a non-NaN float x to an integer, in such a way that
    38. 

  38.     adjacent floats are converted to adjacent integers.  Then
    39. 

  39.     abs(ulps(x) - ulps(y)) gives the difference in ulps between two
    40. 

  40.     floats.
    41. 

  41. 

  42.     The results from this function will only make sense on platforms
    43. 

  43.     where C doubles are represented in IEEE 754 binary64 format.
    44. 

  44. 

  45.     """
    46. 

  46.     n = struct.unpack('<q', struct.pack('<d', x))[0]
    47. 

  47.     if n < 0:
    48. 

  48.         n = ~(n+2**63)
    49. 

  49.     return n
    50. 

  50. 

  51. def ulps_check(expected, got, ulps=20):
    52. 

  52.     """Given non-NaN floats `expected` and `got`,
    53. 

  53.     check that they're equal to within the given number of ulps.
    54. 

    55. 

  55.     Returns None on success and an error message on failure."""
    56. 

    57. 

  57.     ulps_error = to_ulps(got) - to_ulps(expected)
    58. 

  58.     if abs(ulps_error) <= ulps:
    59. 

  59.         return None
    60. 

  60.     return "error = {} ulps; permitted error = {} ulps".format(ulps_error,
    61. 

  61.                                                                ulps)
    62. 

  62. 

  63. def acc_check(expected, got, rel_err=2e-15, abs_err = 5e-323):
    64. 

  64.     """Determine whether non-NaN floats a and b are equal to within a
    65. 

  65.     (small) rounding error.  The default values for rel_err and
    66. 

  66.     abs_err are chosen to be suitable for platforms where a float is
    67. 

  67.     represented by an IEEE 754 double.  They allow an error of between
    68. 

  68.     9 and 19 ulps."""
    69. 

    70. 

  70.     # need to special case infinities, since inf - inf gives nan
    71. 

  71.     if math.isinf(expected) and got == expected:
    72. 

  72.         return None
    73. 

  73. 

  74.     error = got - expected
    75. 

  75. 

  76.     permitted_error = max(abs_err, rel_err * abs(expected))
    77. 

  77.     if abs(error) < permitted_error:
    78. 

  78.         return None
    79. 

  79.     return "error = {}; permitted error = {}".format(error,
    80. 

  80.                                                      permitted_error)
    81. 

  81. 

  82. def parse_mtestfile(fname):
    83. 

  83.     """Parse a file with test values
    84. 

    85. 

  85.     -- starts a comment
    86. 

  86.     blank lines, or lines containing only a comment, are ignored
    87. 

  87.     other lines are expected to have the form
    88. 

  88.       id fn arg -> expected [flag]*
    89. 

  89. 

  90.     """
    91. 

  91.     with open(fname) as fp:
    92. 

  92.         for line in fp:
    93. 

  93.             # strip comments, and skip blank lines
    94. 

  94.             if '--' in line:
    95. 

  95.                 line = line[:line.index('--')]
    96. 

  96.             if not line.strip():
    97. 

  97.                 continue
    98. 

  98. 

  99.             lhs, rhs = line.split('->')
    100. 

  100.             id, fn, arg = lhs.split()
    101. 

  101.             rhs_pieces = rhs.split()
    102. 

  102.             exp = rhs_pieces[0]
    103. 

  103.             flags = rhs_pieces[1:]
    104. 

  104. 

  105.             yield (id, fn, float(arg), float(exp), flags)
    106. 

  106. 

  107. def parse_testfile(fname):
    108. 

  108.     """Parse a file with test values
    109. 

    110. 

  110.     Empty lines or lines starting with -- are ignored
    111. 

  111.     yields id, fn, arg_real, arg_imag, exp_real, exp_imag
    112. 

  112.     """
    113. 

  113.     with open(fname) as fp:
    114. 

  114.         for line in fp:
    115. 

  115.             # skip comment lines and blank lines
    116. 

  116.             if line.startswith('--') or not line.strip():
    117. 

  117.                 continue
    118. 

  118. 

  119.             lhs, rhs = line.split('->')
    120. 

  120.             id, fn, arg_real, arg_imag = lhs.split()
    121. 

  121.             rhs_pieces = rhs.split()
    122. 

  122.             exp_real, exp_imag = rhs_pieces[0], rhs_pieces[1]
    123. 

  123.             flags = rhs_pieces[2:]
    124. 

  124. 

  125.             yield (id, fn,
    126. 

  126.                    float(arg_real), float(arg_imag),
    127. 

  127.                    float(exp_real), float(exp_imag),
    128. 

  128.                    flags
    129. 

  129.                   )
    130. 

  130. 

  131. class MathTests(unittest.TestCase):
    132. 

  132. 

  133.     def ftest(self, name, value, expected):
    134. 

  134.         if abs(value-expected) > eps:
    135. 

  135.             # Use %r instead of %f so the error message
    136. 

  136.             # displays full precision. Otherwise discrepancies
    137. 

  137.             # in the last few bits will lead to very confusing
    138. 

  138.             # error messages
    139. 

  139.             self.fail('%s returned %r, expected %r' %
    140. 

  140.                       (name, value, expected))
    141. 

  141. 

  142.     def testConstants(self):
    143. 

  143.         self.ftest('pi', math.pi, 3.1415926)
    144. 

  144.         self.ftest('e', math.e, 2.7182818)
    145. 

  145. 

  146.     def testAcos(self):
    147. 

  147.         self.assertRaises(TypeError, math.acos)
    148. 

  148.         self.ftest('acos(-1)', math.acos(-1), math.pi)
    149. 

  149.         self.ftest('acos(0)', math.acos(0), math.pi/2)
    150. 

  150.         self.ftest('acos(1)', math.acos(1), 0)
    151. 

  151.         self.assertRaises(ValueError, math.acos, INF)
    152. 

  152.         self.assertRaises(ValueError, math.acos, NINF)
    153. 

  153.         self.assertTrue(math.isnan(math.acos(NAN)))
    154. 

  154. 

  155.     def testAcosh(self):
    156. 

  156.         self.assertRaises(TypeError, math.acosh)
    157. 

  157.         self.ftest('acosh(1)', math.acosh(1), 0)
    158. 

  158.         self.ftest('acosh(2)', math.acosh(2), 1.3169578969248168)
    159. 

  159.         self.assertRaises(ValueError, math.acosh, 0)
    160. 

  160.         self.assertRaises(ValueError, math.acosh, -1)
    161. 

  161.         self.assertEqual(math.acosh(INF), INF)
    162. 

  162.         self.assertRaises(ValueError, math.acosh, NINF)
    163. 

  163.         self.assertTrue(math.isnan(math.acosh(NAN)))
    164. 

  164. 

  165.     def testAsin(self):
    166. 

  166.         self.assertRaises(TypeError, math.asin)
    167. 

  167.         self.ftest('asin(-1)', math.asin(-1), -math.pi/2)
    168. 

  168.         self.ftest('asin(0)', math.asin(0), 0)
    169. 

  169.         self.ftest('asin(1)', math.asin(1), math.pi/2)
    170. 

  170.         self.assertRaises(ValueError, math.asin, INF)
    171. 

  171.         self.assertRaises(ValueError, math.asin, NINF)
    172. 

  172.         self.assertTrue(math.isnan(math.asin(NAN)))
    173. 

  173. 

  174.     def testAsinh(self):
    175. 

  175.         self.assertRaises(TypeError, math.asinh)
    176. 

  176.         self.ftest('asinh(0)', math.asinh(0), 0)
    177. 

  177.         self.ftest('asinh(1)', math.asinh(1), 0.88137358701954305)
    178. 

  178.         self.ftest('asinh(-1)', math.asinh(-1), -0.88137358701954305)
    179. 

  179.         self.assertEqual(math.asinh(INF), INF)
    180. 

  180.         self.assertEqual(math.asinh(NINF), NINF)
    181. 

  181.         self.assertTrue(math.isnan(math.asinh(NAN)))
    182. 

  182. 

  183.     def testAtan(self):
    184. 

  184.         self.assertRaises(TypeError, math.atan)
    185. 

  185.         self.ftest('atan(-1)', math.atan(-1), -math.pi/4)
    186. 

  186.         self.ftest('atan(0)', math.atan(0), 0)
    187. 

  187.         self.ftest('atan(1)', math.atan(1), math.pi/4)
    188. 

  188.         self.ftest('atan(inf)', math.atan(INF), math.pi/2)
    189. 

  189.         self.ftest('atan(-inf)', math.atan(NINF), -math.pi/2)
    190. 

  190.         self.assertTrue(math.isnan(math.atan(NAN)))
    191. 

  191. 

  192.     def testAtanh(self):
    193. 

  193.         self.assertRaises(TypeError, math.atan)
    194. 

  194.         self.ftest('atanh(0)', math.atanh(0), 0)
    195. 

  195.         self.ftest('atanh(0.5)', math.atanh(0.5), 0.54930614433405489)
    196. 

  196.         self.ftest('atanh(-0.5)', math.atanh(-0.5), -0.54930614433405489)
    197. 

  197.         self.assertRaises(ValueError, math.atanh, 1)
    198. 

  198.         self.assertRaises(ValueError, math.atanh, -1)
    199. 

  199.         self.assertRaises(ValueError, math.atanh, INF)
    200. 

  200.         self.assertRaises(ValueError, math.atanh, NINF)
    201. 

  201.         self.assertTrue(math.isnan(math.atanh(NAN)))
    202. 

  202. 

  203.     def testAtan2(self):
    204. 

  204.         self.assertRaises(TypeError, math.atan2)
    205. 

  205.         self.ftest('atan2(-1, 0)', math.atan2(-1, 0), -math.pi/2)
    206. 

  206.         self.ftest('atan2(-1, 1)', math.atan2(-1, 1), -math.pi/4)
    207. 

  207.         self.ftest('atan2(0, 1)', math.atan2(0, 1), 0)
    208. 

  208.         self.ftest('atan2(1, 1)', math.atan2(1, 1), math.pi/4)
    209. 

  209.         self.ftest('atan2(1, 0)', math.atan2(1, 0), math.pi/2)
    210. 

  210. 

  211.         # math.atan2(0, x)
    212. 

  212.         self.ftest('atan2(0., -inf)', math.atan2(0., NINF), math.pi)
    213. 

  213.         self.ftest('atan2(0., -2.3)', math.atan2(0., -2.3), math.pi)
    214. 

  214.         self.ftest('atan2(0., -0.)', math.atan2(0., -0.), math.pi)
    215. 

  215.         self.assertEqual(math.atan2(0., 0.), 0.)
    216. 

  216.         self.assertEqual(math.atan2(0., 2.3), 0.)
    217. 

  217.         self.assertEqual(math.atan2(0., INF), 0.)
    218. 

  218.         self.assertTrue(math.isnan(math.atan2(0., NAN)))
    219. 

  219.         # math.atan2(-0, x)
    220. 

  220.         self.ftest('atan2(-0., -inf)', math.atan2(-0., NINF), -math.pi)
    221. 

  221.         self.ftest('atan2(-0., -2.3)', math.atan2(-0., -2.3), -math.pi)
    222. 

  222.         self.ftest('atan2(-0., -0.)', math.atan2(-0., -0.), -math.pi)
    223. 

  223.         self.assertEqual(math.atan2(-0., 0.), -0.)
    224. 

  224.         self.assertEqual(math.atan2(-0., 2.3), -0.)
    225. 

  225.         self.assertEqual(math.atan2(-0., INF), -0.)
    226. 

  226.         self.assertTrue(math.isnan(math.atan2(-0., NAN)))
    227. 

  227.         # math.atan2(INF, x)
    228. 

  228.         self.ftest('atan2(inf, -inf)', math.atan2(INF, NINF), math.pi*3/4)
    229. 

  229.         self.ftest('atan2(inf, -2.3)', math.atan2(INF, -2.3), math.pi/2)
    230. 

  230.         self.ftest('atan2(inf, -0.)', math.atan2(INF, -0.0), math.pi/2)
    231. 

  231.         self.ftest('atan2(inf, 0.)', math.atan2(INF, 0.0), math.pi/2)
    232. 

  232.         self.ftest('atan2(inf, 2.3)', math.atan2(INF, 2.3), math.pi/2)
    233. 

  233.         self.ftest('atan2(inf, inf)', math.atan2(INF, INF), math.pi/4)
    234. 

  234.         self.assertTrue(math.isnan(math.atan2(INF, NAN)))
    235. 

  235.         # math.atan2(NINF, x)
    236. 

  236.         self.ftest('atan2(-inf, -inf)', math.atan2(NINF, NINF), -math.pi*3/4)
    237. 

  237.         self.ftest('atan2(-inf, -2.3)', math.atan2(NINF, -2.3), -math.pi/2)
    238. 

  238.         self.ftest('atan2(-inf, -0.)', math.atan2(NINF, -0.0), -math.pi/2)
    239. 

  239.         self.ftest('atan2(-inf, 0.)', math.atan2(NINF, 0.0), -math.pi/2)
    240. 

  240.         self.ftest('atan2(-inf, 2.3)', math.atan2(NINF, 2.3), -math.pi/2)
    241. 

  241.         self.ftest('atan2(-inf, inf)', math.atan2(NINF, INF), -math.pi/4)
    242. 

  242.         self.assertTrue(math.isnan(math.atan2(NINF, NAN)))
    243. 

  243.         # math.atan2(+finite, x)
    244. 

  244.         self.ftest('atan2(2.3, -inf)', math.atan2(2.3, NINF), math.pi)
    245. 

  245.         self.ftest('atan2(2.3, -0.)', math.atan2(2.3, -0.), math.pi/2)
    246. 

  246.         self.ftest('atan2(2.3, 0.)', math.atan2(2.3, 0.), math.pi/2)
    247. 

  247.         self.assertEqual(math.atan2(2.3, INF), 0.)
    248. 

  248.         self.assertTrue(math.isnan(math.atan2(2.3, NAN)))
    249. 

  249.         # math.atan2(-finite, x)
    250. 

  250.         self.ftest('atan2(-2.3, -inf)', math.atan2(-2.3, NINF), -math.pi)
    251. 

  251.         self.ftest('atan2(-2.3, -0.)', math.atan2(-2.3, -0.), -math.pi/2)
    252. 

  252.         self.ftest('atan2(-2.3, 0.)', math.atan2(-2.3, 0.), -math.pi/2)
    253. 

  253.         self.assertEqual(math.atan2(-2.3, INF), -0.)
    254. 

  254.         self.assertTrue(math.isnan(math.atan2(-2.3, NAN)))
    255. 

  255.         # math.atan2(NAN, x)
    256. 

  256.         self.assertTrue(math.isnan(math.atan2(NAN, NINF)))
    257. 

  257.         self.assertTrue(math.isnan(math.atan2(NAN, -2.3)))
    258. 

  258.         self.assertTrue(math.isnan(math.atan2(NAN, -0.)))
    259. 

  259.         self.assertTrue(math.isnan(math.atan2(NAN, 0.)))
    260. 

  260.         self.assertTrue(math.isnan(math.atan2(NAN, 2.3)))
    261. 

  261.         self.assertTrue(math.isnan(math.atan2(NAN, INF)))
    262. 

  262.         self.assertTrue(math.isnan(math.atan2(NAN, NAN)))
    263. 

  263. 

  264.     def testCeil(self):
    265. 

  265.         self.assertRaises(TypeError, math.ceil)
    266. 

  266.         # These types will be int in py3k.
    267. 

  267.         self.assertEqual(float, type(math.ceil(1)))
    268. 

  268.         self.assertEqual(float, type(math.ceil(1L)))
    269. 

  269.         self.assertEqual(float, type(math.ceil(1.0)))
    270. 

  270.         self.ftest('ceil(0.5)', math.ceil(0.5), 1)
    271. 

  271.         self.ftest('ceil(1.0)', math.ceil(1.0), 1)
    272. 

  272.         self.ftest('ceil(1.5)', math.ceil(1.5), 2)
    273. 

  273.         self.ftest('ceil(-0.5)', math.ceil(-0.5), 0)
    274. 

  274.         self.ftest('ceil(-1.0)', math.ceil(-1.0), -1)
    275. 

  275.         self.ftest('ceil(-1.5)', math.ceil(-1.5), -1)
    276. 

  276.         self.assertEqual(math.ceil(INF), INF)
    277. 

  277.         self.assertEqual(math.ceil(NINF), NINF)
    278. 

  278.         self.assertTrue(math.isnan(math.ceil(NAN)))
    279. 

  279. 

  280.         class TestCeil(object):
    281. 

  281.             def __float__(self):
    282. 

  282.                 return 41.3
    283. 

  283.         class TestNoCeil(object):
    284. 

  284.             pass
    285. 

  285.         self.ftest('ceil(TestCeil())', math.ceil(TestCeil()), 42)
    286. 

  286.         self.assertRaises(TypeError, math.ceil, TestNoCeil())
    287. 

  287. 

  288.         t = TestNoCeil()
    289. 

  289.         t.__ceil__ = lambda *args: args
    290. 

  290.         self.assertRaises(TypeError, math.ceil, t)
    291. 

  291.         self.assertRaises(TypeError, math.ceil, t, 0)
    292. 

  292. 

  293.     @requires_IEEE_754
    294. 

  294.     def testCopysign(self):
    295. 

  295.         self.assertEqual(math.copysign(1, 42), 1.0)
    296. 

  296.         self.assertEqual(math.copysign(0., 42), 0.0)
    297. 

  297.         self.assertEqual(math.copysign(1., -42), -1.0)
    298. 

  298.         self.assertEqual(math.copysign(3, 0.), 3.0)
    299. 

  299.         self.assertEqual(math.copysign(4., -0.), -4.0)
    300. 

  300. 

  301.         self.assertRaises(TypeError, math.copysign)
    302. 

  302.         # copysign should let us distinguish signs of zeros
    303. 

  303.         self.assertEqual(math.copysign(1., 0.), 1.)
    304. 

  304.         self.assertEqual(math.copysign(1., -0.), -1.)
    305. 

  305.         self.assertEqual(math.copysign(INF, 0.), INF)
    306. 

  306.         self.assertEqual(math.copysign(INF, -0.), NINF)
    307. 

  307.         self.assertEqual(math.copysign(NINF, 0.), INF)
    308. 

  308.         self.assertEqual(math.copysign(NINF, -0.), NINF)
    309. 

  309.         # and of infinities
    310. 

  310.         self.assertEqual(math.copysign(1., INF), 1.)
    311. 

  311.         self.assertEqual(math.copysign(1., NINF), -1.)
    312. 

  312.         self.assertEqual(math.copysign(INF, INF), INF)
    313. 

  313.         self.assertEqual(math.copysign(INF, NINF), NINF)
    314. 

  314.         self.assertEqual(math.copysign(NINF, INF), INF)
    315. 

  315.         self.assertEqual(math.copysign(NINF, NINF), NINF)
    316. 

  316.         self.assertTrue(math.isnan(math.copysign(NAN, 1.)))
    317. 

  317.         self.assertTrue(math.isnan(math.copysign(NAN, INF)))
    318. 

  318.         self.assertTrue(math.isnan(math.copysign(NAN, NINF)))
    319. 

  319.         self.assertTrue(math.isnan(math.copysign(NAN, NAN)))
    320. 

  320.         # copysign(INF, NAN) may be INF or it may be NINF, since
    321. 

  321.         # we don't know whether the sign bit of NAN is set on any
    322. 

  322.         # given platform.
    323. 

  323.         self.assertTrue(math.isinf(math.copysign(INF, NAN)))
    324. 

  324.         # similarly, copysign(2., NAN) could be 2. or -2.
    325. 

  325.         self.assertEqual(abs(math.copysign(2., NAN)), 2.)
    326. 

  326. 

  327.     def testCos(self):
    328. 

  328.         self.assertRaises(TypeError, math.cos)
    329. 

  329.         self.ftest('cos(-pi/2)', math.cos(-math.pi/2), 0)
    330. 

  330.         self.ftest('cos(0)', math.cos(0), 1)
    331. 

  331.         self.ftest('cos(pi/2)', math.cos(math.pi/2), 0)
    332. 

  332.         self.ftest('cos(pi)', math.cos(math.pi), -1)
    333. 

  333.         try:
    334. 

  334.             self.assertTrue(math.isnan(math.cos(INF)))
    335. 

  335.             self.assertTrue(math.isnan(math.cos(NINF)))
    336. 

  336.         except ValueError:
    337. 

  337.             self.assertRaises(ValueError, math.cos, INF)
    338. 

  338.             self.assertRaises(ValueError, math.cos, NINF)
    339. 

  339.         self.assertTrue(math.isnan(math.cos(NAN)))
    340. 

  340. 

  341.     def testCosh(self):
    342. 

  342.         self.assertRaises(TypeError, math.cosh)
    343. 

  343.         self.ftest('cosh(0)', math.cosh(0), 1)
    344. 

  344.         self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert
    345. 

  345.         self.assertEqual(math.cosh(INF), INF)
    346. 

  346.         self.assertEqual(math.cosh(NINF), INF)
    347. 

  347.         self.assertTrue(math.isnan(math.cosh(NAN)))
    348. 

  348. 

  349.     def testDegrees(self):
    350. 

  350.         self.assertRaises(TypeError, math.degrees)
    351. 

  351.         self.ftest('degrees(pi)', math.degrees(math.pi), 180.0)
    352. 

  352.         self.ftest('degrees(pi/2)', math.degrees(math.pi/2), 90.0)
    353. 

  353.         self.ftest('degrees(-pi/4)', math.degrees(-math.pi/4), -45.0)
    354. 

  354. 

  355.     def testExp(self):
    356. 

  356.         self.assertRaises(TypeError, math.exp)
    357. 

  357.         self.ftest('exp(-1)', math.exp(-1), 1/math.e)
    358. 

  358.         self.ftest('exp(0)', math.exp(0), 1)
    359. 

  359.         self.ftest('exp(1)', math.exp(1), math.e)
    360. 

  360.         self.assertEqual(math.exp(INF), INF)
    361. 

  361.         self.assertEqual(math.exp(NINF), 0.)
    362. 

  362.         self.assertTrue(math.isnan(math.exp(NAN)))
    363. 

  363. 

  364.     def testFabs(self):
    365. 

  365.         self.assertRaises(TypeError, math.fabs)
    366. 

  366.         self.ftest('fabs(-1)', math.fabs(-1), 1)
    367. 

  367.         self.ftest('fabs(0)', math.fabs(0), 0)
    368. 

  368.         self.ftest('fabs(1)', math.fabs(1), 1)
    369. 

  369. 

  370.     def testFactorial(self):
    371. 

  371.         def fact(n):
    372. 

  372.             result = 1
    373. 

  373.             for i in range(1, int(n)+1):
    374. 

  374.                 result *= i
    375. 

  375.             return result
    376. 

  376.         values = range(10) + [50, 100, 500]
    377. 

  377.         random.shuffle(values)
    378. 

  378.         for x in values:
    379. 

  379.             for cast in (int, long, float):
    380. 

  380.                 self.assertEqual(math.factorial(cast(x)), fact(x), (x, fact(x), math.factorial(x)))
    381. 

  381.         self.assertRaises(ValueError, math.factorial, -1)
    382. 

  382.         self.assertRaises(ValueError, math.factorial, math.pi)
    383. 

  383. 

  384.     def testFloor(self):
    385. 

  385.         self.assertRaises(TypeError, math.floor)
    386. 

  386.         # These types will be int in py3k.
    387. 

  387.         self.assertEqual(float, type(math.floor(1)))
    388. 

  388.         self.assertEqual(float, type(math.floor(1L)))
    389. 

  389.         self.assertEqual(float, type(math.floor(1.0)))
    390. 

  390.         self.ftest('floor(0.5)', math.floor(0.5), 0)
    391. 

  391.         self.ftest('floor(1.0)', math.floor(1.0), 1)
    392. 

  392.         self.ftest('floor(1.5)', math.floor(1.5), 1)
    393. 

  393.         self.ftest('floor(-0.5)', math.floor(-0.5), -1)
    394. 

  394.         self.ftest('floor(-1.0)', math.floor(-1.0), -1)
    395. 

  395.         self.ftest('floor(-1.5)', math.floor(-1.5), -2)
    396. 

  396.         # pow() relies on floor() to check for integers
    397. 

  397.         # This fails on some platforms - so check it here
    398. 

  398.         self.ftest('floor(1.23e167)', math.floor(1.23e167), 1.23e167)
    399. 

  399.         self.ftest('floor(-1.23e167)', math.floor(-1.23e167), -1.23e167)
    400. 

  400.         self.assertEqual(math.ceil(INF), INF)
    401. 

  401.         self.assertEqual(math.ceil(NINF), NINF)
    402. 

  402.         self.assertTrue(math.isnan(math.floor(NAN)))
    403. 

  403. 

  404.         class TestFloor(object):
    405. 

  405.             def __float__(self):
    406. 

  406.                 return 42.3
    407. 

  407.         class TestNoFloor(object):
    408. 

  408.             pass
    409. 

  409.         self.ftest('floor(TestFloor())', math.floor(TestFloor()), 42)
    410. 

  410.         self.assertRaises(TypeError, math.floor, TestNoFloor())
    411. 

  411. 

  412.         t = TestNoFloor()
    413. 

  413.         t.__floor__ = lambda *args: args
    414. 

  414.         self.assertRaises(TypeError, math.floor, t)
    415. 

  415.         self.assertRaises(TypeError, math.floor, t, 0)
    416. 

  416. 

  417.     def testFmod(self):
    418. 

  418.         self.assertRaises(TypeError, math.fmod)
    419. 

  419.         self.ftest('fmod(10,1)', math.fmod(10,1), 0)
    420. 

  420.         self.ftest('fmod(10,0.5)', math.fmod(10,0.5), 0)
    421. 

  421.         self.ftest('fmod(10,1.5)', math.fmod(10,1.5), 1)
    422. 

  422.         self.ftest('fmod(-10,1)', math.fmod(-10,1), 0)
    423. 

  423.         self.ftest('fmod(-10,0.5)', math.fmod(-10,0.5), 0)
    424. 

  424.         self.ftest('fmod(-10,1.5)', math.fmod(-10,1.5), -1)
    425. 

  425.         self.assertTrue(math.isnan(math.fmod(NAN, 1.)))
    426. 

  426.         self.assertTrue(math.isnan(math.fmod(1., NAN)))
    427. 

  427.         self.assertTrue(math.isnan(math.fmod(NAN, NAN)))
    428. 

  428.         self.assertRaises(ValueError, math.fmod, 1., 0.)
    429. 

  429.         self.assertRaises(ValueError, math.fmod, INF, 1.)
    430. 

  430.         self.assertRaises(ValueError, math.fmod, NINF, 1.)
    431. 

  431.         self.assertRaises(ValueError, math.fmod, INF, 0.)
    432. 

  432.         self.assertEqual(math.fmod(3.0, INF), 3.0)
    433. 

  433.         self.assertEqual(math.fmod(-3.0, INF), -3.0)
    434. 

  434.         self.assertEqual(math.fmod(3.0, NINF), 3.0)
    435. 

  435.         self.assertEqual(math.fmod(-3.0, NINF), -3.0)
    436. 

  436.         self.assertEqual(math.fmod(0.0, 3.0), 0.0)
    437. 

  437.         self.assertEqual(math.fmod(0.0, NINF), 0.0)
    438. 

  438. 

  439.     def testFrexp(self):
    440. 

  440.         self.assertRaises(TypeError, math.frexp)
    441. 

  441. 

  442.         def testfrexp(name, result, expected):
    443. 

  443.             (mant, exp), (emant, eexp) = result, expected
    444. 

  444.             if abs(mant-emant) > eps or exp != eexp:
    445. 

  445.                 self.fail('%s returned %r, expected %r'%\
    446. 

  446.                           (name, (mant, exp), (emant,eexp)))
    447. 

  447. 

  448.         testfrexp('frexp(-1)', math.frexp(-1), (-0.5, 1))
    449. 

  449.         testfrexp('frexp(0)', math.frexp(0), (0, 0))
    450. 

  450.         testfrexp('frexp(1)', math.frexp(1), (0.5, 1))
    451. 

  451.         testfrexp('frexp(2)', math.frexp(2), (0.5, 2))
    452. 

  452. 

  453.         self.assertEqual(math.frexp(INF)[0], INF)
    454. 

  454.         self.assertEqual(math.frexp(NINF)[0], NINF)
    455. 

  455.         self.assertTrue(math.isnan(math.frexp(NAN)[0]))
    456. 

  456. 

  457.     @requires_IEEE_754
    458. 

  458.     @unittest.skipIf(HAVE_DOUBLE_ROUNDING,
    459. 

  459.                          "fsum is not exact on machines with double rounding")
    460. 

  460.     def testFsum(self):
    461. 

  461.         # math.fsum relies on exact rounding for correct operation.
    462. 

  462.         # There's a known problem with IA32 floating-point that causes
    463. 

  463.         # inexact rounding in some situations, and will cause the
    464. 

  464.         # math.fsum tests below to fail; see issue #2937.  On non IEEE
    465. 

  465.         # 754 platforms, and on IEEE 754 platforms that exhibit the
    466. 

  466.         # problem described in issue #2937, we simply skip the whole
    467. 

  467.         # test.
    468. 

  468. 

  469.         # Python version of math.fsum, for comparison.  Uses a
    470. 

  470.         # different algorithm based on frexp, ldexp and integer
    471. 

  471.         # arithmetic.
    472. 

  472.         from sys import float_info
    473. 

  473.         mant_dig = float_info.mant_dig
    474. 

  474.         etiny = float_info.min_exp - mant_dig
    475. 

  475. 

  476.         def msum(iterable):
    477. 

  477.             """Full precision summation.  Compute sum(iterable) without any
    478. 

  478.             intermediate accumulation of error.  Based on the 'lsum' function
    479. 

  479.             at http://code.activestate.com/recipes/393090/
    480. 

  480. 

  481.             """
    482. 

  482.             tmant, texp = 0, 0
    483. 

  483.             for x in iterable:
    484. 

  484.                 mant, exp = math.frexp(x)
    485. 

  485.                 mant, exp = int(math.ldexp(mant, mant_dig)), exp - mant_dig
    486. 

  486.                 if texp > exp:
    487. 

  487.                     tmant <<= texp-exp
    488. 

  488.                     texp = exp
    489. 

  489.                 else:
    490. 

  490.                     mant <<= exp-texp
    491. 

  491.                 tmant += mant
    492. 

  492.             # Round tmant * 2**texp to a float.  The original recipe
    493. 

  493.             # used float(str(tmant)) * 2.0**texp for this, but that's
    494. 

  494.             # a little unsafe because str -> float conversion can't be
    495. 

  495.             # relied upon to do correct rounding on all platforms.
    496. 

  496.             tail = max(len(bin(abs(tmant)))-2 - mant_dig, etiny - texp)
    497. 

  497.             if tail > 0:
    498. 

  498.                 h = 1 << (tail-1)
    499. 

  499.                 tmant = tmant // (2*h) + bool(tmant & h and tmant & 3*h-1)
    500. 

  500.                 texp += tail
    501. 

  501.             return math.ldexp(tmant, texp)
    502. 

  502. 

  503.         test_values = [
    504. 

  504.             ([], 0.0),
    505. 

  505.             ([0.0], 0.0),
    506. 

  506.             ([1e100, 1.0, -1e100, 1e-100, 1e50, -1.0, -1e50], 1e-100),
    507. 

  507.             ([2.0**53, -0.5, -2.0**-54], 2.0**53-1.0),
    508. 

  508.             ([2.0**53, 1.0, 2.0**-100], 2.0**53+2.0),
    509. 

  509.             ([2.0**53+10.0, 1.0, 2.0**-100], 2.0**53+12.0),
    510. 

  510.             ([2.0**53-4.0, 0.5, 2.0**-54], 2.0**53-3.0),
    511. 

  511.             ([1./n for n in range(1, 1001)],
    512. 

  512.              float.fromhex('0x1.df11f45f4e61ap+2')),
    513. 

  513.             ([(-1.)**n/n for n in range(1, 1001)],
    514. 

  514.              float.fromhex('-0x1.62a2af1bd3624p-1')),
    515. 

  515.             ([1.7**(i+1)-1.7**i for i in range(1000)] + [-1.7**1000], -1.0),
    516. 

  516.             ([1e16, 1., 1e-16], 10000000000000002.0),
    517. 

  517.             ([1e16-2., 1.-2.**-53, -(1e16-2.), -(1.-2.**-53)], 0.0),
    518. 

  518.             # exercise code for resizing partials array
    519. 

  519.             ([2.**n - 2.**(n+50) + 2.**(n+52) for n in range(-1074, 972, 2)] +
    520. 

  520.              [-2.**1022],
    521. 

  521.              float.fromhex('0x1.5555555555555p+970')),
    522. 

  522.             ]
    523. 

  523. 

  524.         for i, (vals, expected) in enumerate(test_values):
    525. 

  525.             try:
    526. 

  526.                 actual = math.fsum(vals)
    527. 

  527.             except OverflowError:
    528. 

  528.                 self.fail("test %d failed: got OverflowError, expected %r "
    529. 

  529.                           "for math.fsum(%.100r)" % (i, expected, vals))
    530. 

  530.             except ValueError:
    531. 

  531.                 self.fail("test %d failed: got ValueError, expected %r "
    532. 

  532.                           "for math.fsum(%.100r)" % (i, expected, vals))
    533. 

  533.             self.assertEqual(actual, expected)
    534. 

  534. 

  535.         from random import random, gauss, shuffle
    536. 

  536.         for j in xrange(1000):
    537. 

  537.             vals = [7, 1e100, -7, -1e100, -9e-20, 8e-20] * 10
    538. 

  538.             s = 0
    539. 

  539.             for i in xrange(200):
    540. 

  540.                 v = gauss(0, random()) ** 7 - s
    541. 

  541.                 s += v
    542. 

  542.                 vals.append(v)
    543. 

  543.             shuffle(vals)
    544. 

  544. 

  545.             s = msum(vals)
    546. 

  546.             self.assertEqual(msum(vals), math.fsum(vals))
    547. 

  547. 

  548.     def testHypot(self):
    549. 

  549.         self.assertRaises(TypeError, math.hypot)
    550. 

  550.         self.ftest('hypot(0,0)', math.hypot(0,0), 0)
    551. 

  551.         self.ftest('hypot(3,4)', math.hypot(3,4), 5)
    552. 

  552.         self.assertEqual(math.hypot(NAN, INF), INF)
    553. 

  553.         self.assertEqual(math.hypot(INF, NAN), INF)
    554. 

  554.         self.assertEqual(math.hypot(NAN, NINF), INF)
    555. 

  555.         self.assertEqual(math.hypot(NINF, NAN), INF)
    556. 

  556.         self.assertTrue(math.isnan(math.hypot(1.0, NAN)))
    557. 

  557.         self.assertTrue(math.isnan(math.hypot(NAN, -2.0)))
    558. 

  558. 

  559.     def testLdexp(self):
    560. 

  560.         self.assertRaises(TypeError, math.ldexp)
    561. 

  561.         self.ftest('ldexp(0,1)', math.ldexp(0,1), 0)
    562. 

  562.         self.ftest('ldexp(1,1)', math.ldexp(1,1), 2)
    563. 

  563.         self.ftest('ldexp(1,-1)', math.ldexp(1,-1), 0.5)
    564. 

  564.         self.ftest('ldexp(-1,1)', math.ldexp(-1,1), -2)
    565. 

  565.         self.assertRaises(OverflowError, math.ldexp, 1., 1000000)
    566. 

  566.         self.assertRaises(OverflowError, math.ldexp, -1., 1000000)
    567. 

  567.         self.assertEqual(math.ldexp(1., -1000000), 0.)
    568. 

  568.         self.assertEqual(math.ldexp(-1., -1000000), -0.)
    569. 

  569.         self.assertEqual(math.ldexp(INF, 30), INF)
    570. 

  570.         self.assertEqual(math.ldexp(NINF, -213), NINF)
    571. 

  571.         self.assertTrue(math.isnan(math.ldexp(NAN, 0)))
    572. 

  572. 

  573.         # large second argument
    574. 

  574.         for n in [10**5, 10L**5, 10**10, 10L**10, 10**20, 10**40]:
    575. 

  575.             self.assertEqual(math.ldexp(INF, -n), INF)
    576. 

  576.             self.assertEqual(math.ldexp(NINF, -n), NINF)
    577. 

  577.             self.assertEqual(math.ldexp(1., -n), 0.)
    578. 

  578.             self.assertEqual(math.ldexp(-1., -n), -0.)
    579. 

  579.             self.assertEqual(math.ldexp(0., -n), 0.)
    580. 

  580.             self.assertEqual(math.ldexp(-0., -n), -0.)
    581. 

  581.             self.assertTrue(math.isnan(math.ldexp(NAN, -n)))
    582. 

  582. 

  583.             self.assertRaises(OverflowError, math.ldexp, 1., n)
    584. 

  584.             self.assertRaises(OverflowError, math.ldexp, -1., n)
    585. 

  585.             self.assertEqual(math.ldexp(0., n), 0.)
    586. 

  586.             self.assertEqual(math.ldexp(-0., n), -0.)
    587. 

  587.             self.assertEqual(math.ldexp(INF, n), INF)
    588. 

  588.             self.assertEqual(math.ldexp(NINF, n), NINF)
    589. 

  589.             self.assertTrue(math.isnan(math.ldexp(NAN, n)))
    590. 

  590. 

  591.     def testLog(self):
    592. 

  592.         self.assertRaises(TypeError, math.log)
    593. 

  593.         self.ftest('log(1/e)', math.log(1/math.e), -1)
    594. 

  594.         self.ftest('log(1)', math.log(1), 0)
    595. 

  595.         self.ftest('log(e)', math.log(math.e), 1)
    596. 

  596.         self.ftest('log(32,2)', math.log(32,2), 5)
    597. 

  597.         self.ftest('log(10**40, 10)', math.log(10**40, 10), 40)
    598. 

  598.         self.ftest('log(10**40, 10**20)', math.log(10**40, 10**20), 2)
    599. 

  599.         self.assertEqual(math.log(INF), INF)
    600. 

  600.         self.assertRaises(ValueError, math.log, NINF)
    601. 

  601.         self.assertTrue(math.isnan(math.log(NAN)))
    602. 

  602. 

  603.     def testLog1p(self):
    604. 

  604.         self.assertRaises(TypeError, math.log1p)
    605. 

  605.         self.ftest('log1p(1/e -1)', math.log1p(1/math.e-1), -1)
    606. 

  606.         self.ftest('log1p(0)', math.log1p(0), 0)
    607. 

  607.         self.ftest('log1p(e-1)', math.log1p(math.e-1), 1)
    608. 

  608.         self.ftest('log1p(1)', math.log1p(1), math.log(2))
    609. 

  609.         self.assertEqual(math.log1p(INF), INF)
    610. 

  610.         self.assertRaises(ValueError, math.log1p, NINF)
    611. 

  611.         self.assertTrue(math.isnan(math.log1p(NAN)))
    612. 

  612.         n= 2**90
    613. 

  613.         self.assertAlmostEqual(math.log1p(n), 62.383246250395075)
    614. 

  614.         self.assertAlmostEqual(math.log1p(n), math.log1p(float(n)))
    615. 

  615. 

  616.     def testLog10(self):
    617. 

  617.         self.assertRaises(TypeError, math.log10)
    618. 

  618.         self.ftest('log10(0.1)', math.log10(0.1), -1)
    619. 

  619.         self.ftest('log10(1)', math.log10(1), 0)
    620. 

  620.         self.ftest('log10(10)', math.log10(10), 1)
    621. 

  621.         self.assertEqual(math.log(INF), INF)
    622. 

  622.         self.assertRaises(ValueError, math.log10, NINF)
    623. 

  623.         self.assertTrue(math.isnan(math.log10(NAN)))
    624. 

  624. 

  625.     def testModf(self):
    626. 

  626.         self.assertRaises(TypeError, math.modf)
    627. 

  627. 

  628.         def testmodf(name, result, expected):
    629. 

  629.             (v1, v2), (e1, e2) = result, expected
    630. 

  630.             if abs(v1-e1) > eps or abs(v2-e2):
    631. 

  631.                 self.fail('%s returned %r, expected %r'%\
    632. 

  632.                           (name, (v1,v2), (e1,e2)))
    633. 

  633. 

  634.         testmodf('modf(1.5)', math.modf(1.5), (0.5, 1.0))
    635. 

  635.         testmodf('modf(-1.5)', math.modf(-1.5), (-0.5, -1.0))
    636. 

  636. 

  637.         self.assertEqual(math.modf(INF), (0.0, INF))
    638. 

  638.         self.assertEqual(math.modf(NINF), (-0.0, NINF))
    639. 

  639. 

  640.         modf_nan = math.modf(NAN)
    641. 

  641.         self.assertTrue(math.isnan(modf_nan[0]))
    642. 

  642.         self.assertTrue(math.isnan(modf_nan[1]))
    643. 

  643. 

  644.     def testPow(self):
    645. 

  645.         self.assertRaises(TypeError, math.pow)
    646. 

  646.         self.ftest('pow(0,1)', math.pow(0,1), 0)
    647. 

  647.         self.ftest('pow(1,0)', math.pow(1,0), 1)
    648. 

  648.         self.ftest('pow(2,1)', math.pow(2,1), 2)
    649. 

  649.         self.ftest('pow(2,-1)', math.pow(2,-1), 0.5)
    650. 

  650.         self.assertEqual(math.pow(INF, 1), INF)
    651. 

  651.         self.assertEqual(math.pow(NINF, 1), NINF)
    652. 

  652.         self.assertEqual((math.pow(1, INF)), 1.)
    653. 

  653.         self.assertEqual((math.pow(1, NINF)), 1.)
    654. 

  654.         self.assertTrue(math.isnan(math.pow(NAN, 1)))
    655. 

  655.         self.assertTrue(math.isnan(math.pow(2, NAN)))
    656. 

  656.         self.assertTrue(math.isnan(math.pow(0, NAN)))
    657. 

  657.         self.assertEqual(math.pow(1, NAN), 1)
    658. 

  658. 

  659.         # pow(0., x)
    660. 

  660.         self.assertEqual(math.pow(0., INF), 0.)
    661. 

  661.         self.assertEqual(math.pow(0., 3.), 0.)
    662. 

  662.         self.assertEqual(math.pow(0., 2.3), 0.)
    663. 

  663.         self.assertEqual(math.pow(0., 2.), 0.)
    664. 

  664.         self.assertEqual(math.pow(0., 0.), 1.)
    665. 

  665.         self.assertEqual(math.pow(0., -0.), 1.)
    666. 

  666.         self.assertRaises(ValueError, math.pow, 0., -2.)
    667. 

  667.         self.assertRaises(ValueError, math.pow, 0., -2.3)
    668. 

  668.         self.assertRaises(ValueError, math.pow, 0., -3.)
    669. 

  669.         self.assertRaises(ValueError, math.pow, 0., NINF)
    670. 

  670.         self.assertTrue(math.isnan(math.pow(0., NAN)))
    671. 

  671. 

  672.         # pow(INF, x)
    673. 

  673.         self.assertEqual(math.pow(INF, INF), INF)
    674. 

  674.         self.assertEqual(math.pow(INF, 3.), INF)
    675. 

  675.         self.assertEqual(math.pow(INF, 2.3), INF)
    676. 

  676.         self.assertEqual(math.pow(INF, 2.), INF)
    677. 

  677.         self.assertEqual(math.pow(INF, 0.), 1.)
    678. 

  678.         self.assertEqual(math.pow(INF, -0.), 1.)
    679. 

  679.         self.assertEqual(math.pow(INF, -2.), 0.)
    680. 

  680.         self.assertEqual(math.pow(INF, -2.3), 0.)
    681. 

  681.         self.assertEqual(math.pow(INF, -3.), 0.)
    682. 

  682.         self.assertEqual(math.pow(INF, NINF), 0.)
    683. 

  683.         self.assertTrue(math.isnan(math.pow(INF, NAN)))
    684. 

  684. 

  685.         # pow(-0., x)
    686. 

  686.         self.assertEqual(math.pow(-0., INF), 0.)
    687. 

  687.         self.assertEqual(math.pow(-0., 3.), -0.)
    688. 

  688.         self.assertEqual(math.pow(-0., 2.3), 0.)
    689. 

  689.         self.assertEqual(math.pow(-0., 2.), 0.)
    690. 

  690.         self.assertEqual(math.pow(-0., 0.), 1.)
    691. 

  691.         self.assertEqual(math.pow(-0., -0.), 1.)
    692. 

  692.         self.assertRaises(ValueError, math.pow, -0., -2.)
    693. 

  693.         self.assertRaises(ValueError, math.pow, -0., -2.3)
    694. 

  694.         self.assertRaises(ValueError, math.pow, -0., -3.)
    695. 

  695.         self.assertRaises(ValueError, math.pow, -0., NINF)
    696. 

  696.         self.assertTrue(math.isnan(math.pow(-0., NAN)))
    697. 

  697. 

  698.         # pow(NINF, x)
    699. 

  699.         self.assertEqual(math.pow(NINF, INF), INF)
    700. 

  700.         self.assertEqual(math.pow(NINF, 3.), NINF)
    701. 

  701.         self.assertEqual(math.pow(NINF, 2.3), INF)
    702. 

  702.         self.assertEqual(math.pow(NINF, 2.), INF)
    703. 

  703.         self.assertEqual(math.pow(NINF, 0.), 1.)
    704. 

  704.         self.assertEqual(math.pow(NINF, -0.), 1.)
    705. 

  705.         self.assertEqual(math.pow(NINF, -2.), 0.)
    706. 

  706.         self.assertEqual(math.pow(NINF, -2.3), 0.)
    707. 

  707.         self.assertEqual(math.pow(NINF, -3.), -0.)
    708. 

  708.         self.assertEqual(math.pow(NINF, NINF), 0.)
    709. 

  709.         self.assertTrue(math.isnan(math.pow(NINF, NAN)))
    710. 

  710. 

  711.         # pow(-1, x)
    712. 

  712.         self.assertEqual(math.pow(-1., INF), 1.)
    713. 

  713.         self.assertEqual(math.pow(-1., 3.), -1.)
    714. 

  714.         self.assertRaises(ValueError, math.pow, -1., 2.3)
    715. 

  715.         self.assertEqual(math.pow(-1., 2.), 1.)
    716. 

  716.         self.assertEqual(math.pow(-1., 0.), 1.)
    717. 

  717.         self.assertEqual(math.pow(-1., -0.), 1.)
    718. 

  718.         self.assertEqual(math.pow(-1., -2.), 1.)
    719. 

  719.         self.assertRaises(ValueError, math.pow, -1., -2.3)
    720. 

  720.         self.assertEqual(math.pow(-1., -3.), -1.)
    721. 

  721.         self.assertEqual(math.pow(-1., NINF), 1.)
    722. 

  722.         self.assertTrue(math.isnan(math.pow(-1., NAN)))
    723. 

  723. 

  724.         # pow(1, x)
    725. 

  725.         self.assertEqual(math.pow(1., INF), 1.)
    726. 

  726.         self.assertEqual(math.pow(1., 3.), 1.)
    727. 

  727.         self.assertEqual(math.pow(1., 2.3), 1.)
    728. 

  728.         self.assertEqual(math.pow(1., 2.), 1.)
    729. 

  729.         self.assertEqual(math.pow(1., 0.), 1.)
    730. 

  730.         self.assertEqual(math.pow(1., -0.), 1.)
    731. 

  731.         self.assertEqual(math.pow(1., -2.), 1.)
    732. 

  732.         self.assertEqual(math.pow(1., -2.3), 1.)
    733. 

  733.         self.assertEqual(math.pow(1., -3.), 1.)
    734. 

  734.         self.assertEqual(math.pow(1., NINF), 1.)
    735. 

  735.         self.assertEqual(math.pow(1., NAN), 1.)
    736. 

  736. 

  737.         # pow(x, 0) should be 1 for any x
    738. 

  738.         self.assertEqual(math.pow(2.3, 0.), 1.)
    739. 

  739.         self.assertEqual(math.pow(-2.3, 0.), 1.)
    740. 

  740.         self.assertEqual(math.pow(NAN, 0.), 1.)
    741. 

  741.         self.assertEqual(math.pow(2.3, -0.), 1.)
    742. 

  742.         self.assertEqual(math.pow(-2.3, -0.), 1.)
    743. 

  743.         self.assertEqual(math.pow(NAN, -0.), 1.)
    744. 

  744. 

  745.         # pow(x, y) is invalid if x is negative and y is not integral
    746. 

  746.         self.assertRaises(ValueError, math.pow, -1., 2.3)
    747. 

  747.         self.assertRaises(ValueError, math.pow, -15., -3.1)
    748. 

  748. 

  749.         # pow(x, NINF)
    750. 

  750.         self.assertEqual(math.pow(1.9, NINF), 0.)
    751. 

  751.         self.assertEqual(math.pow(1.1, NINF), 0.)
    752. 

  752.         self.assertEqual(math.pow(0.9, NINF), INF)
    753. 

  753.         self.assertEqual(math.pow(0.1, NINF), INF)
    754. 

  754.         self.assertEqual(math.pow(-0.1, NINF), INF)
    755. 

  755.         self.assertEqual(math.pow(-0.9, NINF), INF)
    756. 

  756.         self.assertEqual(math.pow(-1.1, NINF), 0.)
    757. 

  757.         self.assertEqual(math.pow(-1.9, NINF), 0.)
    758. 

  758. 

  759.         # pow(x, INF)
    760. 

  760.         self.assertEqual(math.pow(1.9, INF), INF)
    761. 

  761.         self.assertEqual(math.pow(1.1, INF), INF)
    762. 

  762.         self.assertEqual(math.pow(0.9, INF), 0.)
    763. 

  763.         self.assertEqual(math.pow(0.1, INF), 0.)
    764. 

  764.         self.assertEqual(math.pow(-0.1, INF), 0.)
    765. 

  765.         self.assertEqual(math.pow(-0.9, INF), 0.)
    766. 

  766.         self.assertEqual(math.pow(-1.1, INF), INF)
    767. 

  767.         self.assertEqual(math.pow(-1.9, INF), INF)
    768. 

  768. 

  769.         # pow(x, y) should work for x negative, y an integer
    770. 

  770.         self.ftest('(-2.)**3.', math.pow(-2.0, 3.0), -8.0)
    771. 

  771.         self.ftest('(-2.)**2.', math.pow(-2.0, 2.0), 4.0)
    772. 

  772.         self.ftest('(-2.)**1.', math.pow(-2.0, 1.0), -2.0)
    773. 

  773.         self.ftest('(-2.)**0.', math.pow(-2.0, 0.0), 1.0)
    774. 

  774.         self.ftest('(-2.)**-0.', math.pow(-2.0, -0.0), 1.0)
    775. 

  775.         self.ftest('(-2.)**-1.', math.pow(-2.0, -1.0), -0.5)
    776. 

  776.         self.ftest('(-2.)**-2.', math.pow(-2.0, -2.0), 0.25)
    777. 

  777.         self.ftest('(-2.)**-3.', math.pow(-2.0, -3.0), -0.125)
    778. 

  778.         self.assertRaises(ValueError, math.pow, -2.0, -0.5)
    779. 

  779.         self.assertRaises(ValueError, math.pow, -2.0, 0.5)
    780. 

  780. 

  781.         # the following tests have been commented out since they don't
    782. 

  782.         # really belong here:  the implementation of ** for floats is
    783. 

  783.         # independent of the implementation of math.pow
    784. 

  784.         #self.assertEqual(1**NAN, 1)
    785. 

  785.         #self.assertEqual(1**INF, 1)
    786. 

  786.         #self.assertEqual(1**NINF, 1)
    787. 

  787.         #self.assertEqual(1**0, 1)
    788. 

  788.         #self.assertEqual(1.**NAN, 1)
    789. 

  789.         #self.assertEqual(1.**INF, 1)
    790. 

  790.         #self.assertEqual(1.**NINF, 1)
    791. 

  791.         #self.assertEqual(1.**0, 1)
    792. 

  792. 

  793.     def testRadians(self):
    794. 

  794.         self.assertRaises(TypeError, math.radians)
    795. 

  795.         self.ftest('radians(180)', math.radians(180), math.pi)
    796. 

  796.         self.ftest('radians(90)', math.radians(90), math.pi/2)
    797. 

  797.         self.ftest('radians(-45)', math.radians(-45), -math.pi/4)
    798. 

  798. 

  799.     def testSin(self):
    800. 

  800.         self.assertRaises(TypeError, math.sin)
    801. 

  801.         self.ftest('sin(0)', math.sin(0), 0)
    802. 

  802.         self.ftest('sin(pi/2)', math.sin(math.pi/2), 1)
    803. 

  803.         self.ftest('sin(-pi/2)', math.sin(-math.pi/2), -1)
    804. 

  804.         try:
    805. 

  805.             self.assertTrue(math.isnan(math.sin(INF)))
    806. 

  806.             self.assertTrue(math.isnan(math.sin(NINF)))
    807. 

  807.         except ValueError:
    808. 

  808.             self.assertRaises(ValueError, math.sin, INF)
    809. 

  809.             self.assertRaises(ValueError, math.sin, NINF)
    810. 

  810.         self.assertTrue(math.isnan(math.sin(NAN)))
    811. 

  811. 

  812.     def testSinh(self):
    813. 

  813.         self.assertRaises(TypeError, math.sinh)
    814. 

  814.         self.ftest('sinh(0)', math.sinh(0), 0)
    815. 

  815.         self.ftest('sinh(1)**2-cosh(1)**2', math.sinh(1)**2-math.cosh(1)**2, -1)
    816. 

  816.         self.ftest('sinh(1)+sinh(-1)', math.sinh(1)+math.sinh(-1), 0)
    817. 

  817.         self.assertEqual(math.sinh(INF), INF)
    818. 

  818.         self.assertEqual(math.sinh(NINF), NINF)
    819. 

  819.         self.assertTrue(math.isnan(math.sinh(NAN)))
    820. 

  820. 

  821.     def testSqrt(self):
    822. 

  822.         self.assertRaises(TypeError, math.sqrt)
    823. 

  823.         self.ftest('sqrt(0)', math.sqrt(0), 0)
    824. 

  824.         self.ftest('sqrt(1)', math.sqrt(1), 1)
    825. 

  825.         self.ftest('sqrt(4)', math.sqrt(4), 2)
    826. 

  826.         self.assertEqual(math.sqrt(INF), INF)
    827. 

  827.         self.assertRaises(ValueError, math.sqrt, NINF)
    828. 

  828.         self.assertTrue(math.isnan(math.sqrt(NAN)))
    829. 

  829. 

  830.     def testTan(self):
    831. 

  831.         self.assertRaises(TypeError, math.tan)
    832. 

  832.         self.ftest('tan(0)', math.tan(0), 0)
    833. 

  833.         self.ftest('tan(pi/4)', math.tan(math.pi/4), 1)
    834. 

  834.         self.ftest('tan(-pi/4)', math.tan(-math.pi/4), -1)
    835. 

  835.         try:
    836. 

  836.             self.assertTrue(math.isnan(math.tan(INF)))
    837. 

  837.             self.assertTrue(math.isnan(math.tan(NINF)))
    838. 

  838.         except:
    839. 

  839.             self.assertRaises(ValueError, math.tan, INF)
    840. 

  840.             self.assertRaises(ValueError, math.tan, NINF)
    841. 

  841.         self.assertTrue(math.isnan(math.tan(NAN)))
    842. 

  842. 

  843.     def testTanh(self):
    844. 

  844.         self.assertRaises(TypeError, math.tanh)
    845. 

  845.         self.ftest('tanh(0)', math.tanh(0), 0)
    846. 

  846.         self.ftest('tanh(1)+tanh(-1)', math.tanh(1)+math.tanh(-1), 0)
    847. 

  847.         self.ftest('tanh(inf)', math.tanh(INF), 1)
    848. 

  848.         self.ftest('tanh(-inf)', math.tanh(NINF), -1)
    849. 

  849.         self.assertTrue(math.isnan(math.tanh(NAN)))
    850. 

  850.         # check that tanh(-0.) == -0. on IEEE 754 systems
    851. 

  851.         if float.__getformat__("double").startswith("IEEE"):
    852. 

  852.             self.assertEqual(math.tanh(-0.), -0.)
    853. 

  853.             self.assertEqual(math.copysign(1., math.tanh(-0.)),
    854. 

  854.                              math.copysign(1., -0.))
    855. 

  855. 

  856.     def test_trunc(self):
    857. 

  857.         self.assertEqual(math.trunc(1), 1)
    858. 

  858.         self.assertEqual(math.trunc(-1), -1)
    859. 

  859.         self.assertEqual(type(math.trunc(1)), int)
    860. 

  860.         self.assertEqual(type(math.trunc(1.5)), int)
    861. 

  861.         self.assertEqual(math.trunc(1.5), 1)
    862. 

  862.         self.assertEqual(math.trunc(-1.5), -1)
    863. 

  863.         self.assertEqual(math.trunc(1.999999), 1)
    864. 

  864.         self.assertEqual(math.trunc(-1.999999), -1)
    865. 

  865.         self.assertEqual(math.trunc(-0.999999), -0)
    866. 

  866.         self.assertEqual(math.trunc(-100.999), -100)
    867. 

  867. 

  868.         class TestTrunc(object):
    869. 

  869.             def __trunc__(self):
    870. 

  870.                 return 23
    871. 

  871. 

  872.         class TestNoTrunc(object):
    873. 

  873.             pass
    874. 

  874. 

  875.         self.assertEqual(math.trunc(TestTrunc()), 23)
    876. 

  876. 

  877.         self.assertRaises(TypeError, math.trunc)
    878. 

  878.         self.assertRaises(TypeError, math.trunc, 1, 2)
    879. 

  879.         self.assertRaises((AttributeError, TypeError), math.trunc,
    880. 

  880.                           TestNoTrunc())
    881. 

  881. 

  882.     def testIsnan(self):
    883. 

  883.         self.assertTrue(math.isnan(float("nan")))
    884. 

  884.         self.assertTrue(math.isnan(float("inf")* 0.))
    885. 

  885.         self.assertFalse(math.isnan(float("inf")))
    886. 

  886.         self.assertFalse(math.isnan(0.))
    887. 

  887.         self.assertFalse(math.isnan(1.))
    888. 

  888. 

  889.     def testIsinf(self):
    890. 

  890.         self.assertTrue(math.isinf(float("inf")))
    891. 

  891.         self.assertTrue(math.isinf(float("-inf")))
    892. 

  892.         self.assertTrue(math.isinf(1E400))
    893. 

  893.         self.assertTrue(math.isinf(-1E400))
    894. 

  894.         self.assertFalse(math.isinf(float("nan")))
    895. 

  895.         self.assertFalse(math.isinf(0.))
    896. 

  896.         self.assertFalse(math.isinf(1.))
    897. 

  897. 

  898.     # RED_FLAG 16-Oct-2000 Tim
    899. 

  899.     # While 2.0 is more consistent about exceptions than previous releases, it
    900. 

  900.     # still fails this part of the test on some platforms.  For now, we only
    901. 

  901.     # *run* test_exceptions() in verbose mode, so that this isn't normally
    902. 

  902.     # tested.
    903. 

  903. 

  904.     if verbose:
    905. 

  905.         def test_exceptions(self):
    906. 

  906.             try:
    907. 

  907.                 x = math.exp(-1000000000)
    908. 

  908.             except:
    909. 

  909.                 # mathmodule.c is failing to weed out underflows from libm, or
    910. 

  910.                 # we've got an fp format with huge dynamic range
    911. 

  911.                 self.fail("underflowing exp() should not have raised "
    912. 

  912.                           "an exception")
    913. 

  913.             if x != 0:
    914. 

  914.                 self.fail("underflowing exp() should have returned 0")
    915. 

  915. 

  916.             # If this fails, probably using a strict IEEE-754 conforming libm, and x
    917. 

  917.             # is +Inf afterwards.  But Python wants overflows detected by default.
    918. 

  918.             try:
    919. 

  919.                 x = math.exp(1000000000)
    920. 

  920.             except OverflowError:
    921. 

  921.                 pass
    922. 

  922.             else:
    923. 

  923.                 self.fail("overflowing exp() didn't trigger OverflowError")
    924. 

  924. 

  925.             # If this fails, it could be a puzzle.  One odd possibility is that
    926. 

  926.             # mathmodule.c's macros are getting confused while comparing
    927. 

  927.             # Inf (HUGE_VAL) to a NaN, and artificially setting errno to ERANGE
    928. 

  928.             # as a result (and so raising OverflowError instead).
    929. 

  929.             try:
    930. 

  930.                 x = math.sqrt(-1.0)
    931. 

  931.             except ValueError:
    932. 

  932.                 pass
    933. 

  933.             else:
    934. 

  934.                 self.fail("sqrt(-1) didn't raise ValueError")
    935. 

  935. 

  936.     @requires_IEEE_754
    937. 

  937.     def test_testfile(self):
    938. 

  938.         for id, fn, ar, ai, er, ei, flags in parse_testfile(test_file):
    939. 

  939.             # Skip if either the input or result is complex, or if
    940. 

  940.             # flags is nonempty
    941. 

  941.             if ai != 0. or ei != 0. or flags:
    942. 

  942.                 continue
    943. 

  943.             if fn in ['rect', 'polar']:
    944. 

  944.                 # no real versions of rect, polar
    945. 

  945.                 continue
    946. 

  946.             func = getattr(math, fn)
    947. 

  947.             try:
    948. 

  948.                 result = func(ar)
    949. 

  949.             except ValueError:
    950. 

  950.                 message = ("Unexpected ValueError in " +
    951. 

  951.                            "test %s:%s(%r)\n" % (id, fn, ar))
    952. 

  952.                 self.fail(message)
    953. 

  953.             except OverflowError:
    954. 

  954.                 message = ("Unexpected OverflowError in " +
    955. 

  955.                            "test %s:%s(%r)\n" % (id, fn, ar))
    956. 

  956.                 self.fail(message)
    957. 

  957.             self.ftest("%s:%s(%r)" % (id, fn, ar), result, er)
    958. 

  958. 

  959.     @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
    960. 

  960.                          "test requires IEEE 754 doubles")
    961. 

  961.     def test_mtestfile(self):
    962. 

  962.         ALLOWED_ERROR = 20  # permitted error, in ulps
    963. 

  963.         fail_fmt = "{}:{}({!r}): expected {!r}, got {!r}"
    964. 

  964. 

  965.         failures = []
    966. 

  966.         for id, fn, arg, expected, flags in parse_mtestfile(math_testcases):
    967. 

  967.             func = getattr(math, fn)
    968. 

  968. 

  969.             if 'invalid' in flags or 'divide-by-zero' in flags:
    970. 

  970.                 expected = 'ValueError'
    971. 

  971.             elif 'overflow' in flags:
    972. 

  972.                 expected = 'OverflowError'
    973. 

  973. 

  974.             try:
    975. 

  975.                 got = func(arg)
    976. 

  976.             except ValueError:
    977. 

  977.                 got = 'ValueError'
    978. 

  978.             except OverflowError:
    979. 

  979.                 got = 'OverflowError'
    980. 

  980. 

  981.             accuracy_failure = None
    982. 

  982.             if isinstance(got, float) and isinstance(expected, float):
    983. 

  983.                 if math.isnan(expected) and math.isnan(got):
    984. 

  984.                     continue
    985. 

  985.                 if not math.isnan(expected) and not math.isnan(got):
    986. 

  986.                     if fn == 'lgamma':
    987. 

  987.                         # we use a weaker accuracy test for lgamma;
    988. 

  988.                         # lgamma only achieves an absolute error of
    989. 

  989.                         # a few multiples of the machine accuracy, in
    990. 

  990.                         # general.
    991. 

  991.                         accuracy_failure = acc_check(expected, got,
    992. 

  992.                                                   rel_err = 5e-15,
    993. 

  993.                                                   abs_err = 5e-15)
    994. 

  994.                     elif fn == 'erfc':
    995. 

  995.                         # erfc has less-than-ideal accuracy for large
    996. 

  996.                         # arguments (x ~ 25 or so), mainly due to the
    997. 

  997.                         # error involved in computing exp(-x*x).
    998. 

  998.                         #
    999. 

  999.                         # XXX Would be better to weaken this test only
    1000. 

  1000.                         # for large x, instead of for all x.
    1001. 

  1001.                         accuracy_failure = ulps_check(expected, got, 2000)
    1002. 

  1002. 

  1003.                     else:
    1004. 

  1004.                         accuracy_failure = ulps_check(expected, got, 20)
    1005. 

  1005.                     if accuracy_failure is None:
    1006. 

  1006.                         continue
    1007. 

  1007. 

  1008.             if isinstance(got, str) and isinstance(expected, str):
    1009. 

  1009.                 if got == expected:
    1010. 

  1010.                     continue
    1011. 

  1011. 

  1012.             fail_msg = fail_fmt.format(id, fn, arg, expected, got)
    1013. 

  1013.             if accuracy_failure is not None:
    1014. 

  1014.                 fail_msg += ' ({})'.format(accuracy_failure)
    1015. 

  1015.             failures.append(fail_msg)
    1016. 

  1016. 

  1017.         if failures:
    1018. 

  1018.             self.fail('Failures in test_mtestfile:\n  ' +
    1019. 

  1019.                       '\n  '.join(failures))
    1020. 

  1020. 

  1021. 

  1022. def test_main():
    1023. 

  1023.     from doctest import DocFileSuite
    1024. 

  1024.     suite = unittest.TestSuite()
    1025. 

  1025.     suite.addTest(unittest.makeSuite(MathTests))
    1026. 

  1026.     suite.addTest(DocFileSuite("ieee754.txt"))
    1027. 

  1027.     run_unittest(suite)
    1028. 

  1028. 

  1029. if __name__ == '__main__':
    1030. 

  1030.     test_main()
    1031. 

  1031.