1
# Python test set -- math module
2
# XXXX Should not do tests around zero only
4
from test.test_support import run_unittest, verbose
16
# locate file with test values
17
if __name__ == '__main__':
21
test_dir = os.path.dirname(file) or os.curdir
22
test_file = os.path.join(test_dir, 'cmath_testcases.txt')
24
def parse_testfile(fname):
25
"""Parse a file with test values
27
Empty lines or lines starting with -- are ignored
28
yields id, fn, arg_real, arg_imag, exp_real, exp_imag
30
with open(fname) as fp:
32
# skip comment lines and blank lines
33
if line.startswith('--') or not line.strip():
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:]
43
float(arg_real), float(arg_imag),
44
float(exp_real), float(exp_imag),
48
class MathTests(unittest.TestCase):
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
56
self.fail('%s returned %r, expected %r' %
57
(name, value, expected))
59
def testConstants(self):
60
self.ftest('pi', math.pi, 3.1415926)
61
self.ftest('e', math.e, 2.7182818)
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)))
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)))
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)))
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)))
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)))
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)))
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)
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)))
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)))
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)))
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)))
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)))
197
class TestCeil(object):
200
class TestNoCeil(object):
202
self.ftest('ceil(TestCeil())', math.ceil(TestCeil()), 42)
203
self.assertRaises(TypeError, math.ceil, TestNoCeil())
206
t.__ceil__ = lambda *args: args
207
self.assertRaises(TypeError, math.ceil, t)
208
self.assertRaises(TypeError, math.ceil, t, 0)
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)
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
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.)
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)
245
self.assert_(math.isnan(math.cos(INF)))
246
self.assert_(math.isnan(math.cos(NINF)))
248
self.assertRaises(ValueError, math.cos, INF)
249
self.assertRaises(ValueError, math.cos, NINF)
250
self.assert_(math.isnan(math.cos(NAN)))
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)))
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)
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)))
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)
281
def testFactorial(self):
284
for i in range(1, int(n)+1):
287
values = range(10) + [50, 100, 500]
288
random.shuffle(values)
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)
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)))
315
class TestFloor(object):
318
class TestNoFloor(object):
320
self.ftest('floor(TestFloor())', math.floor(TestFloor()), 42)
321
self.assertRaises(TypeError, math.floor, TestNoFloor())
324
t.__floor__ = lambda *args: args
325
self.assertRaises(TypeError, math.floor, t)
326
self.assertRaises(TypeError, math.floor, t, 0)
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)
351
self.assertRaises(TypeError, math.frexp)
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)))
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))
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]))
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
376
if not float.__getformat__("double").startswith("IEEE"):
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:
384
# Python version of math.fsum, for comparison. Uses a
385
# different algorithm based on frexp, ldexp and integer
387
from sys import float_info
388
mant_dig = float_info.mant_dig
389
etiny = float_info.min_exp - mant_dig
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/
399
mant, exp = math.frexp(x)
400
mant, exp = int(math.ldexp(mant, mant_dig)), exp - mant_dig
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)
414
tmant = tmant // (2*h) + bool(tmant & h and tmant & 3*h-1)
416
return math.ldexp(tmant, texp)
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)] +
436
float.fromhex('0x1.5555555555555p+970')),
439
for i, (vals, expected) in enumerate(test_values):
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))
446
self.fail("test %d failed: got ValueError, expected %r "
447
"for math.fsum(%.100r)" % (i, expected, vals))
448
self.assertEqual(actual, expected)
450
from random import random, gauss, shuffle
451
for j in xrange(1000):
452
vals = [7, 1e100, -7, -1e100, -9e-20, 8e-20] * 10
454
for i in xrange(200):
455
v = gauss(0, random()) ** 7 - s
461
self.assertEqual(msum(vals), math.fsum(vals))
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)))
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)))
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)))
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)))
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)))
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)))
528
self.assertAlmostEquals(math.log1p(n), 62.383246250395075)
529
self.assertAlmostEquals(math.log1p(n), math.log1p(float(n)))
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)))
541
self.assertRaises(TypeError, math.modf)
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)))
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))
551
self.assertEquals(math.modf(INF), (0.0, INF))
552
self.assertEquals(math.modf(NINF), (-0.0, NINF))
554
modf_nan = math.modf(NAN)
555
self.assert_(math.isnan(modf_nan[0]))
556
self.assert_(math.isnan(modf_nan[1]))
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)
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)))
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)))
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)))
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)))
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)))
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.)
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.)
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)
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.)
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)
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)
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)
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)
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)
719
self.assert_(math.isnan(math.sin(INF)))
720
self.assert_(math.isnan(math.sin(NINF)))
722
self.assertRaises(ValueError, math.sin, INF)
723
self.assertRaises(ValueError, math.sin, NINF)
724
self.assert_(math.isnan(math.sin(NAN)))
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)))
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)))
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)
750
self.assert_(math.isnan(math.tan(INF)))
751
self.assert_(math.isnan(math.tan(NINF)))
753
self.assertRaises(ValueError, math.tan, INF)
754
self.assertRaises(ValueError, math.tan, NINF)
755
self.assert_(math.isnan(math.tan(NAN)))
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.))
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)
782
class TestTrunc(object):
786
class TestNoTrunc(object):
789
self.assertEqual(math.trunc(TestTrunc()), 23)
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())
797
t.__trunc__ = lambda *args: args
798
self.assertEquals((), math.trunc(t))
799
self.assertRaises(TypeError, math.trunc, t, 0)
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)
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.))
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.))
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
831
def test_exceptions(self):
833
x = math.exp(-1000000000)
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 "
840
self.fail("underflowing exp() should have returned 0")
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.
845
x = math.exp(1000000000)
846
except OverflowError:
849
self.fail("overflowing exp() didn't trigger OverflowError")
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).
860
self.fail("sqrt(-1) didn't raise ValueError")
862
def test_testfile(self):
863
if not float.__getformat__("double").startswith("IEEE"):
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
868
if ai != 0. or ei != 0. or flags:
870
if fn in ['rect', 'polar']:
871
# no real versions of rect, polar
873
func = getattr(math, fn)
877
message = ("Unexpected ValueError in " +
878
"test %s:%s(%r)\n" % (id, fn, ar))
880
except OverflowError:
881
message = ("Unexpected OverflowError in " +
882
"test %s:%s(%r)\n" % (id, fn, ar))
884
self.ftest("%s:%s(%r)" % (id, fn, ar), result, er)
887
from doctest import DocFileSuite
888
suite = unittest.TestSuite()
889
suite.addTest(unittest.makeSuite(MathTests))
890
suite.addTest(DocFileSuite("ieee754.txt"))
893
if __name__ == '__main__':