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