ยปCore Development>Code coverage>Lib/test/test_strtod.py

# Python code coverage for Lib/test/test_strtod.py

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