| 1 |
import math |
| 2 |
import unittest |
| 3 |
|
| 4 |
class PowTest(unittest.TestCase): |
| 5 |
|
| 6 |
def powtest(self, type): |
| 7 |
if type != float: |
| 8 |
for i in range(-1000, 1000): |
| 9 |
self.assertEqual(pow(type(i), 0), 1) |
| 10 |
self.assertEqual(pow(type(i), 1), type(i)) |
| 11 |
self.assertEqual(pow(type(0), 1), type(0)) |
| 12 |
self.assertEqual(pow(type(1), 1), type(1)) |
| 13 |
|
| 14 |
for i in range(-100, 100): |
| 15 |
self.assertEqual(pow(type(i), 3), i*i*i) |
| 16 |
|
| 17 |
pow2 = 1 |
| 18 |
for i in range(0, 31): |
| 19 |
self.assertEqual(pow(2, i), pow2) |
| 20 |
if i != 30 : pow2 = pow2*2 |
| 21 |
|
| 22 |
for i in list(range(-10, 0)) + list(range(1, 10)): |
| 23 |
ii = type(i) |
| 24 |
inv = pow(ii, -1) # inverse of ii |
| 25 |
for jj in range(-10, 0): |
| 26 |
self.assertAlmostEqual(pow(ii, jj), pow(inv, -jj)) |
| 27 |
|
| 28 |
for othertype in int, float: |
| 29 |
for i in range(1, 100): |
| 30 |
zero = type(0) |
| 31 |
exp = -othertype(i/10.0) |
| 32 |
if exp == 0: |
| 33 |
continue |
| 34 |
self.assertRaises(ZeroDivisionError, pow, zero, exp) |
| 35 |
|
| 36 |
il, ih = -20, 20 |
| 37 |
jl, jh = -5, 5 |
| 38 |
kl, kh = -10, 10 |
| 39 |
asseq = self.assertEqual |
| 40 |
if type == float: |
| 41 |
il = 1 |
| 42 |
asseq = self.assertAlmostEqual |
| 43 |
elif type == int: |
| 44 |
jl = 0 |
| 45 |
elif type == int: |
| 46 |
jl, jh = 0, 15 |
| 47 |
for i in range(il, ih+1): |
| 48 |
for j in range(jl, jh+1): |
| 49 |
for k in range(kl, kh+1): |
| 50 |
if k != 0: |
| 51 |
if type == float or j < 0: |
| 52 |
self.assertRaises(TypeError, pow, type(i), j, k) |
| 53 |
continue |
| 54 |
asseq( |
| 55 |
pow(type(i),j,k), |
| 56 |
pow(type(i),j)% type(k) |
| 57 |
) |
| 58 |
|
| 59 |
def test_powint(self): |
| 60 |
self.powtest(int) |
| 61 |
|
| 62 |
def test_powfloat(self): |
| 63 |
self.powtest(float) |
| 64 |
|
| 65 |
def test_other(self): |
| 66 |
# Other tests-- not very systematic |
| 67 |
self.assertEqual(pow(3,3) % 8, pow(3,3,8)) |
| 68 |
self.assertEqual(pow(3,3) % -8, pow(3,3,-8)) |
| 69 |
self.assertEqual(pow(3,2) % -2, pow(3,2,-2)) |
| 70 |
self.assertEqual(pow(-3,3) % 8, pow(-3,3,8)) |
| 71 |
self.assertEqual(pow(-3,3) % -8, pow(-3,3,-8)) |
| 72 |
self.assertEqual(pow(5,2) % -8, pow(5,2,-8)) |
| 73 |
|
| 74 |
self.assertEqual(pow(3,3) % 8, pow(3,3,8)) |
| 75 |
self.assertEqual(pow(3,3) % -8, pow(3,3,-8)) |
| 76 |
self.assertEqual(pow(3,2) % -2, pow(3,2,-2)) |
| 77 |
self.assertEqual(pow(-3,3) % 8, pow(-3,3,8)) |
| 78 |
self.assertEqual(pow(-3,3) % -8, pow(-3,3,-8)) |
| 79 |
self.assertEqual(pow(5,2) % -8, pow(5,2,-8)) |
| 80 |
|
| 81 |
for i in range(-10, 11): |
| 82 |
for j in range(0, 6): |
| 83 |
for k in range(-7, 11): |
| 84 |
if j >= 0 and k != 0: |
| 85 |
self.assertEqual( |
| 86 |
pow(i,j) % k, |
| 87 |
pow(i,j,k) |
| 88 |
) |
| 89 |
if j >= 0 and k != 0: |
| 90 |
self.assertEqual( |
| 91 |
pow(int(i),j) % k, |
| 92 |
pow(int(i),j,k) |
| 93 |
) |
| 94 |
|
| 95 |
def test_big_exp(self): |
| 96 |
import random |
| 97 |
self.assertEqual(pow(2, 50000), 1 << 50000) |
| 98 |
# Randomized modular tests, checking the identities |
| 99 |
# a**(b1 + b2) == a**b1 * a**b2 |
| 100 |
# a**(b1 * b2) == (a**b1)**b2 |
| 101 |
prime = 1000000000039 # for speed, relatively small prime modulus |
| 102 |
for i in range(10): |
| 103 |
a = random.randrange(1000, 1000000) |
| 104 |
bpower = random.randrange(1000, 50000) |
| 105 |
b = random.randrange(1 << (bpower - 1), 1 << bpower) |
| 106 |
b1 = random.randrange(1, b) |
| 107 |
b2 = b - b1 |
| 108 |
got1 = pow(a, b, prime) |
| 109 |
got2 = pow(a, b1, prime) * pow(a, b2, prime) % prime |
| 110 |
if got1 != got2: |
| 111 |
self.fail(f"{a=:x} {b1=:x} {b2=:x} {got1=:x} {got2=:x}") |
| 112 |
got3 = pow(a, b1 * b2, prime) |
| 113 |
got4 = pow(pow(a, b1, prime), b2, prime) |
| 114 |
if got3 != got4: |
| 115 |
self.fail(f"{a=:x} {b1=:x} {b2=:x} {got3=:x} {got4=:x}") |
| 116 |
|
| 117 |
def test_bug643260(self): |
| 118 |
class TestRpow: |
| 119 |
def __rpow__(self, other): |
| 120 |
return None |
| 121 |
None ** TestRpow() # Won't fail when __rpow__ invoked. SF bug #643260. |
| 122 |
|
| 123 |
def test_bug705231(self): |
| 124 |
# -1.0 raised to an integer should never blow up. It did if the |
| 125 |
# platform pow() was buggy, and Python didn't worm around it. |
| 126 |
eq = self.assertEqual |
| 127 |
a = -1.0 |
| 128 |
# The next two tests can still fail if the platform floor() |
| 129 |
# function doesn't treat all large inputs as integers |
| 130 |
# test_math should also fail if that is happening |
| 131 |
eq(pow(a, 1.23e167), 1.0) |
| 132 |
eq(pow(a, -1.23e167), 1.0) |
| 133 |
for b in range(-10, 11): |
| 134 |
eq(pow(a, float(b)), b & 1 and -1.0 or 1.0) |
| 135 |
for n in range(0, 100): |
| 136 |
fiveto = float(5 ** n) |
| 137 |
# For small n, fiveto will be odd. Eventually we run out of |
| 138 |
# mantissa bits, though, and thereafer fiveto will be even. |
| 139 |
expected = fiveto % 2.0 and -1.0 or 1.0 |
| 140 |
eq(pow(a, fiveto), expected) |
| 141 |
eq(pow(a, -fiveto), expected) |
| 142 |
eq(expected, 1.0) # else we didn't push fiveto to evenness |
| 143 |
|
| 144 |
def test_negative_exponent(self): |
| 145 |
for a in range(-50, 50): |
| 146 |
for m in range(-50, 50): |
| 147 |
with self.subTest(a=a, m=m): |
| 148 |
if m != 0 and math.gcd(a, m) == 1: |
| 149 |
# Exponent -1 should give an inverse, with the |
| 150 |
# same sign as m. |
| 151 |
inv = pow(a, -1, m) |
| 152 |
self.assertEqual(inv, inv % m) |
| 153 |
self.assertEqual((inv * a - 1) % m, 0) |
| 154 |
|
| 155 |
# Larger exponents |
| 156 |
self.assertEqual(pow(a, -2, m), pow(inv, 2, m)) |
| 157 |
self.assertEqual(pow(a, -3, m), pow(inv, 3, m)) |
| 158 |
self.assertEqual(pow(a, -1001, m), pow(inv, 1001, m)) |
| 159 |
|
| 160 |
else: |
| 161 |
with self.assertRaises(ValueError): |
| 162 |
pow(a, -1, m) |
| 163 |
with self.assertRaises(ValueError): |
| 164 |
pow(a, -2, m) |
| 165 |
with self.assertRaises(ValueError): |
| 166 |
pow(a, -1001, m) |
| 167 |
|
| 168 |
|
| 169 |
if __name__ == "__main__": |
| 170 |
unittest.main() |