Lines Matching refs:math
1 # Python test set -- math module
9 import math
56 # Here's a pure Python version of the math.factorial algorithm, for
97 described at http://www.luschny.de/math/factorial/binarysplitfact.html
200 if math.isnan(expected) and math.isnan(got):
203 elif math.isinf(expected) or math.isinf(got):
254 self.ftest('pi', math.pi, 3.141592653589793238462643)
255 self.ftest('e', math.e, 2.718281828459045235360287)
256 self.assertEqual(math.tau, 2*math.pi)
259 self.assertRaises(TypeError, math.acos)
260 self.ftest('acos(-1)', math.acos(-1), math.pi)
261 self.ftest('acos(0)', math.acos(0), math.pi/2)
262 self.ftest('acos(1)', math.acos(1), 0)
263 self.assertRaises(ValueError, math.acos, INF)
264 self.assertRaises(ValueError, math.acos, NINF)
265 self.assertRaises(ValueError, math.acos, 1 + eps)
266 self.assertRaises(ValueError, math.acos, -1 - eps)
267 self.assertTrue(math.isnan(math.acos(NAN)))
270 self.assertRaises(TypeError, math.acosh)
271 self.ftest('acosh(1)', math.acosh(1), 0)
272 self.ftest('acosh(2)', math.acosh(2), 1.3169578969248168)
273 self.assertRaises(ValueError, math.acosh, 0)
274 self.assertRaises(ValueError, math.acosh, -1)
275 self.assertEqual(math.acosh(INF), INF)
276 self.assertRaises(ValueError, math.acosh, NINF)
277 self.assertTrue(math.isnan(math.acosh(NAN)))
280 self.assertRaises(TypeError, math.asin)
281 self.ftest('asin(-1)', math.asin(-1), -math.pi/2)
282 self.ftest('asin(0)', math.asin(0), 0)
283 self.ftest('asin(1)', math.asin(1), math.pi/2)
284 self.assertRaises(ValueError, math.asin, INF)
285 self.assertRaises(ValueError, math.asin, NINF)
286 self.assertRaises(ValueError, math.asin, 1 + eps)
287 self.assertRaises(ValueError, math.asin, -1 - eps)
288 self.assertTrue(math.isnan(math.asin(NAN)))
291 self.assertRaises(TypeError, math.asinh)
292 self.ftest('asinh(0)', math.asinh(0), 0)
293 self.ftest('asinh(1)', math.asinh(1), 0.88137358701954305)
294 self.ftest('asinh(-1)', math.asinh(-1), -0.88137358701954305)
295 self.assertEqual(math.asinh(INF), INF)
296 self.assertEqual(math.asinh(NINF), NINF)
297 self.assertTrue(math.isnan(math.asinh(NAN)))
300 self.assertRaises(TypeError, math.atan)
301 self.ftest('atan(-1)', math.atan(-1), -math.pi/4)
302 self.ftest('atan(0)', math.atan(0), 0)
303 self.ftest('atan(1)', math.atan(1), math.pi/4)
304 self.ftest('atan(inf)', math.atan(INF), math.pi/2)
305 self.ftest('atan(-inf)', math.atan(NINF), -math.pi/2)
306 self.assertTrue(math.isnan(math.atan(NAN)))
309 self.assertRaises(TypeError, math.atan)
310 self.ftest('atanh(0)', math.atanh(0), 0)
311 self.ftest('atanh(0.5)', math.atanh(0.5), 0.54930614433405489)
312 self.ftest('atanh(-0.5)', math.atanh(-0.5), -0.54930614433405489)
313 self.assertRaises(ValueError, math.atanh, 1)
314 self.assertRaises(ValueError, math.atanh, -1)
315 self.assertRaises(ValueError, math.atanh, INF)
316 self.assertRaises(ValueError, math.atanh, NINF)
317 self.assertTrue(math.isnan(math.atanh(NAN)))
320 self.assertRaises(TypeError, math.atan2)
321 self.ftest('atan2(-1, 0)', math.atan2(-1, 0), -math.pi/2)
322 self.ftest('atan2(-1, 1)', math.atan2(-1, 1), -math.pi/4)
323 self.ftest('atan2(0, 1)', math.atan2(0, 1), 0)
324 self.ftest('atan2(1, 1)', math.atan2(1, 1), math.pi/4)
325 self.ftest('atan2(1, 0)', math.atan2(1, 0), math.pi/2)
327 # math.atan2(0, x)
328 self.ftest('atan2(0., -inf)', math.atan2(0., NINF), math.pi)
329 self.ftest('atan2(0., -2.3)', math.atan2(0., -2.3), math.pi)
330 self.ftest('atan2(0., -0.)', math.atan2(0., -0.), math.pi)
331 self.assertEqual(math.atan2(0., 0.), 0.)
332 self.assertEqual(math.atan2(0., 2.3), 0.)
333 self.assertEqual(math.atan2(0., INF), 0.)
334 self.assertTrue(math.isnan(math.atan2(0., NAN)))
335 # math.atan2(-0, x)
336 self.ftest('atan2(-0., -inf)', math.atan2(-0., NINF), -math.pi)
337 self.ftest('atan2(-0., -2.3)', math.atan2(-0., -2.3), -math.pi)
338 self.ftest('atan2(-0., -0.)', math.atan2(-0., -0.), -math.pi)
339 self.assertEqual(math.atan2(-0., 0.), -0.)
340 self.assertEqual(math.atan2(-0., 2.3), -0.)
341 self.assertEqual(math.atan2(-0., INF), -0.)
342 self.assertTrue(math.isnan(math.atan2(-0., NAN)))
343 # math.atan2(INF, x)
344 self.ftest('atan2(inf, -inf)', math.atan2(INF, NINF), math.pi*3/4)
345 self.ftest('atan2(inf, -2.3)', math.atan2(INF, -2.3), math.pi/2)
346 self.ftest('atan2(inf, -0.)', math.atan2(INF, -0.0), math.pi/2)
347 self.ftest('atan2(inf, 0.)', math.atan2(INF, 0.0), math.pi/2)
348 self.ftest('atan2(inf, 2.3)', math.atan2(INF, 2.3), math.pi/2)
349 self.ftest('atan2(inf, inf)', math.atan2(INF, INF), math.pi/4)
350 self.assertTrue(math.isnan(math.atan2(INF, NAN)))
351 # math.atan2(NINF, x)
352 self.ftest('atan2(-inf, -inf)', math.atan2(NINF, NINF), -math.pi*3/4)
353 self.ftest('atan2(-inf, -2.3)', math.atan2(NINF, -2.3), -math.pi/2)
354 self.ftest('atan2(-inf, -0.)', math.atan2(NINF, -0.0), -math.pi/2)
355 self.ftest('atan2(-inf, 0.)', math.atan2(NINF, 0.0), -math.pi/2)
356 self.ftest('atan2(-inf, 2.3)', math.atan2(NINF, 2.3), -math.pi/2)
357 self.ftest('atan2(-inf, inf)', math.atan2(NINF, INF), -math.pi/4)
358 self.assertTrue(math.isnan(math.atan2(NINF, NAN)))
359 # math.atan2(+finite, x)
360 self.ftest('atan2(2.3, -inf)', math.atan2(2.3, NINF), math.pi)
361 self.ftest('atan2(2.3, -0.)', math.atan2(2.3, -0.), math.pi/2)
362 self.ftest('atan2(2.3, 0.)', math.atan2(2.3, 0.), math.pi/2)
363 self.assertEqual(math.atan2(2.3, INF), 0.)
364 self.assertTrue(math.isnan(math.atan2(2.3, NAN)))
365 # math.atan2(-finite, x)
366 self.ftest('atan2(-2.3, -inf)', math.atan2(-2.3, NINF), -math.pi)
367 self.ftest('atan2(-2.3, -0.)', math.atan2(-2.3, -0.), -math.pi/2)
368 self.ftest('atan2(-2.3, 0.)', math.atan2(-2.3, 0.), -math.pi/2)
369 self.assertEqual(math.atan2(-2.3, INF), -0.)
370 self.assertTrue(math.isnan(math.atan2(-2.3, NAN)))
371 # math.atan2(NAN, x)
372 self.assertTrue(math.isnan(math.atan2(NAN, NINF)))
373 self.assertTrue(math.isnan(math.atan2(NAN, -2.3)))
374 self.assertTrue(math.isnan(math.atan2(NAN, -0.)))
375 self.assertTrue(math.isnan(math.atan2(NAN, 0.)))
376 self.assertTrue(math.isnan(math.atan2(NAN, 2.3)))
377 self.assertTrue(math.isnan(math.atan2(NAN, INF)))
378 self.assertTrue(math.isnan(math.atan2(NAN, NAN)))
381 self.assertRaises(TypeError, math.cbrt)
382 self.ftest('cbrt(0)', math.cbrt(0), 0)
383 self.ftest('cbrt(1)', math.cbrt(1), 1)
384 self.ftest('cbrt(8)', math.cbrt(8), 2)
385 self.ftest('cbrt(0.0)', math.cbrt(0.0), 0.0)
386 self.ftest('cbrt(-0.0)', math.cbrt(-0.0), -0.0)
387 self.ftest('cbrt(1.2)', math.cbrt(1.2), 1.062658569182611)
388 self.ftest('cbrt(-2.6)', math.cbrt(-2.6), -1.375068867074141)
389 self.ftest('cbrt(27)', math.cbrt(27), 3)
390 self.ftest('cbrt(-1)', math.cbrt(-1), -1)
391 self.ftest('cbrt(-27)', math.cbrt(-27), -3)
392 self.assertEqual(math.cbrt(INF), INF)
393 self.assertEqual(math.cbrt(NINF), NINF)
394 self.assertTrue(math.isnan(math.cbrt(NAN)))
397 self.assertRaises(TypeError, math.ceil)
398 self.assertEqual(int, type(math.ceil(0.5)))
399 self.assertEqual(math.ceil(0.5), 1)
400 self.assertEqual(math.ceil(1.0), 1)
401 self.assertEqual(math.ceil(1.5), 2)
402 self.assertEqual(math.ceil(-0.5), 0)
403 self.assertEqual(math.ceil(-1.0), -1)
404 self.assertEqual(math.ceil(-1.5), -1)
405 self.assertEqual(math.ceil(0.0), 0)
406 self.assertEqual(math.ceil(-0.0), 0)
407 #self.assertEqual(math.ceil(INF), INF)
408 #self.assertEqual(math.ceil(NINF), NINF)
409 #self.assertTrue(math.isnan(math.ceil(NAN)))
419 self.assertEqual(math.ceil(TestCeil()), 42)
420 self.assertEqual(math.ceil(FloatCeil()), 42)
421 self.assertEqual(math.ceil(FloatLike(42.5)), 43)
422 self.assertRaises(TypeError, math.ceil, TestNoCeil())
426 self.assertRaises(TypeError, math.ceil, t)
427 self.assertRaises(TypeError, math.ceil, t, 0)
431 self.assertEqual(math.copysign(1, 42), 1.0)
432 self.assertEqual(math.copysign(0., 42), 0.0)
433 self.assertEqual(math.copysign(1., -42), -1.0)
434 self.assertEqual(math.copysign(3, 0.), 3.0)
435 self.assertEqual(math.copysign(4., -0.), -4.0)
437 self.assertRaises(TypeError, math.copysign)
439 self.assertEqual(math.copysign(1., 0.), 1.)
440 self.assertEqual(math.copysign(1., -0.), -1.)
441 self.assertEqual(math.copysign(INF, 0.), INF)
442 self.assertEqual(math.copysign(INF, -0.), NINF)
443 self.assertEqual(math.copysign(NINF, 0.), INF)
444 self.assertEqual(math.copysign(NINF, -0.), NINF)
446 self.assertEqual(math.copysign(1., INF), 1.)
447 self.assertEqual(math.copysign(1., NINF), -1.)
448 self.assertEqual(math.copysign(INF, INF), INF)
449 self.assertEqual(math.copysign(INF, NINF), NINF)
450 self.assertEqual(math.copysign(NINF, INF), INF)
451 self.assertEqual(math.copysign(NINF, NINF), NINF)
452 self.assertTrue(math.isnan(math.copysign(NAN, 1.)))
453 self.assertTrue(math.isnan(math.copysign(NAN, INF)))
454 self.assertTrue(math.isnan(math.copysign(NAN, NINF)))
455 self.assertTrue(math.isnan(math.copysign(NAN, NAN)))
459 self.assertTrue(math.isinf(math.copysign(INF, NAN)))
461 self.assertEqual(abs(math.copysign(2., NAN)), 2.)
464 self.assertRaises(TypeError, math.cos)
465 self.ftest('cos(-pi/2)', math.cos(-math.pi/2), 0, abs_tol=math.ulp(1))
466 self.ftest('cos(0)', math.cos(0), 1)
467 self.ftest('cos(pi/2)', math.cos(math.pi/2), 0, abs_tol=math.ulp(1))
468 self.ftest('cos(pi)', math.cos(math.pi), -1)
470 self.assertTrue(math.isnan(math.cos(INF)))
471 self.assertTrue(math.isnan(math.cos(NINF)))
473 self.assertRaises(ValueError, math.cos, INF)
474 self.assertRaises(ValueError, math.cos, NINF)
475 self.assertTrue(math.isnan(math.cos(NAN)))
480 self.assertRaises(TypeError, math.cosh)
481 self.ftest('cosh(0)', math.cosh(0), 1)
482 self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert
483 self.assertEqual(math.cosh(INF), INF)
484 self.assertEqual(math.cosh(NINF), INF)
485 self.assertTrue(math.isnan(math.cosh(NAN)))
488 self.assertRaises(TypeError, math.degrees)
489 self.ftest('degrees(pi)', math.degrees(math.pi), 180.0)
490 self.ftest('degrees(pi/2)', math.degrees(math.pi/2), 90.0)
491 self.ftest('degrees(-pi/4)', math.degrees(-math.pi/4), -45.0)
492 self.ftest('degrees(0)', math.degrees(0), 0)
495 self.assertRaises(TypeError, math.exp)
496 self.ftest('exp(-1)', math.exp(-1), 1/math.e)
497 self.ftest('exp(0)', math.exp(0), 1)
498 self.ftest('exp(1)', math.exp(1), math.e)
499 self.assertEqual(math.exp(INF), INF)
500 self.assertEqual(math.exp(NINF), 0.)
501 self.assertTrue(math.isnan(math.exp(NAN)))
502 self.assertRaises(OverflowError, math.exp, 1000000)
505 self.assertRaises(TypeError, math.exp2)
506 self.ftest('exp2(-1)', math.exp2(-1), 0.5)
507 self.ftest('exp2(0)', math.exp2(0), 1)
508 self.ftest('exp2(1)', math.exp2(1), 2)
509 self.ftest('exp2(2.3)', math.exp2(2.3), 4.924577653379665)
510 self.assertEqual(math.exp2(INF), INF)
511 self.assertEqual(math.exp2(NINF), 0.)
512 self.assertTrue(math.isnan(math.exp2(NAN)))
513 self.assertRaises(OverflowError, math.exp2, 1000000)
516 self.assertRaises(TypeError, math.fabs)
517 self.ftest('fabs(-1)', math.fabs(-1), 1)
518 self.ftest('fabs(0)', math.fabs(0), 0)
519 self.ftest('fabs(1)', math.fabs(1), 1)
522 self.assertEqual(math.factorial(0), 1)
526 self.assertEqual(math.factorial(i), total)
527 self.assertEqual(math.factorial(i), py_factorial(i))
528 self.assertRaises(ValueError, math.factorial, -1)
529 self.assertRaises(ValueError, math.factorial, -10**100)
532 self.assertRaises(TypeError, math.factorial, 5.0)
533 self.assertRaises(TypeError, math.factorial, 5.2)
534 self.assertRaises(TypeError, math.factorial, -1.0)
535 self.assertRaises(TypeError, math.factorial, -1e100)
536 self.assertRaises(TypeError, math.factorial, decimal.Decimal('5'))
537 self.assertRaises(TypeError, math.factorial, decimal.Decimal('5.2'))
538 self.assertRaises(TypeError, math.factorial, "5")
545 self.assertRaises(OverflowError, math.factorial, 10**100)
546 self.assertRaises(TypeError, math.factorial, 1e100)
549 self.assertRaises(TypeError, math.floor)
550 self.assertEqual(int, type(math.floor(0.5)))
551 self.assertEqual(math.floor(0.5), 0)
552 self.assertEqual(math.floor(1.0), 1)
553 self.assertEqual(math.floor(1.5), 1)
554 self.assertEqual(math.floor(-0.5), -1)
555 self.assertEqual(math.floor(-1.0), -1)
556 self.assertEqual(math.floor(-1.5), -2)
557 #self.assertEqual(math.ceil(INF), INF)
558 #self.assertEqual(math.ceil(NINF), NINF)
559 #self.assertTrue(math.isnan(math.floor(NAN)))
569 self.assertEqual(math.floor(TestFloor()), 42)
570 self.assertEqual(math.floor(FloatFloor()), 42)
571 self.assertEqual(math.floor(FloatLike(41.9)), 41)
572 self.assertRaises(TypeError, math.floor, TestNoFloor())
576 self.assertRaises(TypeError, math.floor, t)
577 self.assertRaises(TypeError, math.floor, t, 0)
580 self.assertRaises(TypeError, math.fmod)
581 self.ftest('fmod(10, 1)', math.fmod(10, 1), 0.0)
582 self.ftest('fmod(10, 0.5)', math.fmod(10, 0.5), 0.0)
583 self.ftest('fmod(10, 1.5)', math.fmod(10, 1.5), 1.0)
584 self.ftest('fmod(-10, 1)', math.fmod(-10, 1), -0.0)
585 self.ftest('fmod(-10, 0.5)', math.fmod(-10, 0.5), -0.0)
586 self.ftest('fmod(-10, 1.5)', math.fmod(-10, 1.5), -1.0)
587 self.assertTrue(math.isnan(math.fmod(NAN, 1.)))
588 self.assertTrue(math.isnan(math.fmod(1., NAN)))
589 self.assertTrue(math.isnan(math.fmod(NAN, NAN)))
590 self.assertRaises(ValueError, math.fmod, 1., 0.)
591 self.assertRaises(ValueError, math.fmod, INF, 1.)
592 self.assertRaises(ValueError, math.fmod, NINF, 1.)
593 self.assertRaises(ValueError, math.fmod, INF, 0.)
594 self.assertEqual(math.fmod(3.0, INF), 3.0)
595 self.assertEqual(math.fmod(-3.0, INF), -3.0)
596 self.assertEqual(math.fmod(3.0, NINF), 3.0)
597 self.assertEqual(math.fmod(-3.0, NINF), -3.0)
598 self.assertEqual(math.fmod(0.0, 3.0), 0.0)
599 self.assertEqual(math.fmod(0.0, NINF), 0.0)
602 self.assertRaises(TypeError, math.frexp)
610 testfrexp('frexp(-1)', math.frexp(-1), (-0.5, 1))
611 testfrexp('frexp(0)', math.frexp(0), (0, 0))
612 testfrexp('frexp(1)', math.frexp(1), (0.5, 1))
613 testfrexp('frexp(2)', math.frexp(2), (0.5, 2))
615 self.assertEqual(math.frexp(INF)[0], INF)
616 self.assertEqual(math.frexp(NINF)[0], NINF)
617 self.assertTrue(math.isnan(math.frexp(NAN)[0]))
623 # math.fsum relies on exact rounding for correct operation.
626 # math.fsum tests below to fail; see issue #2937. On non IEEE
631 # Python version of math.fsum, for comparison. Uses a
646 mant, exp = math.frexp(x)
647 mant, exp = int(math.ldexp(mant, mant_dig)), exp - mant_dig
663 return math.ldexp(tmant, texp)
694 actual = math.fsum(vals)
697 "for math.fsum(%.100r)" % (i, expected, vals))
700 "for math.fsum(%.100r)" % (i, expected, vals))
714 self.assertEqual(msum(vals), math.fsum(vals))
717 gcd = math.gcd
762 hypot = math.hypot
766 args = math.e, math.pi, math.sqrt(2.0), math.gamma(3.5), math.sin(2.1)
770 math.sqrt(sum(s**2 for s in args[:i]))
778 self.assertEqual(hypot(bool(1), bool(0), bool(1), bool(1)), math.sqrt(3))
785 math.copysign(1.0, hypot(-0.0)) # Convert negative zero to positive zero
815 self.assertTrue(math.isnan(hypot(NAN)))
816 self.assertTrue(math.isnan(hypot(0, NAN)))
817 self.assertTrue(math.isnan(hypot(NAN, 10)))
818 self.assertTrue(math.isnan(hypot(10, NAN)))
819 self.assertTrue(math.isnan(hypot(NAN, NAN)))
820 self.assertTrue(math.isnan(hypot(NAN)))
825 self.assertTrue(math.isclose(hypot(*([fourthmax]*n)),
826 fourthmax * math.sqrt(n)))
831 self.assertEqual(math.hypot(4*scale, 3*scale), 5*scale)
848 hypot = math.hypot
900 dist = math.dist
901 sqrt = math.sqrt
938 math.copysign(1.0, dist((-0.0,), (0.0,)))
941 math.copysign(1.0, dist((0.0,), (-0.0,)))
986 if any(map(math.isinf, diffs)):
989 elif any(map(math.isnan, diffs)):
991 self.assertTrue(math.isnan(dist(p, q)))
998 self.assertTrue(math.isclose(dist(p, q), fourthmax * math.sqrt(n)))
999 self.assertTrue(math.isclose(dist(q, p), fourthmax * math.sqrt(n)))
1006 self.assertEqual(math.dist(p, q), 5*scale)
1007 self.assertEqual(math.dist(q, p), 5*scale)
1012 math.dist([1, 2], [3, 4, 5])
1025 s = math.isqrt(value)
1032 math.isqrt(-1)
1035 s = math.isqrt(True)
1039 s = math.isqrt(False)
1050 s = math.isqrt(IntegerLike(1729))
1055 math.isqrt(IntegerLike(-3))
1065 math.isqrt(value)
1068 lcm = math.lcm
1112 self.assertRaises(TypeError, math.ldexp)
1113 self.ftest('ldexp(0,1)', math.ldexp(0,1), 0)
1114 self.ftest('ldexp(1,1)', math.ldexp(1,1), 2)
1115 self.ftest('ldexp(1,-1)', math.ldexp(1,-1), 0.5)
1116 self.ftest('ldexp(-1,1)', math.ldexp(-1,1), -2)
1117 self.assertRaises(OverflowError, math.ldexp, 1., 1000000)
1118 self.assertRaises(OverflowError, math.ldexp, -1., 1000000)
1119 self.assertEqual(math.ldexp(1., -1000000), 0.)
1120 self.assertEqual(math.ldexp(-1., -1000000), -0.)
1121 self.assertEqual(math.ldexp(INF, 30), INF)
1122 self.assertEqual(math.ldexp(NINF, -213), NINF)
1123 self.assertTrue(math.isnan(math.ldexp(NAN, 0)))
1127 self.assertEqual(math.ldexp(INF, -n), INF)
1128 self.assertEqual(math.ldexp(NINF, -n), NINF)
1129 self.assertEqual(math.ldexp(1., -n), 0.)
1130 self.assertEqual(math.ldexp(-1., -n), -0.)
1131 self.assertEqual(math.ldexp(0., -n), 0.)
1132 self.assertEqual(math.ldexp(-0., -n), -0.)
1133 self.assertTrue(math.isnan(math.ldexp(NAN, -n)))
1135 self.assertRaises(OverflowError, math.ldexp, 1., n)
1136 self.assertRaises(OverflowError, math.ldexp, -1., n)
1137 self.assertEqual(math.ldexp(0., n), 0.)
1138 self.assertEqual(math.ldexp(-0., n), -0.)
1139 self.assertEqual(math.ldexp(INF, n), INF)
1140 self.assertEqual(math.ldexp(NINF, n), NINF)
1141 self.assertTrue(math.isnan(math.ldexp(NAN, n)))
1144 self.assertRaises(TypeError, math.log)
1145 self.ftest('log(1/e)', math.log(1/math.e), -1)
1146 self.ftest('log(1)', math.log(1), 0)
1147 self.ftest('log(e)', math.log(math.e), 1)
1148 self.ftest('log(32,2)', math.log(32,2), 5)
1149 self.ftest('log(10**40, 10)', math.log(10**40, 10), 40)
1150 self.ftest('log(10**40, 10**20)', math.log(10**40, 10**20), 2)
1151 self.ftest('log(10**1000)', math.log(10**1000),
1153 self.assertRaises(ValueError, math.log, -1.5)
1154 self.assertRaises(ValueError, math.log, -10**1000)
1155 self.assertRaises(ValueError, math.log, NINF)
1156 self.assertEqual(math.log(INF), INF)
1157 self.assertTrue(math.isnan(math.log(NAN)))
1160 self.assertRaises(TypeError, math.log1p)
1162 self.assertAlmostEqual(math.log1p(n), math.log1p(float(n)))
1163 self.assertRaises(ValueError, math.log1p, -1)
1164 self.assertEqual(math.log1p(INF), INF)
1168 self.assertRaises(TypeError, math.log2)
1171 self.assertEqual(math.log2(1), 0.0)
1172 self.assertEqual(math.log2(2), 1.0)
1173 self.assertEqual(math.log2(4), 2.0)
1176 self.assertEqual(math.log2(2**1023), 1023.0)
1177 self.assertEqual(math.log2(2**1024), 1024.0)
1178 self.assertEqual(math.log2(2**2000), 2000.0)
1180 self.assertRaises(ValueError, math.log2, -1.5)
1181 self.assertRaises(ValueError, math.log2, NINF)
1182 self.assertTrue(math.isnan(math.log2(NAN)))
1189 actual = [math.log2(math.ldexp(1.0, n)) for n in range(-1074, 1024)]
1194 self.assertRaises(TypeError, math.log10)
1195 self.ftest('log10(0.1)', math.log10(0.1), -1)
1196 self.ftest('log10(1)', math.log10(1), 0)
1197 self.ftest('log10(10)', math.log10(10), 1)
1198 self.ftest('log10(10**1000)', math.log10(10**1000), 1000.0)
1199 self.assertRaises(ValueError, math.log10, -1.5)
1200 self.assertRaises(ValueError, math.log10, -10**1000)
1201 self.assertRaises(ValueError, math.log10, NINF)
1202 self.assertEqual(math.log(INF), INF)
1203 self.assertTrue(math.isnan(math.log10(NAN)))
1206 self.assertRaises(TypeError, math.modf)
1214 testmodf('modf(1.5)', math.modf(1.5), (0.5, 1.0))
1215 testmodf('modf(-1.5)', math.modf(-1.5), (-0.5, -1.0))
1217 self.assertEqual(math.modf(INF), (0.0, INF))
1218 self.assertEqual(math.modf(NINF), (-0.0, NINF))
1220 modf_nan = math.modf(NAN)
1221 self.assertTrue(math.isnan(modf_nan[0]))
1222 self.assertTrue(math.isnan(modf_nan[1]))
1225 self.assertRaises(TypeError, math.pow)
1226 self.ftest('pow(0,1)', math.pow(0,1), 0)
1227 self.ftest('pow(1,0)', math.pow(1,0), 1)
1228 self.ftest('pow(2,1)', math.pow(2,1), 2)
1229 self.ftest('pow(2,-1)', math.pow(2,-1), 0.5)
1230 self.assertEqual(math.pow(INF, 1), INF)
1231 self.assertEqual(math.pow(NINF, 1), NINF)
1232 self.assertEqual((math.pow(1, INF)), 1.)
1233 self.assertEqual((math.pow(1, NINF)), 1.)
1234 self.assertTrue(math.isnan(math.pow(NAN, 1)))
1235 self.assertTrue(math.isnan(math.pow(2, NAN)))
1236 self.assertTrue(math.isnan(math.pow(0, NAN)))
1237 self.assertEqual(math.pow(1, NAN), 1)
1240 self.assertEqual(math.pow(0., INF), 0.)
1241 self.assertEqual(math.pow(0., 3.), 0.)
1242 self.assertEqual(math.pow(0., 2.3), 0.)
1243 self.assertEqual(math.pow(0., 2.), 0.)
1244 self.assertEqual(math.pow(0., 0.), 1.)
1245 self.assertEqual(math.pow(0., -0.), 1.)
1246 self.assertRaises(ValueError, math.pow, 0., -2.)
1247 self.assertRaises(ValueError, math.pow, 0., -2.3)
1248 self.assertRaises(ValueError, math.pow, 0., -3.)
1249 self.assertEqual(math.pow(0., NINF), INF)
1250 self.assertTrue(math.isnan(math.pow(0., NAN)))
1253 self.assertEqual(math.pow(INF, INF), INF)
1254 self.assertEqual(math.pow(INF, 3.), INF)
1255 self.assertEqual(math.pow(INF, 2.3), INF)
1256 self.assertEqual(math.pow(INF, 2.), INF)
1257 self.assertEqual(math.pow(INF, 0.), 1.)
1258 self.assertEqual(math.pow(INF, -0.), 1.)
1259 self.assertEqual(math.pow(INF, -2.), 0.)
1260 self.assertEqual(math.pow(INF, -2.3), 0.)
1261 self.assertEqual(math.pow(INF, -3.), 0.)
1262 self.assertEqual(math.pow(INF, NINF), 0.)
1263 self.assertTrue(math.isnan(math.pow(INF, NAN)))
1266 self.assertEqual(math.pow(-0., INF), 0.)
1267 self.assertEqual(math.pow(-0., 3.), -0.)
1268 self.assertEqual(math.pow(-0., 2.3), 0.)
1269 self.assertEqual(math.pow(-0., 2.), 0.)
1270 self.assertEqual(math.pow(-0., 0.), 1.)
1271 self.assertEqual(math.pow(-0., -0.), 1.)
1272 self.assertRaises(ValueError, math.pow, -0., -2.)
1273 self.assertRaises(ValueError, math.pow, -0., -2.3)
1274 self.assertRaises(ValueError, math.pow, -0., -3.)
1275 self.assertEqual(math.pow(-0., NINF), INF)
1276 self.assertTrue(math.isnan(math.pow(-0., NAN)))
1279 self.assertEqual(math.pow(NINF, INF), INF)
1280 self.assertEqual(math.pow(NINF, 3.), NINF)
1281 self.assertEqual(math.pow(NINF, 2.3), INF)
1282 self.assertEqual(math.pow(NINF, 2.), INF)
1283 self.assertEqual(math.pow(NINF, 0.), 1.)
1284 self.assertEqual(math.pow(NINF, -0.), 1.)
1285 self.assertEqual(math.pow(NINF, -2.), 0.)
1286 self.assertEqual(math.pow(NINF, -2.3), 0.)
1287 self.assertEqual(math.pow(NINF, -3.), -0.)
1288 self.assertEqual(math.pow(NINF, NINF), 0.)
1289 self.assertTrue(math.isnan(math.pow(NINF, NAN)))
1292 self.assertEqual(math.pow(-1., INF), 1.)
1293 self.assertEqual(math.pow(-1., 3.), -1.)
1294 self.assertRaises(ValueError, math.pow, -1., 2.3)
1295 self.assertEqual(math.pow(-1., 2.), 1.)
1296 self.assertEqual(math.pow(-1., 0.), 1.)
1297 self.assertEqual(math.pow(-1., -0.), 1.)
1298 self.assertEqual(math.pow(-1., -2.), 1.)
1299 self.assertRaises(ValueError, math.pow, -1., -2.3)
1300 self.assertEqual(math.pow(-1., -3.), -1.)
1301 self.assertEqual(math.pow(-1., NINF), 1.)
1302 self.assertTrue(math.isnan(math.pow(-1., NAN)))
1305 self.assertEqual(math.pow(1., INF), 1.)
1306 self.assertEqual(math.pow(1., 3.), 1.)
1307 self.assertEqual(math.pow(1., 2.3), 1.)
1308 self.assertEqual(math.pow(1., 2.), 1.)
1309 self.assertEqual(math.pow(1., 0.), 1.)
1310 self.assertEqual(math.pow(1., -0.), 1.)
1311 self.assertEqual(math.pow(1., -2.), 1.)
1312 self.assertEqual(math.pow(1., -2.3), 1.)
1313 self.assertEqual(math.pow(1., -3.), 1.)
1314 self.assertEqual(math.pow(1., NINF), 1.)
1315 self.assertEqual(math.pow(1., NAN), 1.)
1318 self.assertEqual(math.pow(2.3, 0.), 1.)
1319 self.assertEqual(math.pow(-2.3, 0.), 1.)
1320 self.assertEqual(math.pow(NAN, 0.), 1.)
1321 self.assertEqual(math.pow(2.3, -0.), 1.)
1322 self.assertEqual(math.pow(-2.3, -0.), 1.)
1323 self.assertEqual(math.pow(NAN, -0.), 1.)
1326 self.assertRaises(ValueError, math.pow, -1., 2.3)
1327 self.assertRaises(ValueError, math.pow, -15., -3.1)
1330 self.assertEqual(math.pow(1.9, NINF), 0.)
1331 self.assertEqual(math.pow(1.1, NINF), 0.)
1332 self.assertEqual(math.pow(0.9, NINF), INF)
1333 self.assertEqual(math.pow(0.1, NINF), INF)
1334 self.assertEqual(math.pow(-0.1, NINF), INF)
1335 self.assertEqual(math.pow(-0.9, NINF), INF)
1336 self.assertEqual(math.pow(-1.1, NINF), 0.)
1337 self.assertEqual(math.pow(-1.9, NINF), 0.)
1340 self.assertEqual(math.pow(1.9, INF), INF)
1341 self.assertEqual(math.pow(1.1, INF), INF)
1342 self.assertEqual(math.pow(0.9, INF), 0.)
1343 self.assertEqual(math.pow(0.1, INF), 0.)
1344 self.assertEqual(math.pow(-0.1, INF), 0.)
1345 self.assertEqual(math.pow(-0.9, INF), 0.)
1346 self.assertEqual(math.pow(-1.1, INF), INF)
1347 self.assertEqual(math.pow(-1.9, INF), INF)
1350 self.ftest('(-2.)**3.', math.pow(-2.0, 3.0), -8.0)
1351 self.ftest('(-2.)**2.', math.pow(-2.0, 2.0), 4.0)
1352 self.ftest('(-2.)**1.', math.pow(-2.0, 1.0), -2.0)
1353 self.ftest('(-2.)**0.', math.pow(-2.0, 0.0), 1.0)
1354 self.ftest('(-2.)**-0.', math.pow(-2.0, -0.0), 1.0)
1355 self.ftest('(-2.)**-1.', math.pow(-2.0, -1.0), -0.5)
1356 self.ftest('(-2.)**-2.', math.pow(-2.0, -2.0), 0.25)
1357 self.ftest('(-2.)**-3.', math.pow(-2.0, -3.0), -0.125)
1358 self.assertRaises(ValueError, math.pow, -2.0, -0.5)
1359 self.assertRaises(ValueError, math.pow, -2.0, 0.5)
1363 # independent of the implementation of math.pow
1374 self.assertRaises(TypeError, math.radians)
1375 self.ftest('radians(180)', math.radians(180), math.pi)
1376 self.ftest('radians(90)', math.radians(90), math.pi/2)
1377 self.ftest('radians(-45)', math.radians(-45), -math.pi/4)
1378 self.ftest('radians(0)', math.radians(0), 0)
1466 actual = math.remainder(x, y)
1481 actual = math.remainder(x, y)
1483 actual = math.remainder(-x, y)
1489 self.assertIsNaN(math.remainder(NAN, value))
1490 self.assertIsNaN(math.remainder(value, NAN))
1494 self.assertEqual(math.remainder(value, INF), value)
1495 self.assertEqual(math.remainder(value, NINF), value)
1501 math.remainder(INF, value)
1503 math.remainder(NINF, value)
1505 math.remainder(value, 0.0)
1507 math.remainder(value, -0.0)
1510 self.assertRaises(TypeError, math.sin)
1511 self.ftest('sin(0)', math.sin(0), 0)
1512 self.ftest('sin(pi/2)', math.sin(math.pi/2), 1)
1513 self.ftest('sin(-pi/2)', math.sin(-math.pi/2), -1)
1515 self.assertTrue(math.isnan(math.sin(INF)))
1516 self.assertTrue(math.isnan(math.sin(NINF)))
1518 self.assertRaises(ValueError, math.sin, INF)
1519 self.assertRaises(ValueError, math.sin, NINF)
1520 self.assertTrue(math.isnan(math.sin(NAN)))
1523 self.assertRaises(TypeError, math.sinh)
1524 self.ftest('sinh(0)', math.sinh(0), 0)
1525 self.ftest('sinh(1)**2-cosh(1)**2', math.sinh(1)**2-math.cosh(1)**2, -1)
1526 self.ftest('sinh(1)+sinh(-1)', math.sinh(1)+math.sinh(-1), 0)
1527 self.assertEqual(math.sinh(INF), INF)
1528 self.assertEqual(math.sinh(NINF), NINF)
1529 self.assertTrue(math.isnan(math.sinh(NAN)))
1532 self.assertRaises(TypeError, math.sqrt)
1533 self.ftest('sqrt(0)', math.sqrt(0), 0)
1534 self.ftest('sqrt(0)', math.sqrt(0.0), 0.0)
1535 self.ftest('sqrt(2.5)', math.sqrt(2.5), 1.5811388300841898)
1536 self.ftest('sqrt(0.25)', math.sqrt(0.25), 0.5)
1537 self.ftest('sqrt(25.25)', math.sqrt(25.25), 5.024937810560445)
1538 self.ftest('sqrt(1)', math.sqrt(1), 1)
1539 self.ftest('sqrt(4)', math.sqrt(4), 2)
1540 self.assertEqual(math.sqrt(INF), INF)
1541 self.assertRaises(ValueError, math.sqrt, -1)
1542 self.assertRaises(ValueError, math.sqrt, NINF)
1543 self.assertTrue(math.isnan(math.sqrt(NAN)))
1546 self.assertRaises(TypeError, math.tan)
1547 self.ftest('tan(0)', math.tan(0), 0)
1548 self.ftest('tan(pi/4)', math.tan(math.pi/4), 1)
1549 self.ftest('tan(-pi/4)', math.tan(-math.pi/4), -1)
1551 self.assertTrue(math.isnan(math.tan(INF)))
1552 self.assertTrue(math.isnan(math.tan(NINF)))
1554 self.assertRaises(ValueError, math.tan, INF)
1555 self.assertRaises(ValueError, math.tan, NINF)
1556 self.assertTrue(math.isnan(math.tan(NAN)))
1559 self.assertRaises(TypeError, math.tanh)
1560 self.ftest('tanh(0)', math.tanh(0), 0)
1561 self.ftest('tanh(1)+tanh(-1)', math.tanh(1)+math.tanh(-1), 0,
1562 abs_tol=math.ulp(1))
1563 self.ftest('tanh(inf)', math.tanh(INF), 1)
1564 self.ftest('tanh(-inf)', math.tanh(NINF), -1)
1565 self.assertTrue(math.isnan(math.tanh(NAN)))
1570 self.assertEqual(math.tanh(-0.), -0.)
1571 self.assertEqual(math.copysign(1., math.tanh(-0.)),
1572 math.copysign(1., -0.))
1575 self.assertEqual(math.trunc(1), 1)
1576 self.assertEqual(math.trunc(-1), -1)
1577 self.assertEqual(type(math.trunc(1)), int)
1578 self.assertEqual(type(math.trunc(1.5)), int)
1579 self.assertEqual(math.trunc(1.5), 1)
1580 self.assertEqual(math.trunc(-1.5), -1)
1581 self.assertEqual(math.trunc(1.999999), 1)
1582 self.assertEqual(math.trunc(-1.999999), -1)
1583 self.assertEqual(math.trunc(-0.999999), -0)
1584 self.assertEqual(math.trunc(-100.999), -100)
1595 self.assertEqual(math.trunc(TestTrunc()), 23)
1596 self.assertEqual(math.trunc(FloatTrunc()), 23)
1598 self.assertRaises(TypeError, math.trunc)
1599 self.assertRaises(TypeError, math.trunc, 1, 2)
1600 self.assertRaises(TypeError, math.trunc, FloatLike(23.5))
1601 self.assertRaises(TypeError, math.trunc, TestNoTrunc())
1604 self.assertTrue(math.isfinite(0.0))
1605 self.assertTrue(math.isfinite(-0.0))
1606 self.assertTrue(math.isfinite(1.0))
1607 self.assertTrue(math.isfinite(-1.0))
1608 self.assertFalse(math.isfinite(float("nan")))
1609 self.assertFalse(math.isfinite(float("inf")))
1610 self.assertFalse(math.isfinite(float("-inf")))
1613 self.assertTrue(math.isnan(float("nan")))
1614 self.assertTrue(math.isnan(float("-nan")))
1615 self.assertTrue(math.isnan(float("inf") * 0.))
1616 self.assertFalse(math.isnan(float("inf")))
1617 self.assertFalse(math.isnan(0.))
1618 self.assertFalse(math.isnan(1.))
1621 self.assertTrue(math.isinf(float("inf")))
1622 self.assertTrue(math.isinf(float("-inf")))
1623 self.assertTrue(math.isinf(1E400))
1624 self.assertTrue(math.isinf(-1E400))
1625 self.assertFalse(math.isinf(float("nan")))
1626 self.assertFalse(math.isinf(0.))
1627 self.assertFalse(math.isinf(1.))
1631 self.assertTrue(math.isnan(math.nan))
1635 self.assertTrue(math.isinf(math.inf))
1636 self.assertGreater(math.inf, 0.0)
1637 self.assertEqual(math.inf, float("inf"))
1638 self.assertEqual(-math.inf, float("-inf"))
1648 x = math.exp(-1000000000)
1660 x = math.exp(1000000000)
1671 x = math.sqrt(-1.0)
1706 func = getattr(math, fn)
1740 func = getattr(math, fn)
1802 prod = math.prod
1894 perm = math.perm
1895 factorial = math.factorial
1958 comb = math.comb
1959 factorial = math.factorial
2030 self.assertEqual(math.nextafter(4503599627370496.0, -INF),
2032 self.assertEqual(math.nextafter(4503599627370496.0, INF),
2034 self.assertEqual(math.nextafter(9223372036854775808.0, 0.0),
2036 self.assertEqual(math.nextafter(-9223372036854775808.0, 0.0),
2040 self.assertEqual(math.nextafter(1.0, -INF),
2042 self.assertEqual(math.nextafter(1.0, INF),
2046 self.assertEqual(math.nextafter(2.0, 2.0), 2.0)
2047 self.assertEqualSign(math.nextafter(-0.0, +0.0), +0.0)
2048 self.assertEqualSign(math.nextafter(+0.0, -0.0), -0.0)
2052 self.assertEqual(math.nextafter(+0.0, INF), smallest_subnormal)
2053 self.assertEqual(math.nextafter(-0.0, INF), smallest_subnormal)
2054 self.assertEqual(math.nextafter(+0.0, -INF), -smallest_subnormal)
2055 self.assertEqual(math.nextafter(-0.0, -INF), -smallest_subnormal)
2056 self.assertEqualSign(math.nextafter(smallest_subnormal, +0.0), +0.0)
2057 self.assertEqualSign(math.nextafter(-smallest_subnormal, +0.0), -0.0)
2058 self.assertEqualSign(math.nextafter(smallest_subnormal, -0.0), +0.0)
2059 self.assertEqualSign(math.nextafter(-smallest_subnormal, -0.0), -0.0)
2063 self.assertEqual(math.nextafter(INF, 0.0), largest_normal)
2064 self.assertEqual(math.nextafter(-INF, 0.0), -largest_normal)
2065 self.assertEqual(math.nextafter(largest_normal, INF), INF)
2066 self.assertEqual(math.nextafter(-largest_normal, -INF), -INF)
2069 self.assertIsNaN(math.nextafter(NAN, 1.0))
2070 self.assertIsNaN(math.nextafter(1.0, NAN))
2071 self.assertIsNaN(math.nextafter(NAN, NAN))
2075 self.assertEqual(math.ulp(1.0), sys.float_info.epsilon)
2077 self.assertEqual(math.ulp(2 ** 52), 1.0)
2078 self.assertEqual(math.ulp(2 ** 53), 2.0)
2079 self.assertEqual(math.ulp(2 ** 64), 4096.0)
2082 self.assertEqual(math.ulp(0.0),
2084 self.assertEqual(math.ulp(FLOAT_MAX),
2085 FLOAT_MAX - math.nextafter(FLOAT_MAX, -INF))
2088 self.assertEqual(math.ulp(INF), INF)
2089 self.assertIsNaN(math.ulp(math.nan))
2094 self.assertEqual(math.ulp(-x), math.ulp(x))
2103 for func in math.atan2, math.copysign, math.remainder:
2115 if not math.isnan(value):
2124 self.assertEqual(math.copysign(1.0, x), math.copysign(1.0, y))
2128 isclose = math.isclose # subclasses should override this