Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / cpython2 / 9ab44b509a935011beb8e9108a2271ee728e8ad4 / . / Lib / test / test_float.py
blob: e2d1ea0a7cd630323b0199fa9bec898c08c2c603 [file] [log] [blame]
Michael W. Hudsonba283e22005-05-27 15:23:20 +0000[diff] [blame]1
2import unittest, struct
Christian Heimes827b35c2007-12-10 22:19:17 +0000[diff] [blame]3import os
Eric Smith0923d1d2009-04-16 20:16:10 +0000[diff] [blame]4import sys
Benjamin Petersonee8712c2008-05-20 21:35:26 +0000[diff] [blame]5from test import support
Christian Heimes53876d92008-04-19 00:31:39 +0000[diff] [blame]6import math
Mark Dickinson65fe25e2008-07-16 11:30:51 +0000[diff] [blame]7from math import isinf, isnan, copysign, ldexp
Christian Heimes53876d92008-04-19 00:31:39 +0000[diff] [blame]8import operator
Amaury Forgeot d'Arc7e958d12008-09-06 21:03:22 +0000[diff] [blame]9import random, fractions
Michael W. Hudsonba283e22005-05-27 15:23:20 +0000[diff] [blame]10
Christian Heimes53876d92008-04-19 00:31:39 +0000[diff] [blame]11INF = float("inf")
12NAN = float("nan")
Christian Heimes99170a52007-12-19 02:07:34 +0000[diff] [blame]13
Mark Dickinson9ab44b52009-12-30 16:22:49 +0000[diff] [blame^]14# decorator for skipping tests on non-IEEE 754 platforms
15requires_IEEE_754 = unittest.skipUnless(
16 float.__getformat__("double").startswith("IEEE"),
17 "test requires IEEE 754 doubles")
18
Eric Smith0923d1d2009-04-16 20:16:10 +0000[diff] [blame]19#locate file with float format test values
20test_dir = os.path.dirname(__file__) or os.curdir
21format_testfile = os.path.join(test_dir, 'formatfloat_testcases.txt')
22
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000[diff] [blame]23class GeneralFloatCases(unittest.TestCase):
24
25 def test_float(self):
26 self.assertEqual(float(3.14), 3.14)
27 self.assertEqual(float(314), 314.0)
28 self.assertEqual(float(" 3.14 "), 3.14)
Amaury Forgeot d'Arc7e958d12008-09-06 21:03:22 +0000[diff] [blame]29 self.assertEqual(float(b" 3.14 "), 3.14)
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000[diff] [blame]30 self.assertRaises(ValueError, float, " 0x3.1 ")
31 self.assertRaises(ValueError, float, " -0x3.p-1 ")
32 self.assertRaises(ValueError, float, " +0x3.p-1 ")
33 self.assertRaises(ValueError, float, "++3.14")
34 self.assertRaises(ValueError, float, "+-3.14")
35 self.assertRaises(ValueError, float, "-+3.14")
36 self.assertRaises(ValueError, float, "--3.14")
Eric Smith0923d1d2009-04-16 20:16:10 +0000[diff] [blame]37 self.assertRaises(ValueError, float, ".nan")
38 self.assertRaises(ValueError, float, "+.inf")
39 self.assertRaises(ValueError, float, ".")
40 self.assertRaises(ValueError, float, "-.")
Amaury Forgeot d'Arc7e958d12008-09-06 21:03:22 +0000[diff] [blame]41 self.assertEqual(float(b" \u0663.\u0661\u0664 ".decode('raw-unicode-escape')), 3.14)
Mark Dickinsona9023be2009-10-27 22:12:20 +0000[diff] [blame]42 # extra long strings should not be a problem
43 float(b'.' + b'1'*1000)
44 float('.' + '1'*1000)
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000[diff] [blame]45
Benjamin Petersonee8712c2008-05-20 21:35:26 +0000[diff] [blame]46 @support.run_with_locale('LC_NUMERIC', 'fr_FR', 'de_DE')
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000[diff] [blame]47 def test_float_with_comma(self):
48 # set locale to something that doesn't use '.' for the decimal point
49 # float must not accept the locale specific decimal point but
50 # it still has to accept the normal python syntac
51 import locale
52 if not locale.localeconv()['decimal_point'] == ',':
53 return
54
55 self.assertEqual(float(" 3.14 "), 3.14)
56 self.assertEqual(float("+3.14 "), 3.14)
57 self.assertEqual(float("-3.14 "), -3.14)
58 self.assertEqual(float(".14 "), .14)
59 self.assertEqual(float("3. "), 3.0)
60 self.assertEqual(float("3.e3 "), 3000.0)
61 self.assertEqual(float("3.2e3 "), 3200.0)
62 self.assertEqual(float("2.5e-1 "), 0.25)
63 self.assertEqual(float("5e-1"), 0.5)
64 self.assertRaises(ValueError, float, " 3,14 ")
65 self.assertRaises(ValueError, float, " +3,14 ")
66 self.assertRaises(ValueError, float, " -3,14 ")
67 self.assertRaises(ValueError, float, " 0x3.1 ")
68 self.assertRaises(ValueError, float, " -0x3.p-1 ")
69 self.assertRaises(ValueError, float, " +0x3.p-1 ")
70 self.assertEqual(float(" 25.e-1 "), 2.5)
Benjamin Petersond43029b2008-09-06 23:33:21 +0000[diff] [blame]71 self.assertEqual(support.fcmp(float(" .25e-1 "), .025), 0)
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000[diff] [blame]72
73 def test_floatconversion(self):
74 # Make sure that calls to __float__() work properly
75 class Foo0:
76 def __float__(self):
77 return 42.
78
79 class Foo1(object):
80 def __float__(self):
81 return 42.
82
83 class Foo2(float):
84 def __float__(self):
85 return 42.
86
87 class Foo3(float):
88 def __new__(cls, value=0.):
89 return float.__new__(cls, 2*value)
90
91 def __float__(self):
92 return self
93
94 class Foo4(float):
95 def __float__(self):
96 return 42
97
Benjamin Peterson2808d3c2009-04-15 21:34:27 +0000[diff] [blame]98 # Issue 5759: __float__ not called on str subclasses (though it is on
99 # unicode subclasses).
100 class FooStr(str):
101 def __float__(self):
102 return float(str(self)) + 1
103
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000[diff] [blame]104 self.assertAlmostEqual(float(Foo0()), 42.)
105 self.assertAlmostEqual(float(Foo1()), 42.)
106 self.assertAlmostEqual(float(Foo2()), 42.)
107 self.assertAlmostEqual(float(Foo3(21)), 42.)
108 self.assertRaises(TypeError, float, Foo4(42))
Benjamin Peterson2808d3c2009-04-15 21:34:27 +0000[diff] [blame]109 self.assertAlmostEqual(float(FooStr('8')), 9.)
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000[diff] [blame]110
111 def test_floatasratio(self):
112 for f, ratio in [
113 (0.875, (7, 8)),
114 (-0.875, (-7, 8)),
115 (0.0, (0, 1)),
116 (11.5, (23, 2)),
117 ]:
118 self.assertEqual(f.as_integer_ratio(), ratio)
119
120 for i in range(10000):
121 f = random.random()
122 f *= 10 ** random.randint(-100, 100)
123 n, d = f.as_integer_ratio()
124 self.assertEqual(float(n).__truediv__(d), f)
125
126 R = fractions.Fraction
127 self.assertEqual(R(0, 1),
128 R(*float(0.0).as_integer_ratio()))
129 self.assertEqual(R(5, 2),
130 R(*float(2.5).as_integer_ratio()))
131 self.assertEqual(R(1, 2),
132 R(*float(0.5).as_integer_ratio()))
133 self.assertEqual(R(4728779608739021, 2251799813685248),
134 R(*float(2.1).as_integer_ratio()))
135 self.assertEqual(R(-4728779608739021, 2251799813685248),
136 R(*float(-2.1).as_integer_ratio()))
137 self.assertEqual(R(-2100, 1),
138 R(*float(-2100.0).as_integer_ratio()))
139
140 self.assertRaises(OverflowError, float('inf').as_integer_ratio)
141 self.assertRaises(OverflowError, float('-inf').as_integer_ratio)
142 self.assertRaises(ValueError, float('nan').as_integer_ratio)
143
Mark Dickinson4a1f5932008-11-12 23:23:36 +0000[diff] [blame]144 def test_float_containment(self):
145 floats = (INF, -INF, 0.0, 1.0, NAN)
146 for f in floats:
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000[diff] [blame]147 self.assertTrue(f in [f], "'%r' not in []" % f)
148 self.assertTrue(f in (f,), "'%r' not in ()" % f)
149 self.assertTrue(f in {f}, "'%r' not in set()" % f)
150 self.assertTrue(f in {f: None}, "'%r' not in {}" % f)
Mark Dickinson4a1f5932008-11-12 23:23:36 +0000[diff] [blame]151 self.assertEqual([f].count(f), 1, "[].count('%r') != 1" % f)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000[diff] [blame]152 self.assertTrue(f in floats, "'%r' not in container" % f)
Mark Dickinson4a1f5932008-11-12 23:23:36 +0000[diff] [blame]153
154 for f in floats:
155 # nonidentical containers, same type, same contents
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000[diff] [blame]156 self.assertTrue([f] == [f], "[%r] != [%r]" % (f, f))
157 self.assertTrue((f,) == (f,), "(%r,) != (%r,)" % (f, f))
158 self.assertTrue({f} == {f}, "{%r} != {%r}" % (f, f))
159 self.assertTrue({f : None} == {f: None}, "{%r : None} != "
Mark Dickinson4a1f5932008-11-12 23:23:36 +0000[diff] [blame]160 "{%r : None}" % (f, f))
161
162 # identical containers
163 l, t, s, d = [f], (f,), {f}, {f: None}
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000[diff] [blame]164 self.assertTrue(l == l, "[%r] not equal to itself" % f)
165 self.assertTrue(t == t, "(%r,) not equal to itself" % f)
166 self.assertTrue(s == s, "{%r} not equal to itself" % f)
167 self.assertTrue(d == d, "{%r : None} not equal to itself" % f)
Mark Dickinson4a1f5932008-11-12 23:23:36 +0000[diff] [blame]168
Mark Dickinson9ab44b52009-12-30 16:22:49 +0000[diff] [blame^]169 def assertEqualAndEqualSign(self, a, b):
170 # fail unless a == b and a and b have the same sign bit;
171 # the only difference from assertEqual is that this test
172 # distingishes -0.0 and 0.0.
173 self.assertEqual((a, copysign(1.0, a)), (b, copysign(1.0, b)))
174
175 @requires_IEEE_754
176 def test_float_pow(self):
177 # test builtin pow and ** operator for IEEE 754 special cases.
178 # Special cases taken from section F.9.4.4 of the C99 specification
179
180 for pow_op in pow, operator.pow:
181 # x**NAN is NAN for any x except 1
182 self.assertTrue(isnan(pow_op(-INF, NAN)))
183 self.assertTrue(isnan(pow_op(-2.0, NAN)))
184 self.assertTrue(isnan(pow_op(-1.0, NAN)))
185 self.assertTrue(isnan(pow_op(-0.5, NAN)))
186 self.assertTrue(isnan(pow_op(-0.0, NAN)))
187 self.assertTrue(isnan(pow_op(0.0, NAN)))
188 self.assertTrue(isnan(pow_op(0.5, NAN)))
189 self.assertTrue(isnan(pow_op(2.0, NAN)))
190 self.assertTrue(isnan(pow_op(INF, NAN)))
191 self.assertTrue(isnan(pow_op(NAN, NAN)))
192
193 # NAN**y is NAN for any y except +-0
194 self.assertTrue(isnan(pow_op(NAN, -INF)))
195 self.assertTrue(isnan(pow_op(NAN, -2.0)))
196 self.assertTrue(isnan(pow_op(NAN, -1.0)))
197 self.assertTrue(isnan(pow_op(NAN, -0.5)))
198 self.assertTrue(isnan(pow_op(NAN, 0.5)))
199 self.assertTrue(isnan(pow_op(NAN, 1.0)))
200 self.assertTrue(isnan(pow_op(NAN, 2.0)))
201 self.assertTrue(isnan(pow_op(NAN, INF)))
202
203 # (+-0)**y raises ZeroDivisionError for y a negative odd integer
204 self.assertRaises(ZeroDivisionError, pow_op, -0.0, -1.0)
205 self.assertRaises(ZeroDivisionError, pow_op, 0.0, -1.0)
206
207 # (+-0)**y raises ZeroDivisionError for y finite and negative
208 # but not an odd integer
209 self.assertRaises(ZeroDivisionError, pow_op, -0.0, -2.0)
210 self.assertRaises(ZeroDivisionError, pow_op, -0.0, -0.5)
211 self.assertRaises(ZeroDivisionError, pow_op, 0.0, -2.0)
212 self.assertRaises(ZeroDivisionError, pow_op, 0.0, -0.5)
213
214 # (+-0)**y is +-0 for y a positive odd integer
215 self.assertEqualAndEqualSign(pow_op(-0.0, 1.0), -0.0)
216 self.assertEqualAndEqualSign(pow_op(0.0, 1.0), 0.0)
217
218 # (+-0)**y is 0 for y finite and positive but not an odd integer
219 self.assertEqualAndEqualSign(pow_op(-0.0, 0.5), 0.0)
220 self.assertEqualAndEqualSign(pow_op(-0.0, 2.0), 0.0)
221 self.assertEqualAndEqualSign(pow_op(0.0, 0.5), 0.0)
222 self.assertEqualAndEqualSign(pow_op(0.0, 2.0), 0.0)
223
224 # (-1)**+-inf is 1
225 self.assertEqualAndEqualSign(pow_op(-1.0, -INF), 1.0)
226 self.assertEqualAndEqualSign(pow_op(-1.0, INF), 1.0)
227
228 # 1**y is 1 for any y, even if y is an infinity or nan
229 self.assertEqualAndEqualSign(pow_op(1.0, -INF), 1.0)
230 self.assertEqualAndEqualSign(pow_op(1.0, -2.0), 1.0)
231 self.assertEqualAndEqualSign(pow_op(1.0, -1.0), 1.0)
232 self.assertEqualAndEqualSign(pow_op(1.0, -0.5), 1.0)
233 self.assertEqualAndEqualSign(pow_op(1.0, -0.0), 1.0)
234 self.assertEqualAndEqualSign(pow_op(1.0, 0.0), 1.0)
235 self.assertEqualAndEqualSign(pow_op(1.0, 0.5), 1.0)
236 self.assertEqualAndEqualSign(pow_op(1.0, 1.0), 1.0)
237 self.assertEqualAndEqualSign(pow_op(1.0, 2.0), 1.0)
238 self.assertEqualAndEqualSign(pow_op(1.0, INF), 1.0)
239 self.assertEqualAndEqualSign(pow_op(1.0, NAN), 1.0)
240
241 # x**+-0 is 1 for any x, even if x is a zero, infinity, or nan
242 self.assertEqualAndEqualSign(pow_op(-INF, 0.0), 1.0)
243 self.assertEqualAndEqualSign(pow_op(-2.0, 0.0), 1.0)
244 self.assertEqualAndEqualSign(pow_op(-1.0, 0.0), 1.0)
245 self.assertEqualAndEqualSign(pow_op(-0.5, 0.0), 1.0)
246 self.assertEqualAndEqualSign(pow_op(-0.0, 0.0), 1.0)
247 self.assertEqualAndEqualSign(pow_op(0.0, 0.0), 1.0)
248 self.assertEqualAndEqualSign(pow_op(0.5, 0.0), 1.0)
249 self.assertEqualAndEqualSign(pow_op(1.0, 0.0), 1.0)
250 self.assertEqualAndEqualSign(pow_op(2.0, 0.0), 1.0)
251 self.assertEqualAndEqualSign(pow_op(INF, 0.0), 1.0)
252 self.assertEqualAndEqualSign(pow_op(NAN, 0.0), 1.0)
253 self.assertEqualAndEqualSign(pow_op(-INF, -0.0), 1.0)
254 self.assertEqualAndEqualSign(pow_op(-2.0, -0.0), 1.0)
255 self.assertEqualAndEqualSign(pow_op(-1.0, -0.0), 1.0)
256 self.assertEqualAndEqualSign(pow_op(-0.5, -0.0), 1.0)
257 self.assertEqualAndEqualSign(pow_op(-0.0, -0.0), 1.0)
258 self.assertEqualAndEqualSign(pow_op(0.0, -0.0), 1.0)
259 self.assertEqualAndEqualSign(pow_op(0.5, -0.0), 1.0)
260 self.assertEqualAndEqualSign(pow_op(1.0, -0.0), 1.0)
261 self.assertEqualAndEqualSign(pow_op(2.0, -0.0), 1.0)
262 self.assertEqualAndEqualSign(pow_op(INF, -0.0), 1.0)
263 self.assertEqualAndEqualSign(pow_op(NAN, -0.0), 1.0)
264
265 # x**y defers to complex pow for finite negative x and
266 # non-integral y.
267 self.assertEqual(type(pow_op(-2.0, -0.5)), complex)
268 self.assertEqual(type(pow_op(-2.0, 0.5)), complex)
269 self.assertEqual(type(pow_op(-1.0, -0.5)), complex)
270 self.assertEqual(type(pow_op(-1.0, 0.5)), complex)
271 self.assertEqual(type(pow_op(-0.5, -0.5)), complex)
272 self.assertEqual(type(pow_op(-0.5, 0.5)), complex)
273
274 # x**-INF is INF for abs(x) < 1
275 self.assertEqualAndEqualSign(pow_op(-0.5, -INF), INF)
276 self.assertEqualAndEqualSign(pow_op(-0.0, -INF), INF)
277 self.assertEqualAndEqualSign(pow_op(0.0, -INF), INF)
278 self.assertEqualAndEqualSign(pow_op(0.5, -INF), INF)
279
280 # x**-INF is 0 for abs(x) > 1
281 self.assertEqualAndEqualSign(pow_op(-INF, -INF), 0.0)
282 self.assertEqualAndEqualSign(pow_op(-2.0, -INF), 0.0)
283 self.assertEqualAndEqualSign(pow_op(2.0, -INF), 0.0)
284 self.assertEqualAndEqualSign(pow_op(INF, -INF), 0.0)
285
286 # x**INF is 0 for abs(x) < 1
287 self.assertEqualAndEqualSign(pow_op(-0.5, INF), 0.0)
288 self.assertEqualAndEqualSign(pow_op(-0.0, INF), 0.0)
289 self.assertEqualAndEqualSign(pow_op(0.0, INF), 0.0)
290 self.assertEqualAndEqualSign(pow_op(0.5, INF), 0.0)
291
292 # x**INF is INF for abs(x) > 1
293 self.assertEqualAndEqualSign(pow_op(-INF, INF), INF)
294 self.assertEqualAndEqualSign(pow_op(-2.0, INF), INF)
295 self.assertEqualAndEqualSign(pow_op(2.0, INF), INF)
296 self.assertEqualAndEqualSign(pow_op(INF, INF), INF)
297
298 # (-INF)**y is -0.0 for y a negative odd integer
299 self.assertEqualAndEqualSign(pow_op(-INF, -1.0), -0.0)
300
301 # (-INF)**y is 0.0 for y negative but not an odd integer
302 self.assertEqualAndEqualSign(pow_op(-INF, -0.5), 0.0)
303 self.assertEqualAndEqualSign(pow_op(-INF, -2.0), 0.0)
304
305 # (-INF)**y is -INF for y a positive odd integer
306 self.assertEqualAndEqualSign(pow_op(-INF, 1.0), -INF)
307
308 # (-INF)**y is INF for y positive but not an odd integer
309 self.assertEqualAndEqualSign(pow_op(-INF, 0.5), INF)
310 self.assertEqualAndEqualSign(pow_op(-INF, 2.0), INF)
311
312 # INF**y is INF for y positive
313 self.assertEqualAndEqualSign(pow_op(INF, 0.5), INF)
314 self.assertEqualAndEqualSign(pow_op(INF, 1.0), INF)
315 self.assertEqualAndEqualSign(pow_op(INF, 2.0), INF)
316
317 # INF**y is 0.0 for y negative
318 self.assertEqualAndEqualSign(pow_op(INF, -2.0), 0.0)
319 self.assertEqualAndEqualSign(pow_op(INF, -1.0), 0.0)
320 self.assertEqualAndEqualSign(pow_op(INF, -0.5), 0.0)
321
322 # basic checks not covered by the special cases above
323 self.assertEqualAndEqualSign(pow_op(-2.0, -2.0), 0.25)
324 self.assertEqualAndEqualSign(pow_op(-2.0, -1.0), -0.5)
325 self.assertEqualAndEqualSign(pow_op(-2.0, -0.0), 1.0)
326 self.assertEqualAndEqualSign(pow_op(-2.0, 0.0), 1.0)
327 self.assertEqualAndEqualSign(pow_op(-2.0, 1.0), -2.0)
328 self.assertEqualAndEqualSign(pow_op(-2.0, 2.0), 4.0)
329 self.assertEqualAndEqualSign(pow_op(-1.0, -2.0), 1.0)
330 self.assertEqualAndEqualSign(pow_op(-1.0, -1.0), -1.0)
331 self.assertEqualAndEqualSign(pow_op(-1.0, -0.0), 1.0)
332 self.assertEqualAndEqualSign(pow_op(-1.0, 0.0), 1.0)
333 self.assertEqualAndEqualSign(pow_op(-1.0, 1.0), -1.0)
334 self.assertEqualAndEqualSign(pow_op(-1.0, 2.0), 1.0)
335 self.assertEqualAndEqualSign(pow_op(2.0, -2.0), 0.25)
336 self.assertEqualAndEqualSign(pow_op(2.0, -1.0), 0.5)
337 self.assertEqualAndEqualSign(pow_op(2.0, -0.0), 1.0)
338 self.assertEqualAndEqualSign(pow_op(2.0, 0.0), 1.0)
339 self.assertEqualAndEqualSign(pow_op(2.0, 1.0), 2.0)
340 self.assertEqualAndEqualSign(pow_op(2.0, 2.0), 4.0)
341
342 # 1 ** large and -1 ** large; some libms apparently
343 # have problems with these
344 self.assertEqualAndEqualSign(pow_op(1.0, -1e100), 1.0)
345 self.assertEqualAndEqualSign(pow_op(1.0, 1e100), 1.0)
346 self.assertEqualAndEqualSign(pow_op(-1.0, -1e100), 1.0)
347 self.assertEqualAndEqualSign(pow_op(-1.0, 1e100), 1.0)
348
349 # check sign for results that underflow to 0
350 self.assertEqualAndEqualSign(pow_op(-2.0, -2000.0), 0.0)
351 self.assertEqual(type(pow_op(-2.0, -2000.5)), complex)
352 self.assertEqualAndEqualSign(pow_op(-2.0, -2001.0), -0.0)
353 self.assertEqualAndEqualSign(pow_op(2.0, -2000.0), 0.0)
354 self.assertEqualAndEqualSign(pow_op(2.0, -2000.5), 0.0)
355 self.assertEqualAndEqualSign(pow_op(2.0, -2001.0), 0.0)
356 self.assertEqualAndEqualSign(pow_op(-0.5, 2000.0), 0.0)
357 self.assertEqual(type(pow_op(-0.5, 2000.5)), complex)
358 self.assertEqualAndEqualSign(pow_op(-0.5, 2001.0), -0.0)
359 self.assertEqualAndEqualSign(pow_op(0.5, 2000.0), 0.0)
360 self.assertEqualAndEqualSign(pow_op(0.5, 2000.5), 0.0)
361 self.assertEqualAndEqualSign(pow_op(0.5, 2001.0), 0.0)
362
363 # check we don't raise an exception for subnormal results,
364 # and validate signs. Tests currently disabled, since
365 # they fail on systems where a subnormal result from pow
366 # is flushed to zero (e.g. Debian/ia64.)
367 #self.assertTrue(0.0 < pow_op(0.5, 1048) < 1e-315)
368 #self.assertTrue(0.0 < pow_op(-0.5, 1048) < 1e-315)
369 #self.assertTrue(0.0 < pow_op(0.5, 1047) < 1e-315)
370 #self.assertTrue(0.0 > pow_op(-0.5, 1047) > -1e-315)
371 #self.assertTrue(0.0 < pow_op(2.0, -1048) < 1e-315)
372 #self.assertTrue(0.0 < pow_op(-2.0, -1048) < 1e-315)
373 #self.assertTrue(0.0 < pow_op(2.0, -1047) < 1e-315)
374 #self.assertTrue(0.0 > pow_op(-2.0, -1047) > -1e-315)
Mark Dickinson4a1f5932008-11-12 23:23:36 +0000[diff] [blame]375
376
Michael W. Hudsonba283e22005-05-27 15:23:20 +0000[diff] [blame]377class FormatFunctionsTestCase(unittest.TestCase):
378
379 def setUp(self):
380 self.save_formats = {'double':float.__getformat__('double'),
381 'float':float.__getformat__('float')}
382
383 def tearDown(self):
384 float.__setformat__('double', self.save_formats['double'])
385 float.__setformat__('float', self.save_formats['float'])
386
387 def test_getformat(self):
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000[diff] [blame]388 self.assertTrue(float.__getformat__('double') in
Michael W. Hudsonba283e22005-05-27 15:23:20 +0000[diff] [blame]389 ['unknown', 'IEEE, big-endian', 'IEEE, little-endian'])
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000[diff] [blame]390 self.assertTrue(float.__getformat__('float') in
Michael W. Hudsonba283e22005-05-27 15:23:20 +0000[diff] [blame]391 ['unknown', 'IEEE, big-endian', 'IEEE, little-endian'])
392 self.assertRaises(ValueError, float.__getformat__, 'chicken')
393 self.assertRaises(TypeError, float.__getformat__, 1)
394
395 def test_setformat(self):
396 for t in 'double', 'float':
397 float.__setformat__(t, 'unknown')
398 if self.save_formats[t] == 'IEEE, big-endian':
399 self.assertRaises(ValueError, float.__setformat__,
400 t, 'IEEE, little-endian')
401 elif self.save_formats[t] == 'IEEE, little-endian':
402 self.assertRaises(ValueError, float.__setformat__,
403 t, 'IEEE, big-endian')
404 else:
405 self.assertRaises(ValueError, float.__setformat__,
406 t, 'IEEE, big-endian')
407 self.assertRaises(ValueError, float.__setformat__,
408 t, 'IEEE, little-endian')
409 self.assertRaises(ValueError, float.__setformat__,
410 t, 'chicken')
411 self.assertRaises(ValueError, float.__setformat__,
412 'chicken', 'unknown')
413
Guido van Rossum2be161d2007-05-15 20:43:51 +0000[diff] [blame]414BE_DOUBLE_INF = b'\x7f\xf0\x00\x00\x00\x00\x00\x00'
Guido van Rossum254348e2007-11-21 19:29:53 +0000[diff] [blame]415LE_DOUBLE_INF = bytes(reversed(BE_DOUBLE_INF))
Guido van Rossum2be161d2007-05-15 20:43:51 +0000[diff] [blame]416BE_DOUBLE_NAN = b'\x7f\xf8\x00\x00\x00\x00\x00\x00'
Guido van Rossum254348e2007-11-21 19:29:53 +0000[diff] [blame]417LE_DOUBLE_NAN = bytes(reversed(BE_DOUBLE_NAN))
Michael W. Hudsonba283e22005-05-27 15:23:20 +0000[diff] [blame]418
Guido van Rossum2be161d2007-05-15 20:43:51 +0000[diff] [blame]419BE_FLOAT_INF = b'\x7f\x80\x00\x00'
Guido van Rossum254348e2007-11-21 19:29:53 +0000[diff] [blame]420LE_FLOAT_INF = bytes(reversed(BE_FLOAT_INF))
Guido van Rossum2be161d2007-05-15 20:43:51 +0000[diff] [blame]421BE_FLOAT_NAN = b'\x7f\xc0\x00\x00'
Guido van Rossum254348e2007-11-21 19:29:53 +0000[diff] [blame]422LE_FLOAT_NAN = bytes(reversed(BE_FLOAT_NAN))
Michael W. Hudsonba283e22005-05-27 15:23:20 +0000[diff] [blame]423
424# on non-IEEE platforms, attempting to unpack a bit pattern
425# representing an infinity or a NaN should raise an exception.
426
427class UnknownFormatTestCase(unittest.TestCase):
428 def setUp(self):
429 self.save_formats = {'double':float.__getformat__('double'),
430 'float':float.__getformat__('float')}
431 float.__setformat__('double', 'unknown')
432 float.__setformat__('float', 'unknown')
Tim Peters5d36a552005-06-03 22:40:27 +0000[diff] [blame]433
Michael W. Hudsonba283e22005-05-27 15:23:20 +0000[diff] [blame]434 def tearDown(self):
435 float.__setformat__('double', self.save_formats['double'])
436 float.__setformat__('float', self.save_formats['float'])
437
438 def test_double_specials_dont_unpack(self):
439 for fmt, data in [('>d', BE_DOUBLE_INF),
440 ('>d', BE_DOUBLE_NAN),
441 ('<d', LE_DOUBLE_INF),
442 ('<d', LE_DOUBLE_NAN)]:
443 self.assertRaises(ValueError, struct.unpack, fmt, data)
444
445 def test_float_specials_dont_unpack(self):
446 for fmt, data in [('>f', BE_FLOAT_INF),
447 ('>f', BE_FLOAT_NAN),
448 ('<f', LE_FLOAT_INF),
449 ('<f', LE_FLOAT_NAN)]:
450 self.assertRaises(ValueError, struct.unpack, fmt, data)
451
452
453# on an IEEE platform, all we guarantee is that bit patterns
454# representing infinities or NaNs do not raise an exception; all else
455# is accident (today).
Guido van Rossum04110fb2007-08-24 16:32:05 +0000[diff] [blame]456# let's also try to guarantee that -0.0 and 0.0 don't get confused.
Michael W. Hudsonba283e22005-05-27 15:23:20 +0000[diff] [blame]457
458class IEEEFormatTestCase(unittest.TestCase):
459 if float.__getformat__("double").startswith("IEEE"):
460 def test_double_specials_do_unpack(self):
461 for fmt, data in [('>d', BE_DOUBLE_INF),
462 ('>d', BE_DOUBLE_NAN),
463 ('<d', LE_DOUBLE_INF),
464 ('<d', LE_DOUBLE_NAN)]:
465 struct.unpack(fmt, data)
466
467 if float.__getformat__("float").startswith("IEEE"):
468 def test_float_specials_do_unpack(self):
469 for fmt, data in [('>f', BE_FLOAT_INF),
470 ('>f', BE_FLOAT_NAN),
471 ('<f', LE_FLOAT_INF),
472 ('<f', LE_FLOAT_NAN)]:
473 struct.unpack(fmt, data)
474
Guido van Rossum04110fb2007-08-24 16:32:05 +0000[diff] [blame]475 if float.__getformat__("double").startswith("IEEE"):
476 def test_negative_zero(self):
477 import math
478 def pos_pos():
479 return 0.0, math.atan2(0.0, -1)
480 def pos_neg():
481 return 0.0, math.atan2(-0.0, -1)
482 def neg_pos():
483 return -0.0, math.atan2(0.0, -1)
484 def neg_neg():
485 return -0.0, math.atan2(-0.0, -1)
486 self.assertEquals(pos_pos(), neg_pos())
487 self.assertEquals(pos_neg(), neg_neg())
488
Eric Smith8c663262007-08-25 02:26:07 +0000[diff] [blame]489class FormatTestCase(unittest.TestCase):
Eric Smith11fe3e02007-08-31 01:33:06 +0000[diff] [blame]490 def test_format(self):
Eric Smith8c663262007-08-25 02:26:07 +0000[diff] [blame]491 # these should be rewritten to use both format(x, spec) and
492 # x.__format__(spec)
493
494 self.assertEqual(format(0.0, 'f'), '0.000000')
495
496 # the default is 'g', except for empty format spec
497 self.assertEqual(format(0.0, ''), '0.0')
498 self.assertEqual(format(0.01, ''), '0.01')
499 self.assertEqual(format(0.01, 'g'), '0.01')
500
Eric Smith63376222009-05-05 14:04:18 +0000[diff] [blame]501 # empty presentation type should format in the same way as str
502 # (issue 5920)
503 x = 100/7.
504 self.assertEqual(format(x, ''), str(x))
505 self.assertEqual(format(x, '-'), str(x))
506 self.assertEqual(format(x, '>'), str(x))
507 self.assertEqual(format(x, '2'), str(x))
Eric Smith8c663262007-08-25 02:26:07 +0000[diff] [blame]508
509 self.assertEqual(format(1.0, 'f'), '1.000000')
Eric Smith8c663262007-08-25 02:26:07 +0000[diff] [blame]510
511 self.assertEqual(format(-1.0, 'f'), '-1.000000')
Eric Smith8c663262007-08-25 02:26:07 +0000[diff] [blame]512
513 self.assertEqual(format( 1.0, ' f'), ' 1.000000')
514 self.assertEqual(format(-1.0, ' f'), '-1.000000')
515 self.assertEqual(format( 1.0, '+f'), '+1.000000')
516 self.assertEqual(format(-1.0, '+f'), '-1.000000')
517
518 # % formatting
519 self.assertEqual(format(-1.0, '%'), '-100.000000%')
520
521 # conversion to string should fail
522 self.assertRaises(ValueError, format, 3.0, "s")
523
Eric Smith7b69c6c2008-01-27 21:07:59 +0000[diff] [blame]524 # other format specifiers shouldn't work on floats,
525 # in particular int specifiers
526 for format_spec in ([chr(x) for x in range(ord('a'), ord('z')+1)] +
527 [chr(x) for x in range(ord('A'), ord('Z')+1)]):
528 if not format_spec in 'eEfFgGn%':
529 self.assertRaises(ValueError, format, 0.0, format_spec)
530 self.assertRaises(ValueError, format, 1.0, format_spec)
531 self.assertRaises(ValueError, format, -1.0, format_spec)
532 self.assertRaises(ValueError, format, 1e100, format_spec)
533 self.assertRaises(ValueError, format, -1e100, format_spec)
534 self.assertRaises(ValueError, format, 1e-100, format_spec)
535 self.assertRaises(ValueError, format, -1e-100, format_spec)
Michael W. Hudsonba283e22005-05-27 15:23:20 +0000[diff] [blame]536
Eric Smith741191f2009-05-06 13:08:15 +0000[diff] [blame]537 # issue 3382
538 self.assertEqual(format(NAN, 'f'), 'nan')
539 self.assertEqual(format(NAN, 'F'), 'NAN')
540 self.assertEqual(format(INF, 'f'), 'inf')
541 self.assertEqual(format(INF, 'F'), 'INF')
542
Eric Smith0923d1d2009-04-16 20:16:10 +0000[diff] [blame]543 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
544 "test requires IEEE 754 doubles")
545 def test_format_testfile(self):
546 for line in open(format_testfile):
547 if line.startswith('--'):
548 continue
549 line = line.strip()
550 if not line:
551 continue
552
553 lhs, rhs = map(str.strip, line.split('->'))
554 fmt, arg = lhs.split()
555 self.assertEqual(fmt % float(arg), rhs)
556 self.assertEqual(fmt % -float(arg), '-' + rhs)
557
Mark Dickinsond3ca5572009-04-29 18:47:07 +0000[diff] [blame]558 def test_issue5864(self):
559 self.assertEquals(format(123.456, '.4'), '123.5')
560 self.assertEquals(format(1234.56, '.4'), '1.235e+03')
561 self.assertEquals(format(12345.6, '.4'), '1.235e+04')
562
Mark Dickinson7efad9e2009-04-17 20:59:58 +0000[diff] [blame]563class ReprTestCase(unittest.TestCase):
564 def test_repr(self):
565 floats_file = open(os.path.join(os.path.split(__file__)[0],
566 'floating_points.txt'))
567 for line in floats_file:
568 line = line.strip()
569 if not line or line.startswith('#'):
570 continue
571 v = eval(line)
572 self.assertEqual(v, eval(repr(v)))
573 floats_file.close()
574
Eric Smith0923d1d2009-04-16 20:16:10 +0000[diff] [blame]575 @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
576 "applies only when using short float repr style")
577 def test_short_repr(self):
578 # test short float repr introduced in Python 3.1. One aspect
579 # of this repr is that we get some degree of str -> float ->
580 # str roundtripping. In particular, for any numeric string
581 # containing 15 or fewer significant digits, those exact same
582 # digits (modulo trailing zeros) should appear in the output.
583 # No more repr(0.03) -> "0.029999999999999999"!
584
585 test_strings = [
586 # output always includes *either* a decimal point and at
587 # least one digit after that point, or an exponent.
588 '0.0',
589 '1.0',
590 '0.01',
591 '0.02',
592 '0.03',
593 '0.04',
594 '0.05',
595 '1.23456789',
596 '10.0',
597 '100.0',
598 # values >= 1e16 get an exponent...
599 '1000000000000000.0',
600 '9999999999999990.0',
601 '1e+16',
602 '1e+17',
603 # ... and so do values < 1e-4
604 '0.001',
605 '0.001001',
606 '0.00010000000000001',
607 '0.0001',
608 '9.999999999999e-05',
609 '1e-05',
610 # values designed to provoke failure if the FPU rounding
611 # precision isn't set correctly
612 '8.72293771110361e+25',
613 '7.47005307342313e+26',
614 '2.86438000439698e+28',
615 '8.89142905246179e+28',
616 '3.08578087079232e+35',
617 ]
618
619 for s in test_strings:
620 negs = '-'+s
621 self.assertEqual(s, repr(float(s)))
622 self.assertEqual(negs, repr(float(negs)))
623
Mark Dickinsone6a076d2009-04-18 11:48:33 +0000[diff] [blame]624class RoundTestCase(unittest.TestCase):
625 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
626 "test requires IEEE 754 doubles")
627 def test_inf_nan(self):
628 self.assertRaises(OverflowError, round, INF)
629 self.assertRaises(OverflowError, round, -INF)
630 self.assertRaises(ValueError, round, NAN)
Mark Dickinson4ca33d12009-11-24 10:59:34 +0000[diff] [blame]631 self.assertRaises(TypeError, round, INF, 0.0)
632 self.assertRaises(TypeError, round, -INF, 1.0)
633 self.assertRaises(TypeError, round, NAN, "ceci n'est pas un integer")
634 self.assertRaises(TypeError, round, -0.0, 1j)
Mark Dickinsone6a076d2009-04-18 11:48:33 +0000[diff] [blame]635
636 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
637 "test requires IEEE 754 doubles")
638 def test_large_n(self):
639 for n in [324, 325, 400, 2**31-1, 2**31, 2**32, 2**100]:
640 self.assertEqual(round(123.456, n), 123.456)
641 self.assertEqual(round(-123.456, n), -123.456)
642 self.assertEqual(round(1e300, n), 1e300)
643 self.assertEqual(round(1e-320, n), 1e-320)
644 self.assertEqual(round(1e150, 300), 1e150)
645 self.assertEqual(round(1e300, 307), 1e300)
646 self.assertEqual(round(-3.1415, 308), -3.1415)
647 self.assertEqual(round(1e150, 309), 1e150)
648 self.assertEqual(round(1.4e-315, 315), 1e-315)
649
650 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
651 "test requires IEEE 754 doubles")
652 def test_small_n(self):
653 for n in [-308, -309, -400, 1-2**31, -2**31, -2**31-1, -2**100]:
654 self.assertEqual(round(123.456, n), 0.0)
655 self.assertEqual(round(-123.456, n), -0.0)
656 self.assertEqual(round(1e300, n), 0.0)
657 self.assertEqual(round(1e-320, n), 0.0)
658
659 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
660 "test requires IEEE 754 doubles")
661 def test_overflow(self):
662 self.assertRaises(OverflowError, round, 1.6e308, -308)
663 self.assertRaises(OverflowError, round, -1.7e308, -308)
664
665 @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
666 "applies only when using short float repr style")
667 def test_previous_round_bugs(self):
668 # particular cases that have occurred in bug reports
669 self.assertEqual(round(562949953421312.5, 1),
670 562949953421312.5)
671 self.assertEqual(round(56294995342131.5, 3),
672 56294995342131.5)
673 # round-half-even
674 self.assertEqual(round(25.0, -1), 20.0)
675 self.assertEqual(round(35.0, -1), 40.0)
676 self.assertEqual(round(45.0, -1), 40.0)
677 self.assertEqual(round(55.0, -1), 60.0)
678 self.assertEqual(round(65.0, -1), 60.0)
679 self.assertEqual(round(75.0, -1), 80.0)
680 self.assertEqual(round(85.0, -1), 80.0)
681 self.assertEqual(round(95.0, -1), 100.0)
682
683 @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
684 "applies only when using short float repr style")
685 def test_matches_float_format(self):
686 # round should give the same results as float formatting
687 for i in range(500):
688 x = i/1000.
689 self.assertEqual(float(format(x, '.0f')), round(x, 0))
690 self.assertEqual(float(format(x, '.1f')), round(x, 1))
691 self.assertEqual(float(format(x, '.2f')), round(x, 2))
692 self.assertEqual(float(format(x, '.3f')), round(x, 3))
693
694 for i in range(5, 5000, 10):
695 x = i/1000.
696 self.assertEqual(float(format(x, '.0f')), round(x, 0))
697 self.assertEqual(float(format(x, '.1f')), round(x, 1))
698 self.assertEqual(float(format(x, '.2f')), round(x, 2))
699 self.assertEqual(float(format(x, '.3f')), round(x, 3))
700
701 for i in range(500):
702 x = random.random()
703 self.assertEqual(float(format(x, '.0f')), round(x, 0))
704 self.assertEqual(float(format(x, '.1f')), round(x, 1))
705 self.assertEqual(float(format(x, '.2f')), round(x, 2))
706 self.assertEqual(float(format(x, '.3f')), round(x, 3))
707
708
Eric Smith8a10ecc2009-12-02 17:58:24 +0000[diff] [blame]709 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
710 "test requires IEEE 754 doubles")
711 def test_format_specials(self):
712 # Test formatting of nans and infs.
713
714 def test(fmt, value, expected):
715 # Test with both % and format().
716 self.assertEqual(fmt % value, expected, fmt)
717 if not '#' in fmt:
718 # Until issue 7094 is implemented, format() for floats doesn't
719 # support '#' formatting
720 fmt = fmt[1:] # strip off the %
721 self.assertEqual(format(value, fmt), expected, fmt)
722
723 for fmt in ['%e', '%f', '%g', '%.0e', '%.6f', '%.20g',
724 '%#e', '%#f', '%#g', '%#.20e', '%#.15f', '%#.3g']:
725 pfmt = '%+' + fmt[1:]
726 sfmt = '% ' + fmt[1:]
727 test(fmt, INF, 'inf')
728 test(fmt, -INF, '-inf')
729 test(fmt, NAN, 'nan')
730 test(fmt, -NAN, 'nan')
731 # When asking for a sign, it's always provided. nans are
732 # always positive.
733 test(pfmt, INF, '+inf')
734 test(pfmt, -INF, '-inf')
735 test(pfmt, NAN, '+nan')
736 test(pfmt, -NAN, '+nan')
737 # When using ' ' for a sign code, only infs can be negative.
738 # Others have a space.
739 test(sfmt, INF, ' inf')
740 test(sfmt, -INF, '-inf')
741 test(sfmt, NAN, ' nan')
742 test(sfmt, -NAN, ' nan')
743
Mark Dickinsone6a076d2009-04-18 11:48:33 +0000[diff] [blame]744
Christian Heimes99170a52007-12-19 02:07:34 +0000[diff] [blame]745# Beginning with Python 2.6 float has cross platform compatible
Georg Brandl2ee470f2008-07-16 12:55:28 +0000[diff] [blame]746# ways to create and represent inf and nan
Christian Heimes99170a52007-12-19 02:07:34 +0000[diff] [blame]747class InfNanTest(unittest.TestCase):
748 def test_inf_from_str(self):
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000[diff] [blame]749 self.assertTrue(isinf(float("inf")))
750 self.assertTrue(isinf(float("+inf")))
751 self.assertTrue(isinf(float("-inf")))
752 self.assertTrue(isinf(float("infinity")))
753 self.assertTrue(isinf(float("+infinity")))
754 self.assertTrue(isinf(float("-infinity")))
Christian Heimes99170a52007-12-19 02:07:34 +0000[diff] [blame]755
756 self.assertEqual(repr(float("inf")), "inf")
757 self.assertEqual(repr(float("+inf")), "inf")
758 self.assertEqual(repr(float("-inf")), "-inf")
Georg Brandl2ee470f2008-07-16 12:55:28 +0000[diff] [blame]759 self.assertEqual(repr(float("infinity")), "inf")
760 self.assertEqual(repr(float("+infinity")), "inf")
761 self.assertEqual(repr(float("-infinity")), "-inf")
Christian Heimes99170a52007-12-19 02:07:34 +0000[diff] [blame]762
763 self.assertEqual(repr(float("INF")), "inf")
764 self.assertEqual(repr(float("+Inf")), "inf")
765 self.assertEqual(repr(float("-iNF")), "-inf")
Georg Brandl2ee470f2008-07-16 12:55:28 +0000[diff] [blame]766 self.assertEqual(repr(float("Infinity")), "inf")
767 self.assertEqual(repr(float("+iNfInItY")), "inf")
768 self.assertEqual(repr(float("-INFINITY")), "-inf")
Christian Heimes99170a52007-12-19 02:07:34 +0000[diff] [blame]769
770 self.assertEqual(str(float("inf")), "inf")
771 self.assertEqual(str(float("+inf")), "inf")
772 self.assertEqual(str(float("-inf")), "-inf")
Georg Brandl2ee470f2008-07-16 12:55:28 +0000[diff] [blame]773 self.assertEqual(str(float("infinity")), "inf")
774 self.assertEqual(str(float("+infinity")), "inf")
775 self.assertEqual(str(float("-infinity")), "-inf")
Christian Heimes99170a52007-12-19 02:07:34 +0000[diff] [blame]776
777 self.assertRaises(ValueError, float, "info")
778 self.assertRaises(ValueError, float, "+info")
779 self.assertRaises(ValueError, float, "-info")
780 self.assertRaises(ValueError, float, "in")
781 self.assertRaises(ValueError, float, "+in")
782 self.assertRaises(ValueError, float, "-in")
Georg Brandl2ee470f2008-07-16 12:55:28 +0000[diff] [blame]783 self.assertRaises(ValueError, float, "infinit")
784 self.assertRaises(ValueError, float, "+Infin")
785 self.assertRaises(ValueError, float, "-INFI")
786 self.assertRaises(ValueError, float, "infinitys")
Christian Heimes99170a52007-12-19 02:07:34 +0000[diff] [blame]787
Mark Dickinsonbd16edd2009-05-20 22:05:25 +0000[diff] [blame]788 self.assertRaises(ValueError, float, "++Inf")
789 self.assertRaises(ValueError, float, "-+inf")
790 self.assertRaises(ValueError, float, "+-infinity")
791 self.assertRaises(ValueError, float, "--Infinity")
792
Christian Heimes99170a52007-12-19 02:07:34 +0000[diff] [blame]793 def test_inf_as_str(self):
794 self.assertEqual(repr(1e300 * 1e300), "inf")
795 self.assertEqual(repr(-1e300 * 1e300), "-inf")
796
797 self.assertEqual(str(1e300 * 1e300), "inf")
798 self.assertEqual(str(-1e300 * 1e300), "-inf")
799
800 def test_nan_from_str(self):
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000[diff] [blame]801 self.assertTrue(isnan(float("nan")))
802 self.assertTrue(isnan(float("+nan")))
803 self.assertTrue(isnan(float("-nan")))
Christian Heimes99170a52007-12-19 02:07:34 +0000[diff] [blame]804
805 self.assertEqual(repr(float("nan")), "nan")
806 self.assertEqual(repr(float("+nan")), "nan")
807 self.assertEqual(repr(float("-nan")), "nan")
808
809 self.assertEqual(repr(float("NAN")), "nan")
810 self.assertEqual(repr(float("+NAn")), "nan")
811 self.assertEqual(repr(float("-NaN")), "nan")
812
813 self.assertEqual(str(float("nan")), "nan")
814 self.assertEqual(str(float("+nan")), "nan")
815 self.assertEqual(str(float("-nan")), "nan")
816
817 self.assertRaises(ValueError, float, "nana")
818 self.assertRaises(ValueError, float, "+nana")
819 self.assertRaises(ValueError, float, "-nana")
820 self.assertRaises(ValueError, float, "na")
821 self.assertRaises(ValueError, float, "+na")
822 self.assertRaises(ValueError, float, "-na")
823
Mark Dickinsonbd16edd2009-05-20 22:05:25 +0000[diff] [blame]824 self.assertRaises(ValueError, float, "++nan")
825 self.assertRaises(ValueError, float, "-+NAN")
826 self.assertRaises(ValueError, float, "+-NaN")
827 self.assertRaises(ValueError, float, "--nAn")
828
Christian Heimes99170a52007-12-19 02:07:34 +0000[diff] [blame]829 def test_nan_as_str(self):
830 self.assertEqual(repr(1e300 * 1e300 * 0), "nan")
831 self.assertEqual(repr(-1e300 * 1e300 * 0), "nan")
832
833 self.assertEqual(str(1e300 * 1e300 * 0), "nan")
834 self.assertEqual(str(-1e300 * 1e300 * 0), "nan")
Christian Heimes827b35c2007-12-10 22:19:17 +0000[diff] [blame]835
Christian Heimes53876d92008-04-19 00:31:39 +0000[diff] [blame]836 def notest_float_nan(self):
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000[diff] [blame]837 self.assertTrue(NAN.is_nan())
838 self.assertFalse(INF.is_nan())
839 self.assertFalse((0.).is_nan())
Christian Heimes53876d92008-04-19 00:31:39 +0000[diff] [blame]840
841 def notest_float_inf(self):
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000[diff] [blame]842 self.assertTrue(INF.is_inf())
843 self.assertFalse(NAN.is_inf())
844 self.assertFalse((0.).is_inf())
Christian Heimes53876d92008-04-19 00:31:39 +0000[diff] [blame]845
Mark Dickinson65fe25e2008-07-16 11:30:51 +0000[diff] [blame]846fromHex = float.fromhex
847toHex = float.hex
848class HexFloatTestCase(unittest.TestCase):
849 MAX = fromHex('0x.fffffffffffff8p+1024') # max normal
850 MIN = fromHex('0x1p-1022') # min normal
851 TINY = fromHex('0x0.0000000000001p-1022') # min subnormal
852 EPS = fromHex('0x0.0000000000001p0') # diff between 1.0 and next float up
853
854 def identical(self, x, y):
855 # check that floats x and y are identical, or that both
856 # are NaNs
857 if isnan(x) or isnan(y):
858 if isnan(x) == isnan(y):
859 return
860 elif x == y and (x != 0.0 or copysign(1.0, x) == copysign(1.0, y)):
861 return
862 self.fail('%r not identical to %r' % (x, y))
863
864 def test_ends(self):
Mark Dickinson38bbc482008-07-16 11:32:23 +0000[diff] [blame]865 self.identical(self.MIN, ldexp(1.0, -1022))
866 self.identical(self.TINY, ldexp(1.0, -1074))
867 self.identical(self.EPS, ldexp(1.0, -52))
868 self.identical(self.MAX, 2.*(ldexp(1.0, 1023) - ldexp(1.0, 970)))
Mark Dickinson65fe25e2008-07-16 11:30:51 +0000[diff] [blame]869
870 def test_invalid_inputs(self):
871 invalid_inputs = [
872 'infi', # misspelt infinities and nans
873 '-Infinit',
874 '++inf',
875 '-+Inf',
876 '--nan',
877 '+-NaN',
878 'snan',
879 'NaNs',
880 'nna',
Mark Dickinsond1ec8b22009-05-11 15:45:15 +0000[diff] [blame]881 'an',
882 'nf',
883 'nfinity',
884 'inity',
885 'iinity',
Mark Dickinson65fe25e2008-07-16 11:30:51 +0000[diff] [blame]886 '0xnan',
887 '',
888 ' ',
889 'x1.0p0',
890 '0xX1.0p0',
891 '+ 0x1.0p0', # internal whitespace
892 '- 0x1.0p0',
893 '0 x1.0p0',
894 '0x 1.0p0',
895 '0x1 2.0p0',
896 '+0x1 .0p0',
897 '0x1. 0p0',
898 '-0x1.0 1p0',
899 '-0x1.0 p0',
900 '+0x1.0p +0',
901 '0x1.0p -0',
902 '0x1.0p 0',
903 '+0x1.0p+ 0',
904 '-0x1.0p- 0',
905 '++0x1.0p-0', # double signs
906 '--0x1.0p0',
907 '+-0x1.0p+0',
908 '-+0x1.0p0',
909 '0x1.0p++0',
910 '+0x1.0p+-0',
911 '-0x1.0p-+0',
912 '0x1.0p--0',
913 '0x1.0.p0',
914 '0x.p0', # no hex digits before or after point
915 '0x1,p0', # wrong decimal point character
916 '0x1pa',
917 '0x1p\uff10', # fullwidth Unicode digits
918 '\uff10x1p0',
919 '0x\uff11p0',
920 '0x1.\uff10p0',
921 '0x1p0 \n 0x2p0',
922 '0x1p0\0 0x1p0', # embedded null byte is not end of string
923 ]
924 for x in invalid_inputs:
Mark Dickinson589b7952008-08-21 20:05:56 +0000[diff] [blame]925 try:
926 result = fromHex(x)
927 except ValueError:
928 pass
929 else:
930 self.fail('Expected float.fromhex(%r) to raise ValueError; '
931 'got %r instead' % (x, result))
Mark Dickinson65fe25e2008-07-16 11:30:51 +0000[diff] [blame]932
933
Mark Dickinsond1ec8b22009-05-11 15:45:15 +0000[diff] [blame]934 def test_whitespace(self):
935 value_pairs = [
936 ('inf', INF),
937 ('-Infinity', -INF),
938 ('nan', NAN),
939 ('1.0', 1.0),
940 ('-0x.2', -0.125),
941 ('-0.0', -0.0)
942 ]
943 whitespace = [
944 '',
945 ' ',
946 '\t',
947 '\n',
948 '\n \t',
949 '\f',
950 '\v',
951 '\r'
952 ]
953 for inp, expected in value_pairs:
954 for lead in whitespace:
955 for trail in whitespace:
956 got = fromHex(lead + inp + trail)
957 self.identical(got, expected)
958
959
Mark Dickinson65fe25e2008-07-16 11:30:51 +0000[diff] [blame]960 def test_from_hex(self):
961 MIN = self.MIN;
962 MAX = self.MAX;
963 TINY = self.TINY;
964 EPS = self.EPS;
965
966 # two spellings of infinity, with optional signs; case-insensitive
967 self.identical(fromHex('inf'), INF)
968 self.identical(fromHex('+Inf'), INF)
969 self.identical(fromHex('-INF'), -INF)
970 self.identical(fromHex('iNf'), INF)
971 self.identical(fromHex('Infinity'), INF)
972 self.identical(fromHex('+INFINITY'), INF)
973 self.identical(fromHex('-infinity'), -INF)
974 self.identical(fromHex('-iNFiNitY'), -INF)
975
976 # nans with optional sign; case insensitive
977 self.identical(fromHex('nan'), NAN)
978 self.identical(fromHex('+NaN'), NAN)
979 self.identical(fromHex('-NaN'), NAN)
980 self.identical(fromHex('-nAN'), NAN)
981
982 # variations in input format
983 self.identical(fromHex('1'), 1.0)
984 self.identical(fromHex('+1'), 1.0)
985 self.identical(fromHex('1.'), 1.0)
986 self.identical(fromHex('1.0'), 1.0)
987 self.identical(fromHex('1.0p0'), 1.0)
988 self.identical(fromHex('01'), 1.0)
989 self.identical(fromHex('01.'), 1.0)
990 self.identical(fromHex('0x1'), 1.0)
991 self.identical(fromHex('0x1.'), 1.0)
992 self.identical(fromHex('0x1.0'), 1.0)
993 self.identical(fromHex('+0x1.0'), 1.0)
994 self.identical(fromHex('0x1p0'), 1.0)
995 self.identical(fromHex('0X1p0'), 1.0)
996 self.identical(fromHex('0X1P0'), 1.0)
997 self.identical(fromHex('0x1P0'), 1.0)
998 self.identical(fromHex('0x1.p0'), 1.0)
999 self.identical(fromHex('0x1.0p0'), 1.0)
1000 self.identical(fromHex('0x.1p4'), 1.0)
1001 self.identical(fromHex('0x.1p04'), 1.0)
1002 self.identical(fromHex('0x.1p004'), 1.0)
1003 self.identical(fromHex('0x1p+0'), 1.0)
1004 self.identical(fromHex('0x1P-0'), 1.0)
1005 self.identical(fromHex('+0x1p0'), 1.0)
1006 self.identical(fromHex('0x01p0'), 1.0)
1007 self.identical(fromHex('0x1p00'), 1.0)
1008 self.identical(fromHex(' 0x1p0 '), 1.0)
1009 self.identical(fromHex('\n 0x1p0'), 1.0)
1010 self.identical(fromHex('0x1p0 \t'), 1.0)
1011 self.identical(fromHex('0xap0'), 10.0)
1012 self.identical(fromHex('0xAp0'), 10.0)
1013 self.identical(fromHex('0xaP0'), 10.0)
1014 self.identical(fromHex('0xAP0'), 10.0)
1015 self.identical(fromHex('0xbep0'), 190.0)
1016 self.identical(fromHex('0xBep0'), 190.0)
1017 self.identical(fromHex('0xbEp0'), 190.0)
1018 self.identical(fromHex('0XBE0P-4'), 190.0)
1019 self.identical(fromHex('0xBEp0'), 190.0)
1020 self.identical(fromHex('0xB.Ep4'), 190.0)
1021 self.identical(fromHex('0x.BEp8'), 190.0)
1022 self.identical(fromHex('0x.0BEp12'), 190.0)
1023
1024 # moving the point around
1025 pi = fromHex('0x1.921fb54442d18p1')
1026 self.identical(fromHex('0x.006487ed5110b46p11'), pi)
1027 self.identical(fromHex('0x.00c90fdaa22168cp10'), pi)
1028 self.identical(fromHex('0x.01921fb54442d18p9'), pi)
1029 self.identical(fromHex('0x.03243f6a8885a3p8'), pi)
1030 self.identical(fromHex('0x.06487ed5110b46p7'), pi)
1031 self.identical(fromHex('0x.0c90fdaa22168cp6'), pi)
1032 self.identical(fromHex('0x.1921fb54442d18p5'), pi)
1033 self.identical(fromHex('0x.3243f6a8885a3p4'), pi)
1034 self.identical(fromHex('0x.6487ed5110b46p3'), pi)
1035 self.identical(fromHex('0x.c90fdaa22168cp2'), pi)
1036 self.identical(fromHex('0x1.921fb54442d18p1'), pi)
1037 self.identical(fromHex('0x3.243f6a8885a3p0'), pi)
1038 self.identical(fromHex('0x6.487ed5110b46p-1'), pi)
1039 self.identical(fromHex('0xc.90fdaa22168cp-2'), pi)
1040 self.identical(fromHex('0x19.21fb54442d18p-3'), pi)
1041 self.identical(fromHex('0x32.43f6a8885a3p-4'), pi)
1042 self.identical(fromHex('0x64.87ed5110b46p-5'), pi)
1043 self.identical(fromHex('0xc9.0fdaa22168cp-6'), pi)
1044 self.identical(fromHex('0x192.1fb54442d18p-7'), pi)
1045 self.identical(fromHex('0x324.3f6a8885a3p-8'), pi)
1046 self.identical(fromHex('0x648.7ed5110b46p-9'), pi)
1047 self.identical(fromHex('0xc90.fdaa22168cp-10'), pi)
1048 self.identical(fromHex('0x1921.fb54442d18p-11'), pi)
1049 # ...
1050 self.identical(fromHex('0x1921fb54442d1.8p-47'), pi)
1051 self.identical(fromHex('0x3243f6a8885a3p-48'), pi)
1052 self.identical(fromHex('0x6487ed5110b46p-49'), pi)
1053 self.identical(fromHex('0xc90fdaa22168cp-50'), pi)
1054 self.identical(fromHex('0x1921fb54442d18p-51'), pi)
1055 self.identical(fromHex('0x3243f6a8885a30p-52'), pi)
1056 self.identical(fromHex('0x6487ed5110b460p-53'), pi)
1057 self.identical(fromHex('0xc90fdaa22168c0p-54'), pi)
1058 self.identical(fromHex('0x1921fb54442d180p-55'), pi)
1059
1060
1061 # results that should overflow...
1062 self.assertRaises(OverflowError, fromHex, '-0x1p1024')
1063 self.assertRaises(OverflowError, fromHex, '0x1p+1025')
1064 self.assertRaises(OverflowError, fromHex, '+0X1p1030')
1065 self.assertRaises(OverflowError, fromHex, '-0x1p+1100')
1066 self.assertRaises(OverflowError, fromHex, '0X1p123456789123456789')
1067 self.assertRaises(OverflowError, fromHex, '+0X.8p+1025')
1068 self.assertRaises(OverflowError, fromHex, '+0x0.8p1025')
1069 self.assertRaises(OverflowError, fromHex, '-0x0.4p1026')
1070 self.assertRaises(OverflowError, fromHex, '0X2p+1023')
1071 self.assertRaises(OverflowError, fromHex, '0x2.p1023')
1072 self.assertRaises(OverflowError, fromHex, '-0x2.0p+1023')
1073 self.assertRaises(OverflowError, fromHex, '+0X4p+1022')
1074 self.assertRaises(OverflowError, fromHex, '0x1.ffffffffffffffp+1023')
1075 self.assertRaises(OverflowError, fromHex, '-0X1.fffffffffffff9p1023')
1076 self.assertRaises(OverflowError, fromHex, '0X1.fffffffffffff8p1023')
1077 self.assertRaises(OverflowError, fromHex, '+0x3.fffffffffffffp1022')
1078 self.assertRaises(OverflowError, fromHex, '0x3fffffffffffffp+970')
1079 self.assertRaises(OverflowError, fromHex, '0x10000000000000000p960')
1080 self.assertRaises(OverflowError, fromHex, '-0Xffffffffffffffffp960')
1081
1082 # ...and those that round to +-max float
1083 self.identical(fromHex('+0x1.fffffffffffffp+1023'), MAX)
1084 self.identical(fromHex('-0X1.fffffffffffff7p1023'), -MAX)
1085 self.identical(fromHex('0X1.fffffffffffff7fffffffffffffp1023'), MAX)
1086
1087 # zeros
1088 self.identical(fromHex('0x0p0'), 0.0)
1089 self.identical(fromHex('0x0p1000'), 0.0)
1090 self.identical(fromHex('-0x0p1023'), -0.0)
1091 self.identical(fromHex('0X0p1024'), 0.0)
1092 self.identical(fromHex('-0x0p1025'), -0.0)
1093 self.identical(fromHex('0X0p2000'), 0.0)
1094 self.identical(fromHex('0x0p123456789123456789'), 0.0)
1095 self.identical(fromHex('-0X0p-0'), -0.0)
1096 self.identical(fromHex('-0X0p-1000'), -0.0)
1097 self.identical(fromHex('0x0p-1023'), 0.0)
1098 self.identical(fromHex('-0X0p-1024'), -0.0)
1099 self.identical(fromHex('-0x0p-1025'), -0.0)
1100 self.identical(fromHex('-0x0p-1072'), -0.0)
1101 self.identical(fromHex('0X0p-1073'), 0.0)
1102 self.identical(fromHex('-0x0p-1074'), -0.0)
1103 self.identical(fromHex('0x0p-1075'), 0.0)
1104 self.identical(fromHex('0X0p-1076'), 0.0)
1105 self.identical(fromHex('-0X0p-2000'), -0.0)
1106 self.identical(fromHex('-0x0p-123456789123456789'), -0.0)
1107
1108 # values that should underflow to 0
1109 self.identical(fromHex('0X1p-1075'), 0.0)
1110 self.identical(fromHex('-0X1p-1075'), -0.0)
1111 self.identical(fromHex('-0x1p-123456789123456789'), -0.0)
1112 self.identical(fromHex('0x1.00000000000000001p-1075'), TINY)
1113 self.identical(fromHex('-0x1.1p-1075'), -TINY)
1114 self.identical(fromHex('0x1.fffffffffffffffffp-1075'), TINY)
1115
1116 # check round-half-even is working correctly near 0 ...
1117 self.identical(fromHex('0x1p-1076'), 0.0)
1118 self.identical(fromHex('0X2p-1076'), 0.0)
1119 self.identical(fromHex('0X3p-1076'), TINY)
1120 self.identical(fromHex('0x4p-1076'), TINY)
1121 self.identical(fromHex('0X5p-1076'), TINY)
1122 self.identical(fromHex('0X6p-1076'), 2*TINY)
1123 self.identical(fromHex('0x7p-1076'), 2*TINY)
1124 self.identical(fromHex('0X8p-1076'), 2*TINY)
1125 self.identical(fromHex('0X9p-1076'), 2*TINY)
1126 self.identical(fromHex('0xap-1076'), 2*TINY)
1127 self.identical(fromHex('0Xbp-1076'), 3*TINY)
1128 self.identical(fromHex('0xcp-1076'), 3*TINY)
1129 self.identical(fromHex('0Xdp-1076'), 3*TINY)
1130 self.identical(fromHex('0Xep-1076'), 4*TINY)
1131 self.identical(fromHex('0xfp-1076'), 4*TINY)
1132 self.identical(fromHex('0x10p-1076'), 4*TINY)
1133 self.identical(fromHex('-0x1p-1076'), -0.0)
1134 self.identical(fromHex('-0X2p-1076'), -0.0)
1135 self.identical(fromHex('-0x3p-1076'), -TINY)
1136 self.identical(fromHex('-0X4p-1076'), -TINY)
1137 self.identical(fromHex('-0x5p-1076'), -TINY)
1138 self.identical(fromHex('-0x6p-1076'), -2*TINY)
1139 self.identical(fromHex('-0X7p-1076'), -2*TINY)
1140 self.identical(fromHex('-0X8p-1076'), -2*TINY)
1141 self.identical(fromHex('-0X9p-1076'), -2*TINY)
1142 self.identical(fromHex('-0Xap-1076'), -2*TINY)
1143 self.identical(fromHex('-0xbp-1076'), -3*TINY)
1144 self.identical(fromHex('-0xcp-1076'), -3*TINY)
1145 self.identical(fromHex('-0Xdp-1076'), -3*TINY)
1146 self.identical(fromHex('-0xep-1076'), -4*TINY)
1147 self.identical(fromHex('-0Xfp-1076'), -4*TINY)
1148 self.identical(fromHex('-0X10p-1076'), -4*TINY)
1149
1150 # ... and near MIN ...
1151 self.identical(fromHex('0x0.ffffffffffffd6p-1022'), MIN-3*TINY)
1152 self.identical(fromHex('0x0.ffffffffffffd8p-1022'), MIN-2*TINY)
1153 self.identical(fromHex('0x0.ffffffffffffdap-1022'), MIN-2*TINY)
1154 self.identical(fromHex('0x0.ffffffffffffdcp-1022'), MIN-2*TINY)
1155 self.identical(fromHex('0x0.ffffffffffffdep-1022'), MIN-2*TINY)
1156 self.identical(fromHex('0x0.ffffffffffffe0p-1022'), MIN-2*TINY)
1157 self.identical(fromHex('0x0.ffffffffffffe2p-1022'), MIN-2*TINY)
1158 self.identical(fromHex('0x0.ffffffffffffe4p-1022'), MIN-2*TINY)
1159 self.identical(fromHex('0x0.ffffffffffffe6p-1022'), MIN-2*TINY)
1160 self.identical(fromHex('0x0.ffffffffffffe8p-1022'), MIN-2*TINY)
1161 self.identical(fromHex('0x0.ffffffffffffeap-1022'), MIN-TINY)
1162 self.identical(fromHex('0x0.ffffffffffffecp-1022'), MIN-TINY)
1163 self.identical(fromHex('0x0.ffffffffffffeep-1022'), MIN-TINY)
1164 self.identical(fromHex('0x0.fffffffffffff0p-1022'), MIN-TINY)
1165 self.identical(fromHex('0x0.fffffffffffff2p-1022'), MIN-TINY)
1166 self.identical(fromHex('0x0.fffffffffffff4p-1022'), MIN-TINY)
1167 self.identical(fromHex('0x0.fffffffffffff6p-1022'), MIN-TINY)
1168 self.identical(fromHex('0x0.fffffffffffff8p-1022'), MIN)
1169 self.identical(fromHex('0x0.fffffffffffffap-1022'), MIN)
1170 self.identical(fromHex('0x0.fffffffffffffcp-1022'), MIN)
1171 self.identical(fromHex('0x0.fffffffffffffep-1022'), MIN)
1172 self.identical(fromHex('0x1.00000000000000p-1022'), MIN)
1173 self.identical(fromHex('0x1.00000000000002p-1022'), MIN)
1174 self.identical(fromHex('0x1.00000000000004p-1022'), MIN)
1175 self.identical(fromHex('0x1.00000000000006p-1022'), MIN)
1176 self.identical(fromHex('0x1.00000000000008p-1022'), MIN)
1177 self.identical(fromHex('0x1.0000000000000ap-1022'), MIN+TINY)
1178 self.identical(fromHex('0x1.0000000000000cp-1022'), MIN+TINY)
1179 self.identical(fromHex('0x1.0000000000000ep-1022'), MIN+TINY)
1180 self.identical(fromHex('0x1.00000000000010p-1022'), MIN+TINY)
1181 self.identical(fromHex('0x1.00000000000012p-1022'), MIN+TINY)
1182 self.identical(fromHex('0x1.00000000000014p-1022'), MIN+TINY)
1183 self.identical(fromHex('0x1.00000000000016p-1022'), MIN+TINY)
1184 self.identical(fromHex('0x1.00000000000018p-1022'), MIN+2*TINY)
1185
1186 # ... and near 1.0.
1187 self.identical(fromHex('0x0.fffffffffffff0p0'), 1.0-EPS)
1188 self.identical(fromHex('0x0.fffffffffffff1p0'), 1.0-EPS)
1189 self.identical(fromHex('0X0.fffffffffffff2p0'), 1.0-EPS)
1190 self.identical(fromHex('0x0.fffffffffffff3p0'), 1.0-EPS)
1191 self.identical(fromHex('0X0.fffffffffffff4p0'), 1.0-EPS)
1192 self.identical(fromHex('0X0.fffffffffffff5p0'), 1.0-EPS/2)
1193 self.identical(fromHex('0X0.fffffffffffff6p0'), 1.0-EPS/2)
1194 self.identical(fromHex('0x0.fffffffffffff7p0'), 1.0-EPS/2)
1195 self.identical(fromHex('0x0.fffffffffffff8p0'), 1.0-EPS/2)
1196 self.identical(fromHex('0X0.fffffffffffff9p0'), 1.0-EPS/2)
1197 self.identical(fromHex('0X0.fffffffffffffap0'), 1.0-EPS/2)
1198 self.identical(fromHex('0x0.fffffffffffffbp0'), 1.0-EPS/2)
1199 self.identical(fromHex('0X0.fffffffffffffcp0'), 1.0)
1200 self.identical(fromHex('0x0.fffffffffffffdp0'), 1.0)
1201 self.identical(fromHex('0X0.fffffffffffffep0'), 1.0)
1202 self.identical(fromHex('0x0.ffffffffffffffp0'), 1.0)
1203 self.identical(fromHex('0X1.00000000000000p0'), 1.0)
1204 self.identical(fromHex('0X1.00000000000001p0'), 1.0)
1205 self.identical(fromHex('0x1.00000000000002p0'), 1.0)
1206 self.identical(fromHex('0X1.00000000000003p0'), 1.0)
1207 self.identical(fromHex('0x1.00000000000004p0'), 1.0)
1208 self.identical(fromHex('0X1.00000000000005p0'), 1.0)
1209 self.identical(fromHex('0X1.00000000000006p0'), 1.0)
1210 self.identical(fromHex('0X1.00000000000007p0'), 1.0)
1211 self.identical(fromHex('0x1.00000000000007ffffffffffffffffffffp0'),
1212 1.0)
1213 self.identical(fromHex('0x1.00000000000008p0'), 1.0)
1214 self.identical(fromHex('0x1.00000000000008000000000000000001p0'),
1215 1+EPS)
1216 self.identical(fromHex('0X1.00000000000009p0'), 1.0+EPS)
1217 self.identical(fromHex('0x1.0000000000000ap0'), 1.0+EPS)
1218 self.identical(fromHex('0x1.0000000000000bp0'), 1.0+EPS)
1219 self.identical(fromHex('0X1.0000000000000cp0'), 1.0+EPS)
1220 self.identical(fromHex('0x1.0000000000000dp0'), 1.0+EPS)
1221 self.identical(fromHex('0x1.0000000000000ep0'), 1.0+EPS)
1222 self.identical(fromHex('0X1.0000000000000fp0'), 1.0+EPS)
1223 self.identical(fromHex('0x1.00000000000010p0'), 1.0+EPS)
1224 self.identical(fromHex('0X1.00000000000011p0'), 1.0+EPS)
1225 self.identical(fromHex('0x1.00000000000012p0'), 1.0+EPS)
1226 self.identical(fromHex('0X1.00000000000013p0'), 1.0+EPS)
1227 self.identical(fromHex('0X1.00000000000014p0'), 1.0+EPS)
1228 self.identical(fromHex('0x1.00000000000015p0'), 1.0+EPS)
1229 self.identical(fromHex('0x1.00000000000016p0'), 1.0+EPS)
1230 self.identical(fromHex('0X1.00000000000017p0'), 1.0+EPS)
1231 self.identical(fromHex('0x1.00000000000017ffffffffffffffffffffp0'),
1232 1.0+EPS)
1233 self.identical(fromHex('0x1.00000000000018p0'), 1.0+2*EPS)
1234 self.identical(fromHex('0X1.00000000000018000000000000000001p0'),
1235 1.0+2*EPS)
1236 self.identical(fromHex('0x1.00000000000019p0'), 1.0+2*EPS)
1237 self.identical(fromHex('0X1.0000000000001ap0'), 1.0+2*EPS)
1238 self.identical(fromHex('0X1.0000000000001bp0'), 1.0+2*EPS)
1239 self.identical(fromHex('0x1.0000000000001cp0'), 1.0+2*EPS)
1240 self.identical(fromHex('0x1.0000000000001dp0'), 1.0+2*EPS)
1241 self.identical(fromHex('0x1.0000000000001ep0'), 1.0+2*EPS)
1242 self.identical(fromHex('0X1.0000000000001fp0'), 1.0+2*EPS)
1243 self.identical(fromHex('0x1.00000000000020p0'), 1.0+2*EPS)
1244
1245 def test_roundtrip(self):
1246 def roundtrip(x):
1247 return fromHex(toHex(x))
1248
1249 for x in [NAN, INF, self.MAX, self.MIN, self.MIN-self.TINY, self.TINY, 0.0]:
1250 self.identical(x, roundtrip(x))
1251 self.identical(-x, roundtrip(-x))
1252
1253 # fromHex(toHex(x)) should exactly recover x, for any non-NaN float x.
1254 import random
1255 for i in range(10000):
1256 e = random.randrange(-1200, 1200)
1257 m = random.random()
1258 s = random.choice([1.0, -1.0])
1259 try:
1260 x = s*ldexp(m, e)
1261 except OverflowError:
1262 pass
1263 else:
1264 self.identical(x, fromHex(toHex(x)))
1265
Christian Heimes53876d92008-04-19 00:31:39 +0000[diff] [blame]1266
Michael W. Hudsonba283e22005-05-27 15:23:20 +0000[diff] [blame]1267def test_main():
Benjamin Petersonee8712c2008-05-20 21:35:26 +0000[diff] [blame]1268 support.run_unittest(
Amaury Forgeot d'Arc7e958d12008-09-06 21:03:22 +0000[diff] [blame]1269 GeneralFloatCases,
Michael W. Hudsonba283e22005-05-27 15:23:20 +0000[diff] [blame]1270 FormatFunctionsTestCase,
1271 UnknownFormatTestCase,
Eric Smith8c663262007-08-25 02:26:07 +0000[diff] [blame]1272 IEEEFormatTestCase,
Christian Heimes827b35c2007-12-10 22:19:17 +0000[diff] [blame]1273 FormatTestCase,
Christian Heimes99170a52007-12-19 02:07:34 +0000[diff] [blame]1274 ReprTestCase,
Mark Dickinsone6a076d2009-04-18 11:48:33 +0000[diff] [blame]1275 RoundTestCase,
Christian Heimes99170a52007-12-19 02:07:34 +0000[diff] [blame]1276 InfNanTest,
Mark Dickinson65fe25e2008-07-16 11:30:51 +0000[diff] [blame]1277 HexFloatTestCase,
Christian Heimesb76922a2007-12-11 01:06:40 +0000[diff] [blame]1278 )
Michael W. Hudsonba283e22005-05-27 15:23:20 +0000[diff] [blame]1279
1280if __name__ == '__main__':
1281 test_main()