OLD | NEW |
(Empty) | |
| 1 # Copyright (c) 2010 Python Software Foundation. All Rights Reserved. |
| 2 # Adapted from Python's Lib/test/test_strtod.py (by Mark Dickinson) |
| 3 |
| 4 # More test cases for deccheck.py. |
| 5 |
| 6 import random |
| 7 |
| 8 TEST_SIZE = 2 |
| 9 |
| 10 |
| 11 def test_short_halfway_cases(): |
| 12 # exact halfway cases with a small number of significant digits |
| 13 for k in 0, 5, 10, 15, 20: |
| 14 # upper = smallest integer >= 2**54/5**k |
| 15 upper = -(-2**54//5**k) |
| 16 # lower = smallest odd number >= 2**53/5**k |
| 17 lower = -(-2**53//5**k) |
| 18 if lower % 2 == 0: |
| 19 lower += 1 |
| 20 for i in range(10 * TEST_SIZE): |
| 21 # Select a random odd n in [2**53/5**k, |
| 22 # 2**54/5**k). Then n * 10**k gives a halfway case |
| 23 # with small number of significant digits. |
| 24 n, e = random.randrange(lower, upper, 2), k |
| 25 |
| 26 # Remove any additional powers of 5. |
| 27 while n % 5 == 0: |
| 28 n, e = n // 5, e + 1 |
| 29 assert n % 10 in (1, 3, 7, 9) |
| 30 |
| 31 # Try numbers of the form n * 2**p2 * 10**e, p2 >= 0, |
| 32 # until n * 2**p2 has more than 20 significant digits. |
| 33 digits, exponent = n, e |
| 34 while digits < 10**20: |
| 35 s = '{}e{}'.format(digits, exponent) |
| 36 yield s |
| 37 # Same again, but with extra trailing zeros. |
| 38 s = '{}e{}'.format(digits * 10**40, exponent - 40) |
| 39 yield s |
| 40 digits *= 2 |
| 41 |
| 42 # Try numbers of the form n * 5**p2 * 10**(e - p5), p5 |
| 43 # >= 0, with n * 5**p5 < 10**20. |
| 44 digits, exponent = n, e |
| 45 while digits < 10**20: |
| 46 s = '{}e{}'.format(digits, exponent) |
| 47 yield s |
| 48 # Same again, but with extra trailing zeros. |
| 49 s = '{}e{}'.format(digits * 10**40, exponent - 40) |
| 50 yield s |
| 51 digits *= 5 |
| 52 exponent -= 1 |
| 53 |
| 54 def test_halfway_cases(): |
| 55 # test halfway cases for the round-half-to-even rule |
| 56 for i in range(1000): |
| 57 for j in range(TEST_SIZE): |
| 58 # bit pattern for a random finite positive (or +0.0) float |
| 59 bits = random.randrange(2047*2**52) |
| 60 |
| 61 # convert bit pattern to a number of the form m * 2**e |
| 62 e, m = divmod(bits, 2**52) |
| 63 if e: |
| 64 m, e = m + 2**52, e - 1 |
| 65 e -= 1074 |
| 66 |
| 67 # add 0.5 ulps |
| 68 m, e = 2*m + 1, e - 1 |
| 69 |
| 70 # convert to a decimal string |
| 71 if e >= 0: |
| 72 digits = m << e |
| 73 exponent = 0 |
| 74 else: |
| 75 # m * 2**e = (m * 5**-e) * 10**e |
| 76 digits = m * 5**-e |
| 77 exponent = e |
| 78 s = '{}e{}'.format(digits, exponent) |
| 79 yield s |
| 80 |
| 81 def test_boundaries(): |
| 82 # boundaries expressed as triples (n, e, u), where |
| 83 # n*10**e is an approximation to the boundary value and |
| 84 # u*10**e is 1ulp |
| 85 boundaries = [ |
| 86 (10000000000000000000, -19, 1110), # a power of 2 boundary (1.0) |
| 87 (17976931348623159077, 289, 1995), # overflow boundary (2.**1024) |
| 88 (22250738585072013831, -327, 4941), # normal/subnormal (2.**-1022) |
| 89 (0, -327, 4941), # zero |
| 90 ] |
| 91 for n, e, u in boundaries: |
| 92 for j in range(1000): |
| 93 for i in range(TEST_SIZE): |
| 94 digits = n + random.randrange(-3*u, 3*u) |
| 95 exponent = e |
| 96 s = '{}e{}'.format(digits, exponent) |
| 97 yield s |
| 98 n *= 10 |
| 99 u *= 10 |
| 100 e -= 1 |
| 101 |
| 102 def test_underflow_boundary(): |
| 103 # test values close to 2**-1075, the underflow boundary; similar |
| 104 # to boundary_tests, except that the random error doesn't scale |
| 105 # with n |
| 106 for exponent in range(-400, -320): |
| 107 base = 10**-exponent // 2**1075 |
| 108 for j in range(TEST_SIZE): |
| 109 digits = base + random.randrange(-1000, 1000) |
| 110 s = '{}e{}'.format(digits, exponent) |
| 111 yield s |
| 112 |
| 113 def test_bigcomp(): |
| 114 for ndigs in 5, 10, 14, 15, 16, 17, 18, 19, 20, 40, 41, 50: |
| 115 dig10 = 10**ndigs |
| 116 for i in range(100 * TEST_SIZE): |
| 117 digits = random.randrange(dig10) |
| 118 exponent = random.randrange(-400, 400) |
| 119 s = '{}e{}'.format(digits, exponent) |
| 120 yield s |
| 121 |
| 122 def test_parsing(): |
| 123 # make '0' more likely to be chosen than other digits |
| 124 digits = '000000123456789' |
| 125 signs = ('+', '-', '') |
| 126 |
| 127 # put together random short valid strings |
| 128 # \d*[.\d*]?e |
| 129 for i in range(1000): |
| 130 for j in range(TEST_SIZE): |
| 131 s = random.choice(signs) |
| 132 intpart_len = random.randrange(5) |
| 133 s += ''.join(random.choice(digits) for _ in range(intpart_len)) |
| 134 if random.choice([True, False]): |
| 135 s += '.' |
| 136 fracpart_len = random.randrange(5) |
| 137 s += ''.join(random.choice(digits) |
| 138 for _ in range(fracpart_len)) |
| 139 else: |
| 140 fracpart_len = 0 |
| 141 if random.choice([True, False]): |
| 142 s += random.choice(['e', 'E']) |
| 143 s += random.choice(signs) |
| 144 exponent_len = random.randrange(1, 4) |
| 145 s += ''.join(random.choice(digits) |
| 146 for _ in range(exponent_len)) |
| 147 |
| 148 if intpart_len + fracpart_len: |
| 149 yield s |
| 150 |
| 151 test_particular = [ |
| 152 # squares |
| 153 '1.00000000100000000025', |
| 154 '1.0000000000000000000000000100000000000000000000000' #... |
| 155 '00025', |
| 156 '1.0000000000000000000000000000000000000000000010000' #... |
| 157 '0000000000000000000000000000000000000000025', |
| 158 '1.0000000000000000000000000000000000000000000000000' #... |
| 159 '000001000000000000000000000000000000000000000000000' #... |
| 160 '000000000025', |
| 161 '0.99999999900000000025', |
| 162 '0.9999999999999999999999999999999999999999999999999' #... |
| 163 '999000000000000000000000000000000000000000000000000' #... |
| 164 '000025', |
| 165 '0.9999999999999999999999999999999999999999999999999' #... |
| 166 '999999999999999999999999999999999999999999999999999' #... |
| 167 '999999999999999999999999999999999999999990000000000' #... |
| 168 '000000000000000000000000000000000000000000000000000' #... |
| 169 '000000000000000000000000000000000000000000000000000' #... |
| 170 '0000000000000000000000000000025', |
| 171 |
| 172 '1.0000000000000000000000000000000000000000000000000' #... |
| 173 '000000000000000000000000000000000000000000000000000' #... |
| 174 '100000000000000000000000000000000000000000000000000' #... |
| 175 '000000000000000000000000000000000000000000000000001', |
| 176 '1.0000000000000000000000000000000000000000000000000' #... |
| 177 '000000000000000000000000000000000000000000000000000' #... |
| 178 '500000000000000000000000000000000000000000000000000' #... |
| 179 '000000000000000000000000000000000000000000000000005', |
| 180 '1.0000000000000000000000000000000000000000000000000' #... |
| 181 '000000000100000000000000000000000000000000000000000' #... |
| 182 '000000000000000000250000000000000002000000000000000' #... |
| 183 '000000000000000000000000000000000000000000010000000' #... |
| 184 '000000000000000000000000000000000000000000000000000' #... |
| 185 '0000000000000000001', |
| 186 '1.0000000000000000000000000000000000000000000000000' #... |
| 187 '000000000100000000000000000000000000000000000000000' #... |
| 188 '000000000000000000249999999999999999999999999999999' #... |
| 189 '999999999999979999999999999999999999999999999999999' #... |
| 190 '999999999999999999999900000000000000000000000000000' #... |
| 191 '000000000000000000000000000000000000000000000000000' #... |
| 192 '00000000000000000000000001', |
| 193 |
| 194 '0.9999999999999999999999999999999999999999999999999' #... |
| 195 '999999999900000000000000000000000000000000000000000' #... |
| 196 '000000000000000000249999999999999998000000000000000' #... |
| 197 '000000000000000000000000000000000000000000010000000' #... |
| 198 '000000000000000000000000000000000000000000000000000' #... |
| 199 '0000000000000000001', |
| 200 '0.9999999999999999999999999999999999999999999999999' #... |
| 201 '999999999900000000000000000000000000000000000000000' #... |
| 202 '000000000000000000250000001999999999999999999999999' #... |
| 203 '999999999999999999999999999999999990000000000000000' #... |
| 204 '000000000000000000000000000000000000000000000000000' #... |
| 205 '1', |
| 206 |
| 207 # tough cases for ln etc. |
| 208 '1.000000000000000000000000000000000000000000000000' #... |
| 209 '00000000000000000000000000000000000000000000000000' #... |
| 210 '00100000000000000000000000000000000000000000000000' #... |
| 211 '00000000000000000000000000000000000000000000000000' #... |
| 212 '0001', |
| 213 '0.999999999999999999999999999999999999999999999999' #... |
| 214 '99999999999999999999999999999999999999999999999999' #... |
| 215 '99899999999999999999999999999999999999999999999999' #... |
| 216 '99999999999999999999999999999999999999999999999999' #... |
| 217 '99999999999999999999999999999999999999999999999999' #... |
| 218 '9999' |
| 219 ] |
| 220 |
| 221 |
| 222 TESTCASES = [ |
| 223 [x for x in test_short_halfway_cases()], |
| 224 [x for x in test_halfway_cases()], |
| 225 [x for x in test_boundaries()], |
| 226 [x for x in test_underflow_boundary()], |
| 227 [x for x in test_bigcomp()], |
| 228 [x for x in test_parsing()], |
| 229 test_particular |
| 230 ] |
| 231 |
| 232 def un_randfloat(): |
| 233 for i in range(1000): |
| 234 l = random.choice(TESTCASES[:6]) |
| 235 yield random.choice(l) |
| 236 for v in test_particular: |
| 237 yield v |
| 238 |
| 239 def bin_randfloat(): |
| 240 for i in range(1000): |
| 241 l1 = random.choice(TESTCASES) |
| 242 l2 = random.choice(TESTCASES) |
| 243 yield random.choice(l1), random.choice(l2) |
| 244 |
| 245 def tern_randfloat(): |
| 246 for i in range(1000): |
| 247 l1 = random.choice(TESTCASES) |
| 248 l2 = random.choice(TESTCASES) |
| 249 l3 = random.choice(TESTCASES) |
| 250 yield random.choice(l1), random.choice(l2), random.choice(l3) |
OLD | NEW |