/Lib/test/test_math.py
Python | 894 lines | 716 code | 91 blank | 87 comment | 53 complexity | ae6ab4ed74f11a85c9805a612cbd17f0 MD5 | raw file
1# Python test set -- math module 2# XXXX Should not do tests around zero only 3 4from test.test_support import run_unittest, verbose 5import unittest 6import math 7import os 8import sys 9import random 10 11eps = 1E-05 12NAN = float('nan') 13INF = float('inf') 14NINF = float('-inf') 15 16# locate file with test values 17if __name__ == '__main__': 18 file = sys.argv[0] 19else: 20 file = __file__ 21test_dir = os.path.dirname(file) or os.curdir 22test_file = os.path.join(test_dir, 'cmath_testcases.txt') 23 24def parse_testfile(fname): 25 """Parse a file with test values 26 27 Empty lines or lines starting with -- are ignored 28 yields id, fn, arg_real, arg_imag, exp_real, exp_imag 29 """ 30 with open(fname) as fp: 31 for line in fp: 32 # skip comment lines and blank lines 33 if line.startswith('--') or not line.strip(): 34 continue 35 36 lhs, rhs = line.split('->') 37 id, fn, arg_real, arg_imag = lhs.split() 38 rhs_pieces = rhs.split() 39 exp_real, exp_imag = rhs_pieces[0], rhs_pieces[1] 40 flags = rhs_pieces[2:] 41 42 yield (id, fn, 43 float(arg_real), float(arg_imag), 44 float(exp_real), float(exp_imag), 45 flags 46 ) 47 48class MathTests(unittest.TestCase): 49 50 def ftest(self, name, value, expected): 51 if abs(value-expected) > eps: 52 # Use %r instead of %f so the error message 53 # displays full precision. Otherwise discrepancies 54 # in the last few bits will lead to very confusing 55 # error messages 56 self.fail('%s returned %r, expected %r' % 57 (name, value, expected)) 58 59 def testConstants(self): 60 self.ftest('pi', math.pi, 3.1415926) 61 self.ftest('e', math.e, 2.7182818) 62 63 def testAcos(self): 64 self.assertRaises(TypeError, math.acos) 65 self.ftest('acos(-1)', math.acos(-1), math.pi) 66 self.ftest('acos(0)', math.acos(0), math.pi/2) 67 self.ftest('acos(1)', math.acos(1), 0) 68 self.assertRaises(ValueError, math.acos, INF) 69 self.assertRaises(ValueError, math.acos, NINF) 70 self.assert_(math.isnan(math.acos(NAN))) 71 72 def testAcosh(self): 73 self.assertRaises(TypeError, math.acosh) 74 self.ftest('acosh(1)', math.acosh(1), 0) 75 self.ftest('acosh(2)', math.acosh(2), 1.3169578969248168) 76 self.assertRaises(ValueError, math.acosh, 0) 77 self.assertRaises(ValueError, math.acosh, -1) 78 self.assertEquals(math.acosh(INF), INF) 79 self.assertRaises(ValueError, math.acosh, NINF) 80 self.assert_(math.isnan(math.acosh(NAN))) 81 82 def testAsin(self): 83 self.assertRaises(TypeError, math.asin) 84 self.ftest('asin(-1)', math.asin(-1), -math.pi/2) 85 self.ftest('asin(0)', math.asin(0), 0) 86 self.ftest('asin(1)', math.asin(1), math.pi/2) 87 self.assertRaises(ValueError, math.asin, INF) 88 self.assertRaises(ValueError, math.asin, NINF) 89 self.assert_(math.isnan(math.asin(NAN))) 90 91 def testAsinh(self): 92 self.assertRaises(TypeError, math.asinh) 93 self.ftest('asinh(0)', math.asinh(0), 0) 94 self.ftest('asinh(1)', math.asinh(1), 0.88137358701954305) 95 self.ftest('asinh(-1)', math.asinh(-1), -0.88137358701954305) 96 self.assertEquals(math.asinh(INF), INF) 97 self.assertEquals(math.asinh(NINF), NINF) 98 self.assert_(math.isnan(math.asinh(NAN))) 99 100 def testAtan(self): 101 self.assertRaises(TypeError, math.atan) 102 self.ftest('atan(-1)', math.atan(-1), -math.pi/4) 103 self.ftest('atan(0)', math.atan(0), 0) 104 self.ftest('atan(1)', math.atan(1), math.pi/4) 105 self.ftest('atan(inf)', math.atan(INF), math.pi/2) 106 self.ftest('atan(-inf)', math.atan(NINF), -math.pi/2) 107 self.assert_(math.isnan(math.atan(NAN))) 108 109 def testAtanh(self): 110 self.assertRaises(TypeError, math.atan) 111 self.ftest('atanh(0)', math.atanh(0), 0) 112 self.ftest('atanh(0.5)', math.atanh(0.5), 0.54930614433405489) 113 self.ftest('atanh(-0.5)', math.atanh(-0.5), -0.54930614433405489) 114 self.assertRaises(ValueError, math.atanh, 1) 115 self.assertRaises(ValueError, math.atanh, -1) 116 self.assertRaises(ValueError, math.atanh, INF) 117 self.assertRaises(ValueError, math.atanh, NINF) 118 self.assert_(math.isnan(math.atanh(NAN))) 119 120 def testAtan2(self): 121 self.assertRaises(TypeError, math.atan2) 122 self.ftest('atan2(-1, 0)', math.atan2(-1, 0), -math.pi/2) 123 self.ftest('atan2(-1, 1)', math.atan2(-1, 1), -math.pi/4) 124 self.ftest('atan2(0, 1)', math.atan2(0, 1), 0) 125 self.ftest('atan2(1, 1)', math.atan2(1, 1), math.pi/4) 126 self.ftest('atan2(1, 0)', math.atan2(1, 0), math.pi/2) 127 128 # math.atan2(0, x) 129 self.ftest('atan2(0., -inf)', math.atan2(0., NINF), math.pi) 130 self.ftest('atan2(0., -2.3)', math.atan2(0., -2.3), math.pi) 131 self.ftest('atan2(0., -0.)', math.atan2(0., -0.), math.pi) 132 self.assertEqual(math.atan2(0., 0.), 0.) 133 self.assertEqual(math.atan2(0., 2.3), 0.) 134 self.assertEqual(math.atan2(0., INF), 0.) 135 self.assert_(math.isnan(math.atan2(0., NAN))) 136 # math.atan2(-0, x) 137 self.ftest('atan2(-0., -inf)', math.atan2(-0., NINF), -math.pi) 138 self.ftest('atan2(-0., -2.3)', math.atan2(-0., -2.3), -math.pi) 139 self.ftest('atan2(-0., -0.)', math.atan2(-0., -0.), -math.pi) 140 self.assertEqual(math.atan2(-0., 0.), -0.) 141 self.assertEqual(math.atan2(-0., 2.3), -0.) 142 self.assertEqual(math.atan2(-0., INF), -0.) 143 self.assert_(math.isnan(math.atan2(-0., NAN))) 144 # math.atan2(INF, x) 145 self.ftest('atan2(inf, -inf)', math.atan2(INF, NINF), math.pi*3/4) 146 self.ftest('atan2(inf, -2.3)', math.atan2(INF, -2.3), math.pi/2) 147 self.ftest('atan2(inf, -0.)', math.atan2(INF, -0.0), math.pi/2) 148 self.ftest('atan2(inf, 0.)', math.atan2(INF, 0.0), math.pi/2) 149 self.ftest('atan2(inf, 2.3)', math.atan2(INF, 2.3), math.pi/2) 150 self.ftest('atan2(inf, inf)', math.atan2(INF, INF), math.pi/4) 151 self.assert_(math.isnan(math.atan2(INF, NAN))) 152 # math.atan2(NINF, x) 153 self.ftest('atan2(-inf, -inf)', math.atan2(NINF, NINF), -math.pi*3/4) 154 self.ftest('atan2(-inf, -2.3)', math.atan2(NINF, -2.3), -math.pi/2) 155 self.ftest('atan2(-inf, -0.)', math.atan2(NINF, -0.0), -math.pi/2) 156 self.ftest('atan2(-inf, 0.)', math.atan2(NINF, 0.0), -math.pi/2) 157 self.ftest('atan2(-inf, 2.3)', math.atan2(NINF, 2.3), -math.pi/2) 158 self.ftest('atan2(-inf, inf)', math.atan2(NINF, INF), -math.pi/4) 159 self.assert_(math.isnan(math.atan2(NINF, NAN))) 160 # math.atan2(+finite, x) 161 self.ftest('atan2(2.3, -inf)', math.atan2(2.3, NINF), math.pi) 162 self.ftest('atan2(2.3, -0.)', math.atan2(2.3, -0.), math.pi/2) 163 self.ftest('atan2(2.3, 0.)', math.atan2(2.3, 0.), math.pi/2) 164 self.assertEqual(math.atan2(2.3, INF), 0.) 165 self.assert_(math.isnan(math.atan2(2.3, NAN))) 166 # math.atan2(-finite, x) 167 self.ftest('atan2(-2.3, -inf)', math.atan2(-2.3, NINF), -math.pi) 168 self.ftest('atan2(-2.3, -0.)', math.atan2(-2.3, -0.), -math.pi/2) 169 self.ftest('atan2(-2.3, 0.)', math.atan2(-2.3, 0.), -math.pi/2) 170 self.assertEqual(math.atan2(-2.3, INF), -0.) 171 self.assert_(math.isnan(math.atan2(-2.3, NAN))) 172 # math.atan2(NAN, x) 173 self.assert_(math.isnan(math.atan2(NAN, NINF))) 174 self.assert_(math.isnan(math.atan2(NAN, -2.3))) 175 self.assert_(math.isnan(math.atan2(NAN, -0.))) 176 self.assert_(math.isnan(math.atan2(NAN, 0.))) 177 self.assert_(math.isnan(math.atan2(NAN, 2.3))) 178 self.assert_(math.isnan(math.atan2(NAN, INF))) 179 self.assert_(math.isnan(math.atan2(NAN, NAN))) 180 181 def testCeil(self): 182 self.assertRaises(TypeError, math.ceil) 183 # These types will be int in py3k. 184 self.assertEquals(float, type(math.ceil(1))) 185 self.assertEquals(float, type(math.ceil(1L))) 186 self.assertEquals(float, type(math.ceil(1.0))) 187 self.ftest('ceil(0.5)', math.ceil(0.5), 1) 188 self.ftest('ceil(1.0)', math.ceil(1.0), 1) 189 self.ftest('ceil(1.5)', math.ceil(1.5), 2) 190 self.ftest('ceil(-0.5)', math.ceil(-0.5), 0) 191 self.ftest('ceil(-1.0)', math.ceil(-1.0), -1) 192 self.ftest('ceil(-1.5)', math.ceil(-1.5), -1) 193 self.assertEquals(math.ceil(INF), INF) 194 self.assertEquals(math.ceil(NINF), NINF) 195 self.assert_(math.isnan(math.ceil(NAN))) 196 197 class TestCeil(object): 198 def __float__(self): 199 return 41.3 200 class TestNoCeil(object): 201 pass 202 self.ftest('ceil(TestCeil())', math.ceil(TestCeil()), 42) 203 self.assertRaises(TypeError, math.ceil, TestNoCeil()) 204 205 t = TestNoCeil() 206 t.__ceil__ = lambda *args: args 207 self.assertRaises(TypeError, math.ceil, t) 208 self.assertRaises(TypeError, math.ceil, t, 0) 209 210 if float.__getformat__("double").startswith("IEEE"): 211 def testCopysign(self): 212 self.assertRaises(TypeError, math.copysign) 213 # copysign should let us distinguish signs of zeros 214 self.assertEquals(copysign(1., 0.), 1.) 215 self.assertEquals(copysign(1., -0.), -1.) 216 self.assertEquals(copysign(INF, 0.), INF) 217 self.assertEquals(copysign(INF, -0.), NINF) 218 self.assertEquals(copysign(NINF, 0.), INF) 219 self.assertEquals(copysign(NINF, -0.), NINF) 220 # and of infinities 221 self.assertEquals(copysign(1., INF), 1.) 222 self.assertEquals(copysign(1., NINF), -1.) 223 self.assertEquals(copysign(INF, INF), INF) 224 self.assertEquals(copysign(INF, NINF), NINF) 225 self.assertEquals(copysign(NINF, INF), INF) 226 self.assertEquals(copysign(NINF, NINF), NINF) 227 self.assert_(math.isnan(copysign(NAN, 1.))) 228 self.assert_(math.isnan(copysign(NAN, INF))) 229 self.assert_(math.isnan(copysign(NAN, NINF))) 230 self.assert_(math.isnan(copysign(NAN, NAN))) 231 # copysign(INF, NAN) may be INF or it may be NINF, since 232 # we don't know whether the sign bit of NAN is set on any 233 # given platform. 234 self.assert_(math.isinf(copysign(INF, NAN))) 235 # similarly, copysign(2., NAN) could be 2. or -2. 236 self.assertEquals(abs(copysign(2., NAN)), 2.) 237 238 def testCos(self): 239 self.assertRaises(TypeError, math.cos) 240 self.ftest('cos(-pi/2)', math.cos(-math.pi/2), 0) 241 self.ftest('cos(0)', math.cos(0), 1) 242 self.ftest('cos(pi/2)', math.cos(math.pi/2), 0) 243 self.ftest('cos(pi)', math.cos(math.pi), -1) 244 try: 245 self.assert_(math.isnan(math.cos(INF))) 246 self.assert_(math.isnan(math.cos(NINF))) 247 except ValueError: 248 self.assertRaises(ValueError, math.cos, INF) 249 self.assertRaises(ValueError, math.cos, NINF) 250 self.assert_(math.isnan(math.cos(NAN))) 251 252 def testCosh(self): 253 self.assertRaises(TypeError, math.cosh) 254 self.ftest('cosh(0)', math.cosh(0), 1) 255 self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert 256 self.assertEquals(math.cosh(INF), INF) 257 self.assertEquals(math.cosh(NINF), INF) 258 self.assert_(math.isnan(math.cosh(NAN))) 259 260 def testDegrees(self): 261 self.assertRaises(TypeError, math.degrees) 262 self.ftest('degrees(pi)', math.degrees(math.pi), 180.0) 263 self.ftest('degrees(pi/2)', math.degrees(math.pi/2), 90.0) 264 self.ftest('degrees(-pi/4)', math.degrees(-math.pi/4), -45.0) 265 266 def testExp(self): 267 self.assertRaises(TypeError, math.exp) 268 self.ftest('exp(-1)', math.exp(-1), 1/math.e) 269 self.ftest('exp(0)', math.exp(0), 1) 270 self.ftest('exp(1)', math.exp(1), math.e) 271 self.assertEquals(math.exp(INF), INF) 272 self.assertEquals(math.exp(NINF), 0.) 273 self.assert_(math.isnan(math.exp(NAN))) 274 275 def testFabs(self): 276 self.assertRaises(TypeError, math.fabs) 277 self.ftest('fabs(-1)', math.fabs(-1), 1) 278 self.ftest('fabs(0)', math.fabs(0), 0) 279 self.ftest('fabs(1)', math.fabs(1), 1) 280 281 def testFactorial(self): 282 def fact(n): 283 result = 1 284 for i in range(1, int(n)+1): 285 result *= i 286 return result 287 values = range(10) + [50, 100, 500] 288 random.shuffle(values) 289 for x in range(10): 290 for cast in (int, long, float): 291 self.assertEqual(math.factorial(cast(x)), fact(x), (x, fact(x), math.factorial(x))) 292 self.assertRaises(ValueError, math.factorial, -1) 293 self.assertRaises(ValueError, math.factorial, math.pi) 294 295 def testFloor(self): 296 self.assertRaises(TypeError, math.floor) 297 # These types will be int in py3k. 298 self.assertEquals(float, type(math.floor(1))) 299 self.assertEquals(float, type(math.floor(1L))) 300 self.assertEquals(float, type(math.floor(1.0))) 301 self.ftest('floor(0.5)', math.floor(0.5), 0) 302 self.ftest('floor(1.0)', math.floor(1.0), 1) 303 self.ftest('floor(1.5)', math.floor(1.5), 1) 304 self.ftest('floor(-0.5)', math.floor(-0.5), -1) 305 self.ftest('floor(-1.0)', math.floor(-1.0), -1) 306 self.ftest('floor(-1.5)', math.floor(-1.5), -2) 307 # pow() relies on floor() to check for integers 308 # This fails on some platforms - so check it here 309 self.ftest('floor(1.23e167)', math.floor(1.23e167), 1.23e167) 310 self.ftest('floor(-1.23e167)', math.floor(-1.23e167), -1.23e167) 311 self.assertEquals(math.ceil(INF), INF) 312 self.assertEquals(math.ceil(NINF), NINF) 313 self.assert_(math.isnan(math.floor(NAN))) 314 315 class TestFloor(object): 316 def __float__(self): 317 return 42.3 318 class TestNoFloor(object): 319 pass 320 self.ftest('floor(TestFloor())', math.floor(TestFloor()), 42) 321 self.assertRaises(TypeError, math.floor, TestNoFloor()) 322 323 t = TestNoFloor() 324 t.__floor__ = lambda *args: args 325 self.assertRaises(TypeError, math.floor, t) 326 self.assertRaises(TypeError, math.floor, t, 0) 327 328 def testFmod(self): 329 self.assertRaises(TypeError, math.fmod) 330 self.ftest('fmod(10,1)', math.fmod(10,1), 0) 331 self.ftest('fmod(10,0.5)', math.fmod(10,0.5), 0) 332 self.ftest('fmod(10,1.5)', math.fmod(10,1.5), 1) 333 self.ftest('fmod(-10,1)', math.fmod(-10,1), 0) 334 self.ftest('fmod(-10,0.5)', math.fmod(-10,0.5), 0) 335 self.ftest('fmod(-10,1.5)', math.fmod(-10,1.5), -1) 336 self.assert_(math.isnan(math.fmod(NAN, 1.))) 337 self.assert_(math.isnan(math.fmod(1., NAN))) 338 self.assert_(math.isnan(math.fmod(NAN, NAN))) 339 self.assertRaises(ValueError, math.fmod, 1., 0.) 340 self.assertRaises(ValueError, math.fmod, INF, 1.) 341 self.assertRaises(ValueError, math.fmod, NINF, 1.) 342 self.assertRaises(ValueError, math.fmod, INF, 0.) 343 self.assertEquals(math.fmod(3.0, INF), 3.0) 344 self.assertEquals(math.fmod(-3.0, INF), -3.0) 345 self.assertEquals(math.fmod(3.0, NINF), 3.0) 346 self.assertEquals(math.fmod(-3.0, NINF), -3.0) 347 self.assertEquals(math.fmod(0.0, 3.0), 0.0) 348 self.assertEquals(math.fmod(0.0, NINF), 0.0) 349 350 def testFrexp(self): 351 self.assertRaises(TypeError, math.frexp) 352 353 def testfrexp(name, (mant, exp), (emant, eexp)): 354 if abs(mant-emant) > eps or exp != eexp: 355 self.fail('%s returned %r, expected %r'%\ 356 (name, (mant, exp), (emant,eexp))) 357 358 testfrexp('frexp(-1)', math.frexp(-1), (-0.5, 1)) 359 testfrexp('frexp(0)', math.frexp(0), (0, 0)) 360 testfrexp('frexp(1)', math.frexp(1), (0.5, 1)) 361 testfrexp('frexp(2)', math.frexp(2), (0.5, 2)) 362 363 self.assertEquals(math.frexp(INF)[0], INF) 364 self.assertEquals(math.frexp(NINF)[0], NINF) 365 self.assert_(math.isnan(math.frexp(NAN)[0])) 366 367 def testFsum(self): 368 # math.fsum relies on exact rounding for correct operation. 369 # There's a known problem with IA32 floating-point that causes 370 # inexact rounding in some situations, and will cause the 371 # math.fsum tests below to fail; see issue #2937. On non IEEE 372 # 754 platforms, and on IEEE 754 platforms that exhibit the 373 # problem described in issue #2937, we simply skip the whole 374 # test. 375 376 if not float.__getformat__("double").startswith("IEEE"): 377 return 378 379 # on IEEE 754 compliant machines, both of the expressions 380 # below should round to 10000000000000002.0. 381 if 1e16+2.0 != 1e16+2.9999: 382 return 383 384 # Python version of math.fsum, for comparison. Uses a 385 # different algorithm based on frexp, ldexp and integer 386 # arithmetic. 387 from sys import float_info 388 mant_dig = float_info.mant_dig 389 etiny = float_info.min_exp - mant_dig 390 391 def msum(iterable): 392 """Full precision summation. Compute sum(iterable) without any 393 intermediate accumulation of error. Based on the 'lsum' function 394 at http://code.activestate.com/recipes/393090/ 395 396 """ 397 tmant, texp = 0, 0 398 for x in iterable: 399 mant, exp = math.frexp(x) 400 mant, exp = int(math.ldexp(mant, mant_dig)), exp - mant_dig 401 if texp > exp: 402 tmant <<= texp-exp 403 texp = exp 404 else: 405 mant <<= exp-texp 406 tmant += mant 407 # Round tmant * 2**texp to a float. The original recipe 408 # used float(str(tmant)) * 2.0**texp for this, but that's 409 # a little unsafe because str -> float conversion can't be 410 # relied upon to do correct rounding on all platforms. 411 tail = max(len(bin(abs(tmant)))-2 - mant_dig, etiny - texp) 412 if tail > 0: 413 h = 1 << (tail-1) 414 tmant = tmant // (2*h) + bool(tmant & h and tmant & 3*h-1) 415 texp += tail 416 return math.ldexp(tmant, texp) 417 418 test_values = [ 419 ([], 0.0), 420 ([0.0], 0.0), 421 ([1e100, 1.0, -1e100, 1e-100, 1e50, -1.0, -1e50], 1e-100), 422 ([2.0**53, -0.5, -2.0**-54], 2.0**53-1.0), 423 ([2.0**53, 1.0, 2.0**-100], 2.0**53+2.0), 424 ([2.0**53+10.0, 1.0, 2.0**-100], 2.0**53+12.0), 425 ([2.0**53-4.0, 0.5, 2.0**-54], 2.0**53-3.0), 426 ([1./n for n in range(1, 1001)], 427 float.fromhex('0x1.df11f45f4e61ap+2')), 428 ([(-1.)**n/n for n in range(1, 1001)], 429 float.fromhex('-0x1.62a2af1bd3624p-1')), 430 ([1.7**(i+1)-1.7**i for i in range(1000)] + [-1.7**1000], -1.0), 431 ([1e16, 1., 1e-16], 10000000000000002.0), 432 ([1e16-2., 1.-2.**-53, -(1e16-2.), -(1.-2.**-53)], 0.0), 433 # exercise code for resizing partials array 434 ([2.**n - 2.**(n+50) + 2.**(n+52) for n in range(-1074, 972, 2)] + 435 [-2.**1022], 436 float.fromhex('0x1.5555555555555p+970')), 437 ] 438 439 for i, (vals, expected) in enumerate(test_values): 440 try: 441 actual = math.fsum(vals) 442 except OverflowError: 443 self.fail("test %d failed: got OverflowError, expected %r " 444 "for math.fsum(%.100r)" % (i, expected, vals)) 445 except ValueError: 446 self.fail("test %d failed: got ValueError, expected %r " 447 "for math.fsum(%.100r)" % (i, expected, vals)) 448 self.assertEqual(actual, expected) 449 450 from random import random, gauss, shuffle 451 for j in xrange(1000): 452 vals = [7, 1e100, -7, -1e100, -9e-20, 8e-20] * 10 453 s = 0 454 for i in xrange(200): 455 v = gauss(0, random()) ** 7 - s 456 s += v 457 vals.append(v) 458 shuffle(vals) 459 460 s = msum(vals) 461 self.assertEqual(msum(vals), math.fsum(vals)) 462 463 def testHypot(self): 464 self.assertRaises(TypeError, math.hypot) 465 self.ftest('hypot(0,0)', math.hypot(0,0), 0) 466 self.ftest('hypot(3,4)', math.hypot(3,4), 5) 467 self.assertEqual(math.hypot(NAN, INF), INF) 468 self.assertEqual(math.hypot(INF, NAN), INF) 469 self.assertEqual(math.hypot(NAN, NINF), INF) 470 self.assertEqual(math.hypot(NINF, NAN), INF) 471 self.assert_(math.isnan(math.hypot(1.0, NAN))) 472 self.assert_(math.isnan(math.hypot(NAN, -2.0))) 473 474 def testLdexp(self): 475 self.assertRaises(TypeError, math.ldexp) 476 self.ftest('ldexp(0,1)', math.ldexp(0,1), 0) 477 self.ftest('ldexp(1,1)', math.ldexp(1,1), 2) 478 self.ftest('ldexp(1,-1)', math.ldexp(1,-1), 0.5) 479 self.ftest('ldexp(-1,1)', math.ldexp(-1,1), -2) 480 self.assertRaises(OverflowError, math.ldexp, 1., 1000000) 481 self.assertRaises(OverflowError, math.ldexp, -1., 1000000) 482 self.assertEquals(math.ldexp(1., -1000000), 0.) 483 self.assertEquals(math.ldexp(-1., -1000000), -0.) 484 self.assertEquals(math.ldexp(INF, 30), INF) 485 self.assertEquals(math.ldexp(NINF, -213), NINF) 486 self.assert_(math.isnan(math.ldexp(NAN, 0))) 487 488 # large second argument 489 for n in [10**5, 10L**5, 10**10, 10L**10, 10**20, 10**40]: 490 self.assertEquals(math.ldexp(INF, -n), INF) 491 self.assertEquals(math.ldexp(NINF, -n), NINF) 492 self.assertEquals(math.ldexp(1., -n), 0.) 493 self.assertEquals(math.ldexp(-1., -n), -0.) 494 self.assertEquals(math.ldexp(0., -n), 0.) 495 self.assertEquals(math.ldexp(-0., -n), -0.) 496 self.assert_(math.isnan(math.ldexp(NAN, -n))) 497 498 self.assertRaises(OverflowError, math.ldexp, 1., n) 499 self.assertRaises(OverflowError, math.ldexp, -1., n) 500 self.assertEquals(math.ldexp(0., n), 0.) 501 self.assertEquals(math.ldexp(-0., n), -0.) 502 self.assertEquals(math.ldexp(INF, n), INF) 503 self.assertEquals(math.ldexp(NINF, n), NINF) 504 self.assert_(math.isnan(math.ldexp(NAN, n))) 505 506 def testLog(self): 507 self.assertRaises(TypeError, math.log) 508 self.ftest('log(1/e)', math.log(1/math.e), -1) 509 self.ftest('log(1)', math.log(1), 0) 510 self.ftest('log(e)', math.log(math.e), 1) 511 self.ftest('log(32,2)', math.log(32,2), 5) 512 self.ftest('log(10**40, 10)', math.log(10**40, 10), 40) 513 self.ftest('log(10**40, 10**20)', math.log(10**40, 10**20), 2) 514 self.assertEquals(math.log(INF), INF) 515 self.assertRaises(ValueError, math.log, NINF) 516 self.assert_(math.isnan(math.log(NAN))) 517 518 def testLog1p(self): 519 self.assertRaises(TypeError, math.log1p) 520 self.ftest('log1p(1/e -1)', math.log1p(1/math.e-1), -1) 521 self.ftest('log1p(0)', math.log1p(0), 0) 522 self.ftest('log1p(e-1)', math.log1p(math.e-1), 1) 523 self.ftest('log1p(1)', math.log1p(1), math.log(2)) 524 self.assertEquals(math.log1p(INF), INF) 525 self.assertRaises(ValueError, math.log1p, NINF) 526 self.assert_(math.isnan(math.log1p(NAN))) 527 n= 2**90 528 self.assertAlmostEquals(math.log1p(n), 62.383246250395075) 529 self.assertAlmostEquals(math.log1p(n), math.log1p(float(n))) 530 531 def testLog10(self): 532 self.assertRaises(TypeError, math.log10) 533 self.ftest('log10(0.1)', math.log10(0.1), -1) 534 self.ftest('log10(1)', math.log10(1), 0) 535 self.ftest('log10(10)', math.log10(10), 1) 536 self.assertEquals(math.log(INF), INF) 537 self.assertRaises(ValueError, math.log10, NINF) 538 self.assert_(math.isnan(math.log10(NAN))) 539 540 def testModf(self): 541 self.assertRaises(TypeError, math.modf) 542 543 def testmodf(name, (v1, v2), (e1, e2)): 544 if abs(v1-e1) > eps or abs(v2-e2): 545 self.fail('%s returned %r, expected %r'%\ 546 (name, (v1,v2), (e1,e2))) 547 548 testmodf('modf(1.5)', math.modf(1.5), (0.5, 1.0)) 549 testmodf('modf(-1.5)', math.modf(-1.5), (-0.5, -1.0)) 550 551 self.assertEquals(math.modf(INF), (0.0, INF)) 552 self.assertEquals(math.modf(NINF), (-0.0, NINF)) 553 554 modf_nan = math.modf(NAN) 555 self.assert_(math.isnan(modf_nan[0])) 556 self.assert_(math.isnan(modf_nan[1])) 557 558 def testPow(self): 559 self.assertRaises(TypeError, math.pow) 560 self.ftest('pow(0,1)', math.pow(0,1), 0) 561 self.ftest('pow(1,0)', math.pow(1,0), 1) 562 self.ftest('pow(2,1)', math.pow(2,1), 2) 563 self.ftest('pow(2,-1)', math.pow(2,-1), 0.5) 564 self.assertEqual(math.pow(INF, 1), INF) 565 self.assertEqual(math.pow(NINF, 1), NINF) 566 self.assertEqual((math.pow(1, INF)), 1.) 567 self.assertEqual((math.pow(1, NINF)), 1.) 568 self.assert_(math.isnan(math.pow(NAN, 1))) 569 self.assert_(math.isnan(math.pow(2, NAN))) 570 self.assert_(math.isnan(math.pow(0, NAN))) 571 self.assertEqual(math.pow(1, NAN), 1) 572 573 # pow(0., x) 574 self.assertEqual(math.pow(0., INF), 0.) 575 self.assertEqual(math.pow(0., 3.), 0.) 576 self.assertEqual(math.pow(0., 2.3), 0.) 577 self.assertEqual(math.pow(0., 2.), 0.) 578 self.assertEqual(math.pow(0., 0.), 1.) 579 self.assertEqual(math.pow(0., -0.), 1.) 580 self.assertRaises(ValueError, math.pow, 0., -2.) 581 self.assertRaises(ValueError, math.pow, 0., -2.3) 582 self.assertRaises(ValueError, math.pow, 0., -3.) 583 self.assertRaises(ValueError, math.pow, 0., NINF) 584 self.assert_(math.isnan(math.pow(0., NAN))) 585 586 # pow(INF, x) 587 self.assertEqual(math.pow(INF, INF), INF) 588 self.assertEqual(math.pow(INF, 3.), INF) 589 self.assertEqual(math.pow(INF, 2.3), INF) 590 self.assertEqual(math.pow(INF, 2.), INF) 591 self.assertEqual(math.pow(INF, 0.), 1.) 592 self.assertEqual(math.pow(INF, -0.), 1.) 593 self.assertEqual(math.pow(INF, -2.), 0.) 594 self.assertEqual(math.pow(INF, -2.3), 0.) 595 self.assertEqual(math.pow(INF, -3.), 0.) 596 self.assertEqual(math.pow(INF, NINF), 0.) 597 self.assert_(math.isnan(math.pow(INF, NAN))) 598 599 # pow(-0., x) 600 self.assertEqual(math.pow(-0., INF), 0.) 601 self.assertEqual(math.pow(-0., 3.), -0.) 602 self.assertEqual(math.pow(-0., 2.3), 0.) 603 self.assertEqual(math.pow(-0., 2.), 0.) 604 self.assertEqual(math.pow(-0., 0.), 1.) 605 self.assertEqual(math.pow(-0., -0.), 1.) 606 self.assertRaises(ValueError, math.pow, -0., -2.) 607 self.assertRaises(ValueError, math.pow, -0., -2.3) 608 self.assertRaises(ValueError, math.pow, -0., -3.) 609 self.assertRaises(ValueError, math.pow, -0., NINF) 610 self.assert_(math.isnan(math.pow(-0., NAN))) 611 612 # pow(NINF, x) 613 self.assertEqual(math.pow(NINF, INF), INF) 614 self.assertEqual(math.pow(NINF, 3.), NINF) 615 self.assertEqual(math.pow(NINF, 2.3), INF) 616 self.assertEqual(math.pow(NINF, 2.), INF) 617 self.assertEqual(math.pow(NINF, 0.), 1.) 618 self.assertEqual(math.pow(NINF, -0.), 1.) 619 self.assertEqual(math.pow(NINF, -2.), 0.) 620 self.assertEqual(math.pow(NINF, -2.3), 0.) 621 self.assertEqual(math.pow(NINF, -3.), -0.) 622 self.assertEqual(math.pow(NINF, NINF), 0.) 623 self.assert_(math.isnan(math.pow(NINF, NAN))) 624 625 # pow(-1, x) 626 self.assertEqual(math.pow(-1., INF), 1.) 627 self.assertEqual(math.pow(-1., 3.), -1.) 628 self.assertRaises(ValueError, math.pow, -1., 2.3) 629 self.assertEqual(math.pow(-1., 2.), 1.) 630 self.assertEqual(math.pow(-1., 0.), 1.) 631 self.assertEqual(math.pow(-1., -0.), 1.) 632 self.assertEqual(math.pow(-1., -2.), 1.) 633 self.assertRaises(ValueError, math.pow, -1., -2.3) 634 self.assertEqual(math.pow(-1., -3.), -1.) 635 self.assertEqual(math.pow(-1., NINF), 1.) 636 self.assert_(math.isnan(math.pow(-1., NAN))) 637 638 # pow(1, x) 639 self.assertEqual(math.pow(1., INF), 1.) 640 self.assertEqual(math.pow(1., 3.), 1.) 641 self.assertEqual(math.pow(1., 2.3), 1.) 642 self.assertEqual(math.pow(1., 2.), 1.) 643 self.assertEqual(math.pow(1., 0.), 1.) 644 self.assertEqual(math.pow(1., -0.), 1.) 645 self.assertEqual(math.pow(1., -2.), 1.) 646 self.assertEqual(math.pow(1., -2.3), 1.) 647 self.assertEqual(math.pow(1., -3.), 1.) 648 self.assertEqual(math.pow(1., NINF), 1.) 649 self.assertEqual(math.pow(1., NAN), 1.) 650 651 # pow(x, 0) should be 1 for any x 652 self.assertEqual(math.pow(2.3, 0.), 1.) 653 self.assertEqual(math.pow(-2.3, 0.), 1.) 654 self.assertEqual(math.pow(NAN, 0.), 1.) 655 self.assertEqual(math.pow(2.3, -0.), 1.) 656 self.assertEqual(math.pow(-2.3, -0.), 1.) 657 self.assertEqual(math.pow(NAN, -0.), 1.) 658 659 # pow(x, y) is invalid if x is negative and y is not integral 660 self.assertRaises(ValueError, math.pow, -1., 2.3) 661 self.assertRaises(ValueError, math.pow, -15., -3.1) 662 663 # pow(x, NINF) 664 self.assertEqual(math.pow(1.9, NINF), 0.) 665 self.assertEqual(math.pow(1.1, NINF), 0.) 666 self.assertEqual(math.pow(0.9, NINF), INF) 667 self.assertEqual(math.pow(0.1, NINF), INF) 668 self.assertEqual(math.pow(-0.1, NINF), INF) 669 self.assertEqual(math.pow(-0.9, NINF), INF) 670 self.assertEqual(math.pow(-1.1, NINF), 0.) 671 self.assertEqual(math.pow(-1.9, NINF), 0.) 672 673 # pow(x, INF) 674 self.assertEqual(math.pow(1.9, INF), INF) 675 self.assertEqual(math.pow(1.1, INF), INF) 676 self.assertEqual(math.pow(0.9, INF), 0.) 677 self.assertEqual(math.pow(0.1, INF), 0.) 678 self.assertEqual(math.pow(-0.1, INF), 0.) 679 self.assertEqual(math.pow(-0.9, INF), 0.) 680 self.assertEqual(math.pow(-1.1, INF), INF) 681 self.assertEqual(math.pow(-1.9, INF), INF) 682 683 # pow(x, y) should work for x negative, y an integer 684 self.ftest('(-2.)**3.', math.pow(-2.0, 3.0), -8.0) 685 self.ftest('(-2.)**2.', math.pow(-2.0, 2.0), 4.0) 686 self.ftest('(-2.)**1.', math.pow(-2.0, 1.0), -2.0) 687 self.ftest('(-2.)**0.', math.pow(-2.0, 0.0), 1.0) 688 self.ftest('(-2.)**-0.', math.pow(-2.0, -0.0), 1.0) 689 self.ftest('(-2.)**-1.', math.pow(-2.0, -1.0), -0.5) 690 self.ftest('(-2.)**-2.', math.pow(-2.0, -2.0), 0.25) 691 self.ftest('(-2.)**-3.', math.pow(-2.0, -3.0), -0.125) 692 self.assertRaises(ValueError, math.pow, -2.0, -0.5) 693 self.assertRaises(ValueError, math.pow, -2.0, 0.5) 694 695 # the following tests have been commented out since they don't 696 # really belong here: the implementation of ** for floats is 697 # independent of the implemention of math.pow 698 #self.assertEqual(1**NAN, 1) 699 #self.assertEqual(1**INF, 1) 700 #self.assertEqual(1**NINF, 1) 701 #self.assertEqual(1**0, 1) 702 #self.assertEqual(1.**NAN, 1) 703 #self.assertEqual(1.**INF, 1) 704 #self.assertEqual(1.**NINF, 1) 705 #self.assertEqual(1.**0, 1) 706 707 def testRadians(self): 708 self.assertRaises(TypeError, math.radians) 709 self.ftest('radians(180)', math.radians(180), math.pi) 710 self.ftest('radians(90)', math.radians(90), math.pi/2) 711 self.ftest('radians(-45)', math.radians(-45), -math.pi/4) 712 713 def testSin(self): 714 self.assertRaises(TypeError, math.sin) 715 self.ftest('sin(0)', math.sin(0), 0) 716 self.ftest('sin(pi/2)', math.sin(math.pi/2), 1) 717 self.ftest('sin(-pi/2)', math.sin(-math.pi/2), -1) 718 try: 719 self.assert_(math.isnan(math.sin(INF))) 720 self.assert_(math.isnan(math.sin(NINF))) 721 except ValueError: 722 self.assertRaises(ValueError, math.sin, INF) 723 self.assertRaises(ValueError, math.sin, NINF) 724 self.assert_(math.isnan(math.sin(NAN))) 725 726 def testSinh(self): 727 self.assertRaises(TypeError, math.sinh) 728 self.ftest('sinh(0)', math.sinh(0), 0) 729 self.ftest('sinh(1)**2-cosh(1)**2', math.sinh(1)**2-math.cosh(1)**2, -1) 730 self.ftest('sinh(1)+sinh(-1)', math.sinh(1)+math.sinh(-1), 0) 731 self.assertEquals(math.sinh(INF), INF) 732 self.assertEquals(math.sinh(NINF), NINF) 733 self.assert_(math.isnan(math.sinh(NAN))) 734 735 def testSqrt(self): 736 self.assertRaises(TypeError, math.sqrt) 737 self.ftest('sqrt(0)', math.sqrt(0), 0) 738 self.ftest('sqrt(1)', math.sqrt(1), 1) 739 self.ftest('sqrt(4)', math.sqrt(4), 2) 740 self.assertEquals(math.sqrt(INF), INF) 741 self.assertRaises(ValueError, math.sqrt, NINF) 742 self.assert_(math.isnan(math.sqrt(NAN))) 743 744 def testTan(self): 745 self.assertRaises(TypeError, math.tan) 746 self.ftest('tan(0)', math.tan(0), 0) 747 self.ftest('tan(pi/4)', math.tan(math.pi/4), 1) 748 self.ftest('tan(-pi/4)', math.tan(-math.pi/4), -1) 749 try: 750 self.assert_(math.isnan(math.tan(INF))) 751 self.assert_(math.isnan(math.tan(NINF))) 752 except: 753 self.assertRaises(ValueError, math.tan, INF) 754 self.assertRaises(ValueError, math.tan, NINF) 755 self.assert_(math.isnan(math.tan(NAN))) 756 757 def testTanh(self): 758 self.assertRaises(TypeError, math.tanh) 759 self.ftest('tanh(0)', math.tanh(0), 0) 760 self.ftest('tanh(1)+tanh(-1)', math.tanh(1)+math.tanh(-1), 0) 761 self.ftest('tanh(inf)', math.tanh(INF), 1) 762 self.ftest('tanh(-inf)', math.tanh(NINF), -1) 763 self.assert_(math.isnan(math.tanh(NAN))) 764 # check that tanh(-0.) == -0. on IEEE 754 systems 765 if float.__getformat__("double").startswith("IEEE"): 766 self.assertEqual(math.tanh(-0.), -0.) 767 self.assertEqual(math.copysign(1., math.tanh(-0.)), 768 math.copysign(1., -0.)) 769 770 def test_trunc(self): 771 self.assertEqual(math.trunc(1), 1) 772 self.assertEqual(math.trunc(-1), -1) 773 self.assertEqual(type(math.trunc(1)), int) 774 self.assertEqual(type(math.trunc(1.5)), int) 775 self.assertEqual(math.trunc(1.5), 1) 776 self.assertEqual(math.trunc(-1.5), -1) 777 self.assertEqual(math.trunc(1.999999), 1) 778 self.assertEqual(math.trunc(-1.999999), -1) 779 self.assertEqual(math.trunc(-0.999999), -0) 780 self.assertEqual(math.trunc(-100.999), -100) 781 782 class TestTrunc(object): 783 def __trunc__(self): 784 return 23 785 786 class TestNoTrunc(object): 787 pass 788 789 self.assertEqual(math.trunc(TestTrunc()), 23) 790 791 self.assertRaises(TypeError, math.trunc) 792 self.assertRaises(TypeError, math.trunc, 1, 2) 793 # XXX: This is not ideal, but see the comment in math_trunc(). 794 self.assertRaises(AttributeError, math.trunc, TestNoTrunc()) 795 796 t = TestNoTrunc() 797 t.__trunc__ = lambda *args: args 798 self.assertEquals((), math.trunc(t)) 799 self.assertRaises(TypeError, math.trunc, t, 0) 800 801 def testCopysign(self): 802 self.assertEqual(math.copysign(1, 42), 1.0) 803 self.assertEqual(math.copysign(0., 42), 0.0) 804 self.assertEqual(math.copysign(1., -42), -1.0) 805 self.assertEqual(math.copysign(3, 0.), 3.0) 806 self.assertEqual(math.copysign(4., -0.), -4.0) 807 808 def testIsnan(self): 809 self.assert_(math.isnan(float("nan"))) 810 self.assert_(math.isnan(float("inf")* 0.)) 811 self.failIf(math.isnan(float("inf"))) 812 self.failIf(math.isnan(0.)) 813 self.failIf(math.isnan(1.)) 814 815 def testIsinf(self): 816 self.assert_(math.isinf(float("inf"))) 817 self.assert_(math.isinf(float("-inf"))) 818 self.assert_(math.isinf(1E400)) 819 self.assert_(math.isinf(-1E400)) 820 self.failIf(math.isinf(float("nan"))) 821 self.failIf(math.isinf(0.)) 822 self.failIf(math.isinf(1.)) 823 824 # RED_FLAG 16-Oct-2000 Tim 825 # While 2.0 is more consistent about exceptions than previous releases, it 826 # still fails this part of the test on some platforms. For now, we only 827 # *run* test_exceptions() in verbose mode, so that this isn't normally 828 # tested. 829 830 if verbose: 831 def test_exceptions(self): 832 try: 833 x = math.exp(-1000000000) 834 except: 835 # mathmodule.c is failing to weed out underflows from libm, or 836 # we've got an fp format with huge dynamic range 837 self.fail("underflowing exp() should not have raised " 838 "an exception") 839 if x != 0: 840 self.fail("underflowing exp() should have returned 0") 841 842 # If this fails, probably using a strict IEEE-754 conforming libm, and x 843 # is +Inf afterwards. But Python wants overflows detected by default. 844 try: 845 x = math.exp(1000000000) 846 except OverflowError: 847 pass 848 else: 849 self.fail("overflowing exp() didn't trigger OverflowError") 850 851 # If this fails, it could be a puzzle. One odd possibility is that 852 # mathmodule.c's macros are getting confused while comparing 853 # Inf (HUGE_VAL) to a NaN, and artificially setting errno to ERANGE 854 # as a result (and so raising OverflowError instead). 855 try: 856 x = math.sqrt(-1.0) 857 except ValueError: 858 pass 859 else: 860 self.fail("sqrt(-1) didn't raise ValueError") 861 862 def test_testfile(self): 863 if not float.__getformat__("double").startswith("IEEE"): 864 return 865 for id, fn, ar, ai, er, ei, flags in parse_testfile(test_file): 866 # Skip if either the input or result is complex, or if 867 # flags is nonempty 868 if ai != 0. or ei != 0. or flags: 869 continue 870 if fn in ['rect', 'polar']: 871 # no real versions of rect, polar 872 continue 873 func = getattr(math, fn) 874 try: 875 result = func(ar) 876 except ValueError: 877 message = ("Unexpected ValueError in " + 878 "test %s:%s(%r)\n" % (id, fn, ar)) 879 self.fail(message) 880 except OverflowError: 881 message = ("Unexpected OverflowError in " + 882 "test %s:%s(%r)\n" % (id, fn, ar)) 883 self.fail(message) 884 self.ftest("%s:%s(%r)" % (id, fn, ar), result, er) 885 886def test_main(): 887 from doctest import DocFileSuite 888 suite = unittest.TestSuite() 889 suite.addTest(unittest.makeSuite(MathTests)) 890 suite.addTest(DocFileSuite("ieee754.txt")) 891 run_unittest(suite) 892 893if __name__ == '__main__': 894 test_main()