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