1# Tests for the correctly-rounded string -> float conversions 2# introduced in Python 2.7 and 3.1. 3 4import random 5import unittest 6import re 7import sys 8import test.support 9 10if getattr(sys, 'float_repr_style', '') != 'short': 11 raise unittest.SkipTest('correctly-rounded string->float conversions ' 12 'not available on this system') 13 14# Correctly rounded str -> float in pure Python, for comparison. 15 16strtod_parser = re.compile(r""" # A numeric string consists of: 17 (?P<sign>[-+])? # an optional sign, followed by 18 (?=\d|\.\d) # a number with at least one digit 19 (?P<int>\d*) # having a (possibly empty) integer part 20 (?:\.(?P<frac>\d*))? # followed by an optional fractional part 21 (?:E(?P<exp>[-+]?\d+))? # and an optional exponent 22 \Z 23""", re.VERBOSE | re.IGNORECASE).match 24 25# Pure Python version of correctly rounded string->float conversion. 26# Avoids any use of floating-point by returning the result as a hex string. 27def strtod(s, mant_dig=53, min_exp = -1021, max_exp = 1024): 28 """Convert a finite decimal string to a hex string representing an 29 IEEE 754 binary64 float. Return 'inf' or '-inf' on overflow. 30 This function makes no use of floating-point arithmetic at any 31 stage.""" 32 33 # parse string into a pair of integers 'a' and 'b' such that 34 # abs(decimal value) = a/b, along with a boolean 'negative'. 35 m = strtod_parser(s) 36 if m is None: 37 raise ValueError('invalid numeric string') 38 fraction = m.group('frac') or '' 39 intpart = int(m.group('int') + fraction) 40 exp = int(m.group('exp') or '0') - len(fraction) 41 negative = m.group('sign') == '-' 42 a, b = intpart*10**max(exp, 0), 10**max(0, -exp) 43 44 # quick return for zeros 45 if not a: 46 return '-0x0.0p+0' if negative else '0x0.0p+0' 47 48 # compute exponent e for result; may be one too small in the case 49 # that the rounded value of a/b lies in a different binade from a/b 50 d = a.bit_length() - b.bit_length() 51 d += (a >> d if d >= 0 else a << -d) >= b 52 e = max(d, min_exp) - mant_dig 53 54 # approximate a/b by number of the form q * 2**e; adjust e if necessary 55 a, b = a << max(-e, 0), b << max(e, 0) 56 q, r = divmod(a, b) 57 if 2*r > b or 2*r == b and q & 1: 58 q += 1 59 if q.bit_length() == mant_dig+1: 60 q //= 2 61 e += 1 62 63 # double check that (q, e) has the right form 64 assert q.bit_length() <= mant_dig and e >= min_exp - mant_dig 65 assert q.bit_length() == mant_dig or e == min_exp - mant_dig 66 67 # check for overflow and underflow 68 if e + q.bit_length() > max_exp: 69 return '-inf' if negative else 'inf' 70 if not q: 71 return '-0x0.0p+0' if negative else '0x0.0p+0' 72 73 # for hex representation, shift so # bits after point is a multiple of 4 74 hexdigs = 1 + (mant_dig-2)//4 75 shift = 3 - (mant_dig-2)%4 76 q, e = q << shift, e - shift 77 return '{}0x{:x}.{:0{}x}p{:+d}'.format( 78 '-' if negative else '', 79 q // 16**hexdigs, 80 q % 16**hexdigs, 81 hexdigs, 82 e + 4*hexdigs) 83 84TEST_SIZE = 10 85 86class StrtodTests(unittest.TestCase): 87 def check_strtod(self, s): 88 """Compare the result of Python's builtin correctly rounded 89 string->float conversion (using float) to a pure Python 90 correctly rounded string->float implementation. Fail if the 91 two methods give different results.""" 92 93 try: 94 fs = float(s) 95 except OverflowError: 96 got = '-inf' if s[0] == '-' else 'inf' 97 except MemoryError: 98 got = 'memory error' 99 else: 100 got = fs.hex() 101 expected = strtod(s) 102 self.assertEqual(expected, got, 103 "Incorrectly rounded str->float conversion for {}: " 104 "expected {}, got {}".format(s, expected, got)) 105 106 def test_short_halfway_cases(self): 107 # exact halfway cases with a small number of significant digits 108 for k in 0, 5, 10, 15, 20: 109 # upper = smallest integer >= 2**54/5**k 110 upper = -(-2**54//5**k) 111 # lower = smallest odd number >= 2**53/5**k 112 lower = -(-2**53//5**k) 113 if lower % 2 == 0: 114 lower += 1 115 for i in range(TEST_SIZE): 116 # Select a random odd n in [2**53/5**k, 117 # 2**54/5**k). Then n * 10**k gives a halfway case 118 # with small number of significant digits. 119 n, e = random.randrange(lower, upper, 2), k 120 121 # Remove any additional powers of 5. 122 while n % 5 == 0: 123 n, e = n // 5, e + 1 124 assert n % 10 in (1, 3, 7, 9) 125 126 # Try numbers of the form n * 2**p2 * 10**e, p2 >= 0, 127 # until n * 2**p2 has more than 20 significant digits. 128 digits, exponent = n, e 129 while digits < 10**20: 130 s = '{}e{}'.format(digits, exponent) 131 self.check_strtod(s) 132 # Same again, but with extra trailing zeros. 133 s = '{}e{}'.format(digits * 10**40, exponent - 40) 134 self.check_strtod(s) 135 digits *= 2 136 137 # Try numbers of the form n * 5**p2 * 10**(e - p5), p5 138 # >= 0, with n * 5**p5 < 10**20. 139 digits, exponent = n, e 140 while digits < 10**20: 141 s = '{}e{}'.format(digits, exponent) 142 self.check_strtod(s) 143 # Same again, but with extra trailing zeros. 144 s = '{}e{}'.format(digits * 10**40, exponent - 40) 145 self.check_strtod(s) 146 digits *= 5 147 exponent -= 1 148 149 def test_halfway_cases(self): 150 # test halfway cases for the round-half-to-even rule 151 for i in range(100 * TEST_SIZE): 152 # bit pattern for a random finite positive (or +0.0) float 153 bits = random.randrange(2047*2**52) 154 155 # convert bit pattern to a number of the form m * 2**e 156 e, m = divmod(bits, 2**52) 157 if e: 158 m, e = m + 2**52, e - 1 159 e -= 1074 160 161 # add 0.5 ulps 162 m, e = 2*m + 1, e - 1 163 164 # convert to a decimal string 165 if e >= 0: 166 digits = m << e 167 exponent = 0 168 else: 169 # m * 2**e = (m * 5**-e) * 10**e 170 digits = m * 5**-e 171 exponent = e 172 s = '{}e{}'.format(digits, exponent) 173 self.check_strtod(s) 174 175 def test_boundaries(self): 176 # boundaries expressed as triples (n, e, u), where 177 # n*10**e is an approximation to the boundary value and 178 # u*10**e is 1ulp 179 boundaries = [ 180 (10000000000000000000, -19, 1110), # a power of 2 boundary (1.0) 181 (17976931348623159077, 289, 1995), # overflow boundary (2.**1024) 182 (22250738585072013831, -327, 4941), # normal/subnormal (2.**-1022) 183 (0, -327, 4941), # zero 184 ] 185 for n, e, u in boundaries: 186 for j in range(1000): 187 digits = n + random.randrange(-3*u, 3*u) 188 exponent = e 189 s = '{}e{}'.format(digits, exponent) 190 self.check_strtod(s) 191 n *= 10 192 u *= 10 193 e -= 1 194 195 def test_underflow_boundary(self): 196 # test values close to 2**-1075, the underflow boundary; similar 197 # to boundary_tests, except that the random error doesn't scale 198 # with n 199 for exponent in range(-400, -320): 200 base = 10**-exponent // 2**1075 201 for j in range(TEST_SIZE): 202 digits = base + random.randrange(-1000, 1000) 203 s = '{}e{}'.format(digits, exponent) 204 self.check_strtod(s) 205 206 def test_bigcomp(self): 207 for ndigs in 5, 10, 14, 15, 16, 17, 18, 19, 20, 40, 41, 50: 208 dig10 = 10**ndigs 209 for i in range(10 * TEST_SIZE): 210 digits = random.randrange(dig10) 211 exponent = random.randrange(-400, 400) 212 s = '{}e{}'.format(digits, exponent) 213 self.check_strtod(s) 214 215 def test_parsing(self): 216 # make '0' more likely to be chosen than other digits 217 digits = '000000123456789' 218 signs = ('+', '-', '') 219 220 # put together random short valid strings 221 # \d*[.\d*]?e 222 for i in range(1000): 223 for j in range(TEST_SIZE): 224 s = random.choice(signs) 225 intpart_len = random.randrange(5) 226 s += ''.join(random.choice(digits) for _ in range(intpart_len)) 227 if random.choice([True, False]): 228 s += '.' 229 fracpart_len = random.randrange(5) 230 s += ''.join(random.choice(digits) 231 for _ in range(fracpart_len)) 232 else: 233 fracpart_len = 0 234 if random.choice([True, False]): 235 s += random.choice(['e', 'E']) 236 s += random.choice(signs) 237 exponent_len = random.randrange(1, 4) 238 s += ''.join(random.choice(digits) 239 for _ in range(exponent_len)) 240 241 if intpart_len + fracpart_len: 242 self.check_strtod(s) 243 else: 244 try: 245 float(s) 246 except ValueError: 247 pass 248 else: 249 assert False, "expected ValueError" 250 251 @test.support.bigmemtest(size=test.support._2G+10, memuse=3, dry_run=False) 252 def test_oversized_digit_strings(self, maxsize): 253 # Input string whose length doesn't fit in an INT. 254 s = "1." + "1" * maxsize 255 with self.assertRaises(ValueError): 256 float(s) 257 del s 258 259 s = "0." + "0" * maxsize + "1" 260 with self.assertRaises(ValueError): 261 float(s) 262 del s 263 264 def test_large_exponents(self): 265 # Verify that the clipping of the exponent in strtod doesn't affect the 266 # output values. 267 def positive_exp(n): 268 """ Long string with value 1.0 and exponent n""" 269 return '0.{}1e+{}'.format('0'*(n-1), n) 270 271 def negative_exp(n): 272 """ Long string with value 1.0 and exponent -n""" 273 return '1{}e-{}'.format('0'*n, n) 274 275 self.assertEqual(float(positive_exp(10000)), 1.0) 276 self.assertEqual(float(positive_exp(20000)), 1.0) 277 self.assertEqual(float(positive_exp(30000)), 1.0) 278 self.assertEqual(float(negative_exp(10000)), 1.0) 279 self.assertEqual(float(negative_exp(20000)), 1.0) 280 self.assertEqual(float(negative_exp(30000)), 1.0) 281 282 def test_particular(self): 283 # inputs that produced crashes or incorrectly rounded results with 284 # previous versions of dtoa.c, for various reasons 285 test_strings = [ 286 # issue 7632 bug 1, originally reported failing case 287 '2183167012312112312312.23538020374420446192e-370', 288 # 5 instances of issue 7632 bug 2 289 '12579816049008305546974391768996369464963024663104e-357', 290 '17489628565202117263145367596028389348922981857013e-357', 291 '18487398785991994634182916638542680759613590482273e-357', 292 '32002864200581033134358724675198044527469366773928e-358', 293 '94393431193180696942841837085033647913224148539854e-358', 294 '73608278998966969345824653500136787876436005957953e-358', 295 '64774478836417299491718435234611299336288082136054e-358', 296 '13704940134126574534878641876947980878824688451169e-357', 297 '46697445774047060960624497964425416610480524760471e-358', 298 # failing case for bug introduced by METD in r77451 (attempted 299 # fix for issue 7632, bug 2), and fixed in r77482. 300 '28639097178261763178489759107321392745108491825303e-311', 301 # two numbers demonstrating a flaw in the bigcomp 'dig == 0' 302 # correction block (issue 7632, bug 3) 303 '1.00000000000000001e44', 304 '1.0000000000000000100000000000000000000001e44', 305 # dtoa.c bug for numbers just smaller than a power of 2 (issue 306 # 7632, bug 4) 307 '99999999999999994487665465554760717039532578546e-47', 308 # failing case for off-by-one error introduced by METD in 309 # r77483 (dtoa.c cleanup), fixed in r77490 310 '965437176333654931799035513671997118345570045914469' #... 311 '6213413350821416312194420007991306908470147322020121018368e0', 312 # incorrect lsb detection for round-half-to-even when 313 # bc->scale != 0 (issue 7632, bug 6). 314 '104308485241983990666713401708072175773165034278685' #... 315 '682646111762292409330928739751702404658197872319129' #... 316 '036519947435319418387839758990478549477777586673075' #... 317 '945844895981012024387992135617064532141489278815239' #... 318 '849108105951619997829153633535314849999674266169258' #... 319 '928940692239684771590065027025835804863585454872499' #... 320 '320500023126142553932654370362024104462255244034053' #... 321 '203998964360882487378334860197725139151265590832887' #... 322 '433736189468858614521708567646743455601905935595381' #... 323 '852723723645799866672558576993978025033590728687206' #... 324 '296379801363024094048327273913079612469982585674824' #... 325 '156000783167963081616214710691759864332339239688734' #... 326 '656548790656486646106983450809073750535624894296242' #... 327 '072010195710276073042036425579852459556183541199012' #... 328 '652571123898996574563824424330960027873516082763671875e-1075', 329 # demonstration that original fix for issue 7632 bug 1 was 330 # buggy; the exit condition was too strong 331 '247032822920623295e-341', 332 # demonstrate similar problem to issue 7632 bug1: crash 333 # with 'oversized quotient in quorem' message. 334 '99037485700245683102805043437346965248029601286431e-373', 335 '99617639833743863161109961162881027406769510558457e-373', 336 '98852915025769345295749278351563179840130565591462e-372', 337 '99059944827693569659153042769690930905148015876788e-373', 338 '98914979205069368270421829889078356254059760327101e-372', 339 # issue 7632 bug 5: the following 2 strings convert differently 340 '1000000000000000000000000000000000000000e-16', 341 '10000000000000000000000000000000000000000e-17', 342 # issue 7632 bug 7 343 '991633793189150720000000000000000000000000000000000000000e-33', 344 # And another, similar, failing halfway case 345 '4106250198039490000000000000000000000000000000000000000e-38', 346 # issue 7632 bug 8: the following produced 10.0 347 '10.900000000000000012345678912345678912345', 348 349 # two humongous values from issue 7743 350 '116512874940594195638617907092569881519034793229385' #... 351 '228569165191541890846564669771714896916084883987920' #... 352 '473321268100296857636200926065340769682863349205363' #... 353 '349247637660671783209907949273683040397979984107806' #... 354 '461822693332712828397617946036239581632976585100633' #... 355 '520260770761060725403904123144384571612073732754774' #... 356 '588211944406465572591022081973828448927338602556287' #... 357 '851831745419397433012491884869454462440536895047499' #... 358 '436551974649731917170099387762871020403582994193439' #... 359 '761933412166821484015883631622539314203799034497982' #... 360 '130038741741727907429575673302461380386596501187482' #... 361 '006257527709842179336488381672818798450229339123527' #... 362 '858844448336815912020452294624916993546388956561522' #... 363 '161875352572590420823607478788399460162228308693742' #... 364 '05287663441403533948204085390898399055004119873046875e-1075', 365 366 '525440653352955266109661060358202819561258984964913' #... 367 '892256527849758956045218257059713765874251436193619' #... 368 '443248205998870001633865657517447355992225852945912' #... 369 '016668660000210283807209850662224417504752264995360' #... 370 '631512007753855801075373057632157738752800840302596' #... 371 '237050247910530538250008682272783660778181628040733' #... 372 '653121492436408812668023478001208529190359254322340' #... 373 '397575185248844788515410722958784640926528544043090' #... 374 '115352513640884988017342469275006999104519620946430' #... 375 '818767147966495485406577703972687838176778993472989' #... 376 '561959000047036638938396333146685137903018376496408' #... 377 '319705333868476925297317136513970189073693314710318' #... 378 '991252811050501448326875232850600451776091303043715' #... 379 '157191292827614046876950225714743118291034780466325' #... 380 '085141343734564915193426994587206432697337118211527' #... 381 '278968731294639353354774788602467795167875117481660' #... 382 '4738791256853675690543663283782215866825e-1180', 383 384 # exercise exit conditions in bigcomp comparison loop 385 '2602129298404963083833853479113577253105939995688e2', 386 '260212929840496308383385347911357725310593999568896e0', 387 '26021292984049630838338534791135772531059399956889601e-2', 388 '260212929840496308383385347911357725310593999568895e0', 389 '260212929840496308383385347911357725310593999568897e0', 390 '260212929840496308383385347911357725310593999568996e0', 391 '260212929840496308383385347911357725310593999568866e0', 392 # 2**53 393 '9007199254740992.00', 394 # 2**1024 - 2**970: exact overflow boundary. All values 395 # smaller than this should round to something finite; any value 396 # greater than or equal to this one overflows. 397 '179769313486231580793728971405303415079934132710037' #... 398 '826936173778980444968292764750946649017977587207096' #... 399 '330286416692887910946555547851940402630657488671505' #... 400 '820681908902000708383676273854845817711531764475730' #... 401 '270069855571366959622842914819860834936475292719074' #... 402 '168444365510704342711559699508093042880177904174497792', 403 # 2**1024 - 2**970 - tiny 404 '179769313486231580793728971405303415079934132710037' #... 405 '826936173778980444968292764750946649017977587207096' #... 406 '330286416692887910946555547851940402630657488671505' #... 407 '820681908902000708383676273854845817711531764475730' #... 408 '270069855571366959622842914819860834936475292719074' #... 409 '168444365510704342711559699508093042880177904174497791.999', 410 # 2**1024 - 2**970 + tiny 411 '179769313486231580793728971405303415079934132710037' #... 412 '826936173778980444968292764750946649017977587207096' #... 413 '330286416692887910946555547851940402630657488671505' #... 414 '820681908902000708383676273854845817711531764475730' #... 415 '270069855571366959622842914819860834936475292719074' #... 416 '168444365510704342711559699508093042880177904174497792.001', 417 # 1 - 2**-54, +-tiny 418 '999999999999999944488848768742172978818416595458984375e-54', 419 '9999999999999999444888487687421729788184165954589843749999999e-54', 420 '9999999999999999444888487687421729788184165954589843750000001e-54', 421 # Value found by Rick Regan that gives a result of 2**-968 422 # under Gay's dtoa.c (as of Nov 04, 2010); since fixed. 423 # (Fixed some time ago in Python's dtoa.c.) 424 '0.0000000000000000000000000000000000000000100000000' #... 425 '000000000576129113423785429971690421191214034235435' #... 426 '087147763178149762956868991692289869941246658073194' #... 427 '51982237978882039897143840789794921875', 428 ] 429 for s in test_strings: 430 self.check_strtod(s) 431 432if __name__ == "__main__": 433 unittest.main() 434