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