Debian Codegraph @

Lib/test/test_float.py

raw
1 import fractions
2 import operator
3 import os
4 import random
5 import sys
6 import struct
7 import time
8 import unittest
9
10 from test import support
11 from test.support.testcase import FloatsAreIdenticalMixin
12 from test.support.numbers import (
13 VALID_UNDERSCORE_LITERALS,
14 INVALID_UNDERSCORE_LITERALS,
15 )
16 from math import isinf, isnan, copysign, ldexp
17 import math
18
19 try:
20 import _testcapi
21 except ImportError:
22 _testcapi = None
23
24 INF = float("inf")
25 NAN = float("nan")
26
27
28 #locate file with float format test values
29 test_dir = os.path.dirname(__file__) or os.curdir
30 format_testfile = os.path.join(test_dir, 'mathdata', 'formatfloat_testcases.txt')
31
32 class FloatSubclass(float):
33 pass
34
35 class OtherFloatSubclass(float):
36 pass
37
38 class MyIndex:
39 def __init__(self, value):
40 self.value = value
41
42 def __index__(self):
43 return self.value
44
45 class MyInt:
46 def __init__(self, value):
47 self.value = value
48
49 def __int__(self):
50 return self.value
51
52 class FloatLike:
53 def __init__(self, value):
54 self.value = value
55
56 def __float__(self):
57 return self.value
58
59
60 class GeneralFloatCases(unittest.TestCase):
61
62 def test_float(self):
63 self.assertEqual(float(3.14), 3.14)
64 self.assertEqual(float(314), 314.0)
65 self.assertEqual(float(" 3.14 "), 3.14)
66 self.assertRaises(ValueError, float, " 0x3.1 ")
67 self.assertRaises(ValueError, float, " -0x3.p-1 ")
68 self.assertRaises(ValueError, float, " +0x3.p-1 ")
69 self.assertRaises(ValueError, float, "++3.14")
70 self.assertRaises(ValueError, float, "+-3.14")
71 self.assertRaises(ValueError, float, "-+3.14")
72 self.assertRaises(ValueError, float, "--3.14")
73 self.assertRaises(ValueError, float, ".nan")
74 self.assertRaises(ValueError, float, "+.inf")
75 self.assertRaises(ValueError, float, ".")
76 self.assertRaises(ValueError, float, "-.")
77 self.assertRaises(TypeError, float, {})
78 self.assertRaisesRegex(TypeError, "not 'dict'", float, {})
79 # Lone surrogate
80 self.assertRaises(ValueError, float, '\uD8F0')
81 # check that we don't accept alternate exponent markers
82 self.assertRaises(ValueError, float, "-1.7d29")
83 self.assertRaises(ValueError, float, "3D-14")
84 self.assertEqual(float(" \u0663.\u0661\u0664 "), 3.14)
85 self.assertEqual(float("\N{EM SPACE}3.14\N{EN SPACE}"), 3.14)
86 # extra long strings should not be a problem
87 float(b'.' + b'1'*1000)
88 float('.' + '1'*1000)
89 # Invalid unicode string
90 # See bpo-34087
91 self.assertRaises(ValueError, float, '\u3053\u3093\u306b\u3061\u306f')
92
93 def test_noargs(self):
94 self.assertEqual(float(), 0.0)
95
96 def test_underscores(self):
97 for lit in VALID_UNDERSCORE_LITERALS:
98 if not any(ch in lit for ch in 'jJxXoObB'):
99 self.assertEqual(float(lit), eval(lit))
100 self.assertEqual(float(lit), float(lit.replace('_', '')))
101 for lit in INVALID_UNDERSCORE_LITERALS:
102 if lit in ('0_7', '09_99'): # octals are not recognized here
103 continue
104 if not any(ch in lit for ch in 'jJxXoObB'):
105 self.assertRaises(ValueError, float, lit)
106 # Additional test cases; nan and inf are never valid as literals,
107 # only in the float() constructor, but we don't allow underscores
108 # in or around them.
109 self.assertRaises(ValueError, float, '_NaN')
110 self.assertRaises(ValueError, float, 'Na_N')
111 self.assertRaises(ValueError, float, 'IN_F')
112 self.assertRaises(ValueError, float, '-_INF')
113 self.assertRaises(ValueError, float, '-INF_')
114 # Check that we handle bytes values correctly.
115 self.assertRaises(ValueError, float, b'0_.\xff9')
116
117 def test_non_numeric_input_types(self):
118 # Test possible non-numeric types for the argument x, including
119 # subclasses of the explicitly documented accepted types.
120 class CustomStr(str): pass
121 class CustomBytes(bytes): pass
122 class CustomByteArray(bytearray): pass
123
124 factories = [
125 bytes,
126 bytearray,
127 lambda b: CustomStr(b.decode()),
128 CustomBytes,
129 CustomByteArray,
130 memoryview,
131 ]
132 try:
133 from array import array
134 except ImportError:
135 pass
136 else:
137 factories.append(lambda b: array('B', b))
138
139 for f in factories:
140 x = f(b" 3.14 ")
141 with self.subTest(type(x)):
142 self.assertEqual(float(x), 3.14)
143 with self.assertRaisesRegex(ValueError, "could not convert"):
144 float(f(b'A' * 0x10))
145
146 def test_float_memoryview(self):
147 self.assertEqual(float(memoryview(b'12.3')[1:4]), 2.3)
148 self.assertEqual(float(memoryview(b'12.3\x00')[1:4]), 2.3)
149 self.assertEqual(float(memoryview(b'12.3 ')[1:4]), 2.3)
150 self.assertEqual(float(memoryview(b'12.3A')[1:4]), 2.3)
151 self.assertEqual(float(memoryview(b'12.34')[1:4]), 2.3)
152
153 def test_error_message(self):
154 def check(s):
155 with self.assertRaises(ValueError, msg='float(%r)' % (s,)) as cm:
156 float(s)
157 self.assertEqual(str(cm.exception),
158 'could not convert string to float: %r' % (s,))
159
160 check('\xbd')
161 check('123\xbd')
162 check(' 123 456 ')
163 check(b' 123 456 ')
164 # all whitespace (cf. https://github.com/python/cpython/issues/95605)
165 check('')
166 check(' ')
167 check('\t \n')
168
169 # non-ascii digits (error came from non-digit '!')
170 check('\u0663\u0661\u0664!')
171 # embedded NUL
172 check('123\x00')
173 check('123\x00 245')
174 check('123\x00245')
175 # byte string with embedded NUL
176 check(b'123\x00')
177 # non-UTF-8 byte string
178 check(b'123\xa0')
179
180 @support.run_with_locale('LC_NUMERIC', 'fr_FR', 'de_DE', '')
181 def test_float_with_comma(self):
182 # set locale to something that doesn't use '.' for the decimal point
183 # float must not accept the locale specific decimal point but
184 # it still has to accept the normal python syntax
185 import locale
186 if not locale.localeconv()['decimal_point'] == ',':
187 self.skipTest('decimal_point is not ","')
188
189 self.assertEqual(float(" 3.14 "), 3.14)
190 self.assertEqual(float("+3.14 "), 3.14)
191 self.assertEqual(float("-3.14 "), -3.14)
192 self.assertEqual(float(".14 "), .14)
193 self.assertEqual(float("3. "), 3.0)
194 self.assertEqual(float("3.e3 "), 3000.0)
195 self.assertEqual(float("3.2e3 "), 3200.0)
196 self.assertEqual(float("2.5e-1 "), 0.25)
197 self.assertEqual(float("5e-1"), 0.5)
198 self.assertRaises(ValueError, float, " 3,14 ")
199 self.assertRaises(ValueError, float, " +3,14 ")
200 self.assertRaises(ValueError, float, " -3,14 ")
201 self.assertRaises(ValueError, float, " 0x3.1 ")
202 self.assertRaises(ValueError, float, " -0x3.p-1 ")
203 self.assertRaises(ValueError, float, " +0x3.p-1 ")
204 self.assertEqual(float(" 25.e-1 "), 2.5)
205 self.assertAlmostEqual(float(" .25e-1 "), .025)
206
207 def test_floatconversion(self):
208 # Make sure that calls to __float__() work properly
209 class Foo2(float):
210 def __float__(self):
211 return 42.
212
213 class Foo3(float):
214 def __new__(cls, value=0.):
215 return float.__new__(cls, 2*value)
216
217 def __float__(self):
218 return self
219
220 class Foo4(float):
221 def __float__(self):
222 return 42
223
224 # Issue 5759: __float__ not called on str subclasses (though it is on
225 # unicode subclasses).
226 class FooStr(str):
227 def __float__(self):
228 return float(str(self)) + 1
229
230 self.assertEqual(float(FloatLike(42.)), 42.)
231 self.assertEqual(float(Foo2()), 42.)
232 with self.assertWarns(DeprecationWarning):
233 self.assertEqual(float(Foo3(21)), 42.)
234 self.assertRaises(TypeError, float, Foo4(42))
235 self.assertEqual(float(FooStr('8')), 9.)
236
237 self.assertRaises(TypeError, time.sleep, FloatLike(""))
238
239 # Issue #24731
240 f = FloatLike(OtherFloatSubclass(42.))
241 with self.assertWarns(DeprecationWarning):
242 self.assertEqual(float(f), 42.)
243 with self.assertWarns(DeprecationWarning):
244 self.assertIs(type(float(f)), float)
245 with self.assertWarns(DeprecationWarning):
246 self.assertEqual(FloatSubclass(f), 42.)
247 with self.assertWarns(DeprecationWarning):
248 self.assertIs(type(FloatSubclass(f)), FloatSubclass)
249
250 self.assertEqual(float(MyIndex(42)), 42.0)
251 self.assertRaises(OverflowError, float, MyIndex(2**2000))
252 self.assertRaises(TypeError, float, MyInt(42))
253
254 def test_keyword_args(self):
255 with self.assertRaisesRegex(TypeError, 'keyword argument'):
256 float(x='3.14')
257
258 def test_keywords_in_subclass(self):
259 class subclass(float):
260 pass
261 u = subclass(2.5)
262 self.assertIs(type(u), subclass)
263 self.assertEqual(float(u), 2.5)
264 with self.assertRaises(TypeError):
265 subclass(x=0)
266
267 class subclass_with_init(float):
268 def __init__(self, arg, newarg=None):
269 self.newarg = newarg
270 u = subclass_with_init(2.5, newarg=3)
271 self.assertIs(type(u), subclass_with_init)
272 self.assertEqual(float(u), 2.5)
273 self.assertEqual(u.newarg, 3)
274
275 class subclass_with_new(float):
276 def __new__(cls, arg, newarg=None):
277 self = super().__new__(cls, arg)
278 self.newarg = newarg
279 return self
280 u = subclass_with_new(2.5, newarg=3)
281 self.assertIs(type(u), subclass_with_new)
282 self.assertEqual(float(u), 2.5)
283 self.assertEqual(u.newarg, 3)
284
285 def assertEqualAndType(self, actual, expected_value, expected_type):
286 self.assertEqual(actual, expected_value)
287 self.assertIs(type(actual), expected_type)
288
289 def test_from_number(self, cls=float):
290 def eq(actual, expected):
291 self.assertEqual(actual, expected)
292 self.assertIs(type(actual), cls)
293
294 eq(cls.from_number(3.14), 3.14)
295 eq(cls.from_number(314), 314.0)
296 eq(cls.from_number(OtherFloatSubclass(3.14)), 3.14)
297 eq(cls.from_number(FloatLike(3.14)), 3.14)
298 eq(cls.from_number(MyIndex(314)), 314.0)
299
300 x = cls.from_number(NAN)
301 self.assertTrue(x != x)
302 self.assertIs(type(x), cls)
303 if cls is float:
304 self.assertIs(cls.from_number(NAN), NAN)
305
306 self.assertRaises(TypeError, cls.from_number, '3.14')
307 self.assertRaises(TypeError, cls.from_number, b'3.14')
308 self.assertRaises(TypeError, cls.from_number, 3.14j)
309 self.assertRaises(TypeError, cls.from_number, MyInt(314))
310 self.assertRaises(TypeError, cls.from_number, {})
311 self.assertRaises(TypeError, cls.from_number)
312
313 def test_from_number_subclass(self):
314 self.test_from_number(FloatSubclass)
315
316 def test_is_integer(self):
317 self.assertFalse((1.1).is_integer())
318 self.assertTrue((1.).is_integer())
319 self.assertFalse(float("nan").is_integer())
320 self.assertFalse(float("inf").is_integer())
321
322 def test_floatasratio(self):
323 for f, ratio in [
324 (0.875, (7, 8)),
325 (-0.875, (-7, 8)),
326 (0.0, (0, 1)),
327 (11.5, (23, 2)),
328 ]:
329 self.assertEqual(f.as_integer_ratio(), ratio)
330
331 for i in range(10000):
332 f = random.random()
333 f *= 10 ** random.randint(-100, 100)
334 n, d = f.as_integer_ratio()
335 self.assertEqual(float(n).__truediv__(d), f)
336
337 R = fractions.Fraction
338 self.assertEqual(R(0, 1),
339 R(*float(0.0).as_integer_ratio()))
340 self.assertEqual(R(5, 2),
341 R(*float(2.5).as_integer_ratio()))
342 self.assertEqual(R(1, 2),
343 R(*float(0.5).as_integer_ratio()))
344 self.assertEqual(R(4728779608739021, 2251799813685248),
345 R(*float(2.1).as_integer_ratio()))
346 self.assertEqual(R(-4728779608739021, 2251799813685248),
347 R(*float(-2.1).as_integer_ratio()))
348 self.assertEqual(R(-2100, 1),
349 R(*float(-2100.0).as_integer_ratio()))
350
351 self.assertRaises(OverflowError, float('inf').as_integer_ratio)
352 self.assertRaises(OverflowError, float('-inf').as_integer_ratio)
353 self.assertRaises(ValueError, float('nan').as_integer_ratio)
354
355 def test_float_containment(self):
356 floats = (INF, -INF, 0.0, 1.0, NAN)
357 for f in floats:
358 self.assertIn(f, [f])
359 self.assertIn(f, (f,))
360 self.assertIn(f, {f})
361 self.assertIn(f, {f: None})
362 self.assertEqual([f].count(f), 1, "[].count('%r') != 1" % f)
363 self.assertIn(f, floats)
364
365 for f in floats:
366 # nonidentical containers, same type, same contents
367 self.assertTrue([f] == [f], "[%r] != [%r]" % (f, f))
368 self.assertTrue((f,) == (f,), "(%r,) != (%r,)" % (f, f))
369 self.assertTrue({f} == {f}, "{%r} != {%r}" % (f, f))
370 self.assertTrue({f : None} == {f: None}, "{%r : None} != "
371 "{%r : None}" % (f, f))
372
373 # identical containers
374 l, t, s, d = [f], (f,), {f}, {f: None}
375 self.assertTrue(l == l, "[%r] not equal to itself" % f)
376 self.assertTrue(t == t, "(%r,) not equal to itself" % f)
377 self.assertTrue(s == s, "{%r} not equal to itself" % f)
378 self.assertTrue(d == d, "{%r : None} not equal to itself" % f)
379
380 def assertEqualAndEqualSign(self, a, b):
381 # fail unless a == b and a and b have the same sign bit;
382 # the only difference from assertEqual is that this test
383 # distinguishes -0.0 and 0.0.
384 self.assertEqual((a, copysign(1.0, a)), (b, copysign(1.0, b)))
385
386 def test_float_floor(self):
387 self.assertIsInstance(float(0.5).__floor__(), int)
388 self.assertEqual(float(0.5).__floor__(), 0)
389 self.assertEqual(float(1.0).__floor__(), 1)
390 self.assertEqual(float(1.5).__floor__(), 1)
391 self.assertEqual(float(-0.5).__floor__(), -1)
392 self.assertEqual(float(-1.0).__floor__(), -1)
393 self.assertEqual(float(-1.5).__floor__(), -2)
394 self.assertEqual(float(1.23e167).__floor__(), 1.23e167)
395 self.assertEqual(float(-1.23e167).__floor__(), -1.23e167)
396 self.assertRaises(ValueError, float("nan").__floor__)
397 self.assertRaises(OverflowError, float("inf").__floor__)
398 self.assertRaises(OverflowError, float("-inf").__floor__)
399
400 def test_float_ceil(self):
401 self.assertIsInstance(float(0.5).__ceil__(), int)
402 self.assertEqual(float(0.5).__ceil__(), 1)
403 self.assertEqual(float(1.0).__ceil__(), 1)
404 self.assertEqual(float(1.5).__ceil__(), 2)
405 self.assertEqual(float(-0.5).__ceil__(), 0)
406 self.assertEqual(float(-1.0).__ceil__(), -1)
407 self.assertEqual(float(-1.5).__ceil__(), -1)
408 self.assertEqual(float(1.23e167).__ceil__(), 1.23e167)
409 self.assertEqual(float(-1.23e167).__ceil__(), -1.23e167)
410 self.assertRaises(ValueError, float("nan").__ceil__)
411 self.assertRaises(OverflowError, float("inf").__ceil__)
412 self.assertRaises(OverflowError, float("-inf").__ceil__)
413
414 @support.requires_IEEE_754
415 def test_float_mod(self):
416 # Check behaviour of % operator for IEEE 754 special cases.
417 # In particular, check signs of zeros.
418 mod = operator.mod
419
420 self.assertEqualAndEqualSign(mod(-1.0, 1.0), 0.0)
421 self.assertEqualAndEqualSign(mod(-1e-100, 1.0), 1.0)
422 self.assertEqualAndEqualSign(mod(-0.0, 1.0), 0.0)
423 self.assertEqualAndEqualSign(mod(0.0, 1.0), 0.0)
424 self.assertEqualAndEqualSign(mod(1e-100, 1.0), 1e-100)
425 self.assertEqualAndEqualSign(mod(1.0, 1.0), 0.0)
426
427 self.assertEqualAndEqualSign(mod(-1.0, -1.0), -0.0)
428 self.assertEqualAndEqualSign(mod(-1e-100, -1.0), -1e-100)
429 self.assertEqualAndEqualSign(mod(-0.0, -1.0), -0.0)
430 self.assertEqualAndEqualSign(mod(0.0, -1.0), -0.0)
431 self.assertEqualAndEqualSign(mod(1e-100, -1.0), -1.0)
432 self.assertEqualAndEqualSign(mod(1.0, -1.0), -0.0)
433
434 @support.requires_IEEE_754
435 def test_float_pow(self):
436 # test builtin pow and ** operator for IEEE 754 special cases.
437 # Special cases taken from section F.9.4.4 of the C99 specification
438
439 for pow_op in pow, operator.pow:
440 # x**NAN is NAN for any x except 1
441 self.assertTrue(isnan(pow_op(-INF, NAN)))
442 self.assertTrue(isnan(pow_op(-2.0, NAN)))
443 self.assertTrue(isnan(pow_op(-1.0, NAN)))
444 self.assertTrue(isnan(pow_op(-0.5, NAN)))
445 self.assertTrue(isnan(pow_op(-0.0, NAN)))
446 self.assertTrue(isnan(pow_op(0.0, NAN)))
447 self.assertTrue(isnan(pow_op(0.5, NAN)))
448 self.assertTrue(isnan(pow_op(2.0, NAN)))
449 self.assertTrue(isnan(pow_op(INF, NAN)))
450 self.assertTrue(isnan(pow_op(NAN, NAN)))
451
452 # NAN**y is NAN for any y except +-0
453 self.assertTrue(isnan(pow_op(NAN, -INF)))
454 self.assertTrue(isnan(pow_op(NAN, -2.0)))
455 self.assertTrue(isnan(pow_op(NAN, -1.0)))
456 self.assertTrue(isnan(pow_op(NAN, -0.5)))
457 self.assertTrue(isnan(pow_op(NAN, 0.5)))
458 self.assertTrue(isnan(pow_op(NAN, 1.0)))
459 self.assertTrue(isnan(pow_op(NAN, 2.0)))
460 self.assertTrue(isnan(pow_op(NAN, INF)))
461
462 # (+-0)**y raises ZeroDivisionError for y a negative odd integer
463 self.assertRaises(ZeroDivisionError, pow_op, -0.0, -1.0)
464 self.assertRaises(ZeroDivisionError, pow_op, 0.0, -1.0)
465
466 # (+-0)**y raises ZeroDivisionError for y finite and negative
467 # but not an odd integer
468 self.assertRaises(ZeroDivisionError, pow_op, -0.0, -2.0)
469 self.assertRaises(ZeroDivisionError, pow_op, -0.0, -0.5)
470 self.assertRaises(ZeroDivisionError, pow_op, 0.0, -2.0)
471 self.assertRaises(ZeroDivisionError, pow_op, 0.0, -0.5)
472
473 # (+-0)**y is +-0 for y a positive odd integer
474 self.assertEqualAndEqualSign(pow_op(-0.0, 1.0), -0.0)
475 self.assertEqualAndEqualSign(pow_op(0.0, 1.0), 0.0)
476
477 # (+-0)**y is 0 for y finite and positive but not an odd integer
478 self.assertEqualAndEqualSign(pow_op(-0.0, 0.5), 0.0)
479 self.assertEqualAndEqualSign(pow_op(-0.0, 2.0), 0.0)
480 self.assertEqualAndEqualSign(pow_op(0.0, 0.5), 0.0)
481 self.assertEqualAndEqualSign(pow_op(0.0, 2.0), 0.0)
482
483 # (-1)**+-inf is 1
484 self.assertEqualAndEqualSign(pow_op(-1.0, -INF), 1.0)
485 self.assertEqualAndEqualSign(pow_op(-1.0, INF), 1.0)
486
487 # 1**y is 1 for any y, even if y is an infinity or nan
488 self.assertEqualAndEqualSign(pow_op(1.0, -INF), 1.0)
489 self.assertEqualAndEqualSign(pow_op(1.0, -2.0), 1.0)
490 self.assertEqualAndEqualSign(pow_op(1.0, -1.0), 1.0)
491 self.assertEqualAndEqualSign(pow_op(1.0, -0.5), 1.0)
492 self.assertEqualAndEqualSign(pow_op(1.0, -0.0), 1.0)
493 self.assertEqualAndEqualSign(pow_op(1.0, 0.0), 1.0)
494 self.assertEqualAndEqualSign(pow_op(1.0, 0.5), 1.0)
495 self.assertEqualAndEqualSign(pow_op(1.0, 1.0), 1.0)
496 self.assertEqualAndEqualSign(pow_op(1.0, 2.0), 1.0)
497 self.assertEqualAndEqualSign(pow_op(1.0, INF), 1.0)
498 self.assertEqualAndEqualSign(pow_op(1.0, NAN), 1.0)
499
500 # x**+-0 is 1 for any x, even if x is a zero, infinity, or nan
501 self.assertEqualAndEqualSign(pow_op(-INF, 0.0), 1.0)
502 self.assertEqualAndEqualSign(pow_op(-2.0, 0.0), 1.0)
503 self.assertEqualAndEqualSign(pow_op(-1.0, 0.0), 1.0)
504 self.assertEqualAndEqualSign(pow_op(-0.5, 0.0), 1.0)
505 self.assertEqualAndEqualSign(pow_op(-0.0, 0.0), 1.0)
506 self.assertEqualAndEqualSign(pow_op(0.0, 0.0), 1.0)
507 self.assertEqualAndEqualSign(pow_op(0.5, 0.0), 1.0)
508 self.assertEqualAndEqualSign(pow_op(1.0, 0.0), 1.0)
509 self.assertEqualAndEqualSign(pow_op(2.0, 0.0), 1.0)
510 self.assertEqualAndEqualSign(pow_op(INF, 0.0), 1.0)
511 self.assertEqualAndEqualSign(pow_op(NAN, 0.0), 1.0)
512 self.assertEqualAndEqualSign(pow_op(-INF, -0.0), 1.0)
513 self.assertEqualAndEqualSign(pow_op(-2.0, -0.0), 1.0)
514 self.assertEqualAndEqualSign(pow_op(-1.0, -0.0), 1.0)
515 self.assertEqualAndEqualSign(pow_op(-0.5, -0.0), 1.0)
516 self.assertEqualAndEqualSign(pow_op(-0.0, -0.0), 1.0)
517 self.assertEqualAndEqualSign(pow_op(0.0, -0.0), 1.0)
518 self.assertEqualAndEqualSign(pow_op(0.5, -0.0), 1.0)
519 self.assertEqualAndEqualSign(pow_op(1.0, -0.0), 1.0)
520 self.assertEqualAndEqualSign(pow_op(2.0, -0.0), 1.0)
521 self.assertEqualAndEqualSign(pow_op(INF, -0.0), 1.0)
522 self.assertEqualAndEqualSign(pow_op(NAN, -0.0), 1.0)
523
524 # x**y defers to complex pow for finite negative x and
525 # non-integral y.
526 self.assertEqual(type(pow_op(-2.0, -0.5)), complex)
527 self.assertEqual(type(pow_op(-2.0, 0.5)), complex)
528 self.assertEqual(type(pow_op(-1.0, -0.5)), complex)
529 self.assertEqual(type(pow_op(-1.0, 0.5)), complex)
530 self.assertEqual(type(pow_op(-0.5, -0.5)), complex)
531 self.assertEqual(type(pow_op(-0.5, 0.5)), complex)
532
533 # x**-INF is INF for abs(x) < 1
534 self.assertEqualAndEqualSign(pow_op(-0.5, -INF), INF)
535 self.assertEqualAndEqualSign(pow_op(-0.0, -INF), INF)
536 self.assertEqualAndEqualSign(pow_op(0.0, -INF), INF)
537 self.assertEqualAndEqualSign(pow_op(0.5, -INF), INF)
538
539 # x**-INF is 0 for abs(x) > 1
540 self.assertEqualAndEqualSign(pow_op(-INF, -INF), 0.0)
541 self.assertEqualAndEqualSign(pow_op(-2.0, -INF), 0.0)
542 self.assertEqualAndEqualSign(pow_op(2.0, -INF), 0.0)
543 self.assertEqualAndEqualSign(pow_op(INF, -INF), 0.0)
544
545 # x**INF is 0 for abs(x) < 1
546 self.assertEqualAndEqualSign(pow_op(-0.5, INF), 0.0)
547 self.assertEqualAndEqualSign(pow_op(-0.0, INF), 0.0)
548 self.assertEqualAndEqualSign(pow_op(0.0, INF), 0.0)
549 self.assertEqualAndEqualSign(pow_op(0.5, INF), 0.0)
550
551 # x**INF is INF for abs(x) > 1
552 self.assertEqualAndEqualSign(pow_op(-INF, INF), INF)
553 self.assertEqualAndEqualSign(pow_op(-2.0, INF), INF)
554 self.assertEqualAndEqualSign(pow_op(2.0, INF), INF)
555 self.assertEqualAndEqualSign(pow_op(INF, INF), INF)
556
557 # (-INF)**y is -0.0 for y a negative odd integer
558 self.assertEqualAndEqualSign(pow_op(-INF, -1.0), -0.0)
559
560 # (-INF)**y is 0.0 for y negative but not an odd integer
561 self.assertEqualAndEqualSign(pow_op(-INF, -0.5), 0.0)
562 self.assertEqualAndEqualSign(pow_op(-INF, -2.0), 0.0)
563
564 # (-INF)**y is -INF for y a positive odd integer
565 self.assertEqualAndEqualSign(pow_op(-INF, 1.0), -INF)
566
567 # (-INF)**y is INF for y positive but not an odd integer
568 self.assertEqualAndEqualSign(pow_op(-INF, 0.5), INF)
569 self.assertEqualAndEqualSign(pow_op(-INF, 2.0), INF)
570
571 # INF**y is INF for y positive
572 self.assertEqualAndEqualSign(pow_op(INF, 0.5), INF)
573 self.assertEqualAndEqualSign(pow_op(INF, 1.0), INF)
574 self.assertEqualAndEqualSign(pow_op(INF, 2.0), INF)
575
576 # INF**y is 0.0 for y negative
577 self.assertEqualAndEqualSign(pow_op(INF, -2.0), 0.0)
578 self.assertEqualAndEqualSign(pow_op(INF, -1.0), 0.0)
579 self.assertEqualAndEqualSign(pow_op(INF, -0.5), 0.0)
580
581 # basic checks not covered by the special cases above
582 self.assertEqualAndEqualSign(pow_op(-2.0, -2.0), 0.25)
583 self.assertEqualAndEqualSign(pow_op(-2.0, -1.0), -0.5)
584 self.assertEqualAndEqualSign(pow_op(-2.0, -0.0), 1.0)
585 self.assertEqualAndEqualSign(pow_op(-2.0, 0.0), 1.0)
586 self.assertEqualAndEqualSign(pow_op(-2.0, 1.0), -2.0)
587 self.assertEqualAndEqualSign(pow_op(-2.0, 2.0), 4.0)
588 self.assertEqualAndEqualSign(pow_op(-1.0, -2.0), 1.0)
589 self.assertEqualAndEqualSign(pow_op(-1.0, -1.0), -1.0)
590 self.assertEqualAndEqualSign(pow_op(-1.0, -0.0), 1.0)
591 self.assertEqualAndEqualSign(pow_op(-1.0, 0.0), 1.0)
592 self.assertEqualAndEqualSign(pow_op(-1.0, 1.0), -1.0)
593 self.assertEqualAndEqualSign(pow_op(-1.0, 2.0), 1.0)
594 self.assertEqualAndEqualSign(pow_op(2.0, -2.0), 0.25)
595 self.assertEqualAndEqualSign(pow_op(2.0, -1.0), 0.5)
596 self.assertEqualAndEqualSign(pow_op(2.0, -0.0), 1.0)
597 self.assertEqualAndEqualSign(pow_op(2.0, 0.0), 1.0)
598 self.assertEqualAndEqualSign(pow_op(2.0, 1.0), 2.0)
599 self.assertEqualAndEqualSign(pow_op(2.0, 2.0), 4.0)
600
601 # 1 ** large and -1 ** large; some libms apparently
602 # have problems with these
603 self.assertEqualAndEqualSign(pow_op(1.0, -1e100), 1.0)
604 self.assertEqualAndEqualSign(pow_op(1.0, 1e100), 1.0)
605 self.assertEqualAndEqualSign(pow_op(-1.0, -1e100), 1.0)
606 self.assertEqualAndEqualSign(pow_op(-1.0, 1e100), 1.0)
607
608 # check sign for results that underflow to 0
609 self.assertEqualAndEqualSign(pow_op(-2.0, -2000.0), 0.0)
610 self.assertEqual(type(pow_op(-2.0, -2000.5)), complex)
611 self.assertEqualAndEqualSign(pow_op(-2.0, -2001.0), -0.0)
612 self.assertEqualAndEqualSign(pow_op(2.0, -2000.0), 0.0)
613 self.assertEqualAndEqualSign(pow_op(2.0, -2000.5), 0.0)
614 self.assertEqualAndEqualSign(pow_op(2.0, -2001.0), 0.0)
615 self.assertEqualAndEqualSign(pow_op(-0.5, 2000.0), 0.0)
616 self.assertEqual(type(pow_op(-0.5, 2000.5)), complex)
617 self.assertEqualAndEqualSign(pow_op(-0.5, 2001.0), -0.0)
618 self.assertEqualAndEqualSign(pow_op(0.5, 2000.0), 0.0)
619 self.assertEqualAndEqualSign(pow_op(0.5, 2000.5), 0.0)
620 self.assertEqualAndEqualSign(pow_op(0.5, 2001.0), 0.0)
621
622 # check we don't raise an exception for subnormal results,
623 # and validate signs. Tests currently disabled, since
624 # they fail on systems where a subnormal result from pow
625 # is flushed to zero (e.g. Debian/ia64.)
626 #self.assertTrue(0.0 < pow_op(0.5, 1048) < 1e-315)
627 #self.assertTrue(0.0 < pow_op(-0.5, 1048) < 1e-315)
628 #self.assertTrue(0.0 < pow_op(0.5, 1047) < 1e-315)
629 #self.assertTrue(0.0 > pow_op(-0.5, 1047) > -1e-315)
630 #self.assertTrue(0.0 < pow_op(2.0, -1048) < 1e-315)
631 #self.assertTrue(0.0 < pow_op(-2.0, -1048) < 1e-315)
632 #self.assertTrue(0.0 < pow_op(2.0, -1047) < 1e-315)
633 #self.assertTrue(0.0 > pow_op(-2.0, -1047) > -1e-315)
634
635 def test_hash(self):
636 for x in range(-30, 30):
637 self.assertEqual(hash(float(x)), hash(x))
638 self.assertEqual(hash(float(sys.float_info.max)),
639 hash(int(sys.float_info.max)))
640 self.assertEqual(hash(float('inf')), sys.hash_info.inf)
641 self.assertEqual(hash(float('-inf')), -sys.hash_info.inf)
642
643 def test_hash_nan(self):
644 value = float('nan')
645 self.assertEqual(hash(value), object.__hash__(value))
646 class H:
647 def __hash__(self):
648 return 42
649 class F(float, H):
650 pass
651 value = F('nan')
652 self.assertEqual(hash(value), object.__hash__(value))
653
654 def test_issue_gh143006(self):
655 # When comparing negative non-integer float and int with the
656 # same number of bits in the integer part, __neg__() in the
657 # int subclass returning not an int caused an assertion error.
658 class EvilInt(int):
659 def __neg__(self):
660 return ""
661
662 i = -1 << 50
663 f = float(i) - 0.5
664 i = EvilInt(i)
665 self.assertFalse(f == i)
666 self.assertTrue(f != i)
667 self.assertTrue(f < i)
668 self.assertTrue(f <= i)
669 self.assertFalse(f > i)
670 self.assertFalse(f >= i)
671
672
673 @unittest.skipUnless(hasattr(float, "__getformat__"), "requires __getformat__")
674 class FormatFunctionsTestCase(unittest.TestCase):
675 def test_getformat(self):
676 self.assertIn(float.__getformat__('double'),
677 ['unknown', 'IEEE, big-endian', 'IEEE, little-endian'])
678 self.assertIn(float.__getformat__('float'),
679 ['unknown', 'IEEE, big-endian', 'IEEE, little-endian'])
680 self.assertRaises(ValueError, float.__getformat__, 'chicken')
681 self.assertRaises(TypeError, float.__getformat__, 1)
682
683
684 BE_DOUBLE_INF = b'\x7f\xf0\x00\x00\x00\x00\x00\x00'
685 LE_DOUBLE_INF = bytes(reversed(BE_DOUBLE_INF))
686 BE_DOUBLE_NAN = b'\x7f\xf8\x00\x00\x00\x00\x00\x00'
687 LE_DOUBLE_NAN = bytes(reversed(BE_DOUBLE_NAN))
688
689 BE_FLOAT_INF = b'\x7f\x80\x00\x00'
690 LE_FLOAT_INF = bytes(reversed(BE_FLOAT_INF))
691 BE_FLOAT_NAN = b'\x7f\xc0\x00\x00'
692 LE_FLOAT_NAN = bytes(reversed(BE_FLOAT_NAN))
693
694 # on an IEEE platform, all we guarantee is that bit patterns
695 # representing infinities or NaNs do not raise an exception; all else
696 # is accident (today).
697 # let's also try to guarantee that -0.0 and 0.0 don't get confused.
698
699 class IEEEFormatTestCase(unittest.TestCase):
700
701 @support.requires_IEEE_754
702 def test_double_specials_do_unpack(self):
703 for fmt, data in [('>d', BE_DOUBLE_INF),
704 ('>d', BE_DOUBLE_NAN),
705 ('<d', LE_DOUBLE_INF),
706 ('<d', LE_DOUBLE_NAN)]:
707 struct.unpack(fmt, data)
708
709 @support.requires_IEEE_754
710 def test_float_specials_do_unpack(self):
711 for fmt, data in [('>f', BE_FLOAT_INF),
712 ('>f', BE_FLOAT_NAN),
713 ('<f', LE_FLOAT_INF),
714 ('<f', LE_FLOAT_NAN)]:
715 struct.unpack(fmt, data)
716
717 @support.requires_IEEE_754
718 @unittest.skipIf(_testcapi is None, 'needs _testcapi')
719 def test_serialized_float_rounding(self):
720 FLT_MAX = _testcapi.FLT_MAX
721 self.assertEqual(struct.pack("<f", 3.40282356e38), struct.pack("<f", FLT_MAX))
722 self.assertEqual(struct.pack("<f", -3.40282356e38), struct.pack("<f", -FLT_MAX))
723
724 class FormatTestCase(unittest.TestCase):
725
726 def test_format(self):
727 # these should be rewritten to use both format(x, spec) and
728 # x.__format__(spec)
729
730 self.assertEqual(format(0.0, 'f'), '0.000000')
731
732 # the default is 'g', except for empty format spec
733 self.assertEqual(format(0.0, ''), '0.0')
734 self.assertEqual(format(0.01, ''), '0.01')
735 self.assertEqual(format(0.01, 'g'), '0.01')
736
737 # empty presentation type should format in the same way as str
738 # (issue 5920)
739 x = 100/7.
740 self.assertEqual(format(x, ''), str(x))
741 self.assertEqual(format(x, '-'), str(x))
742 self.assertEqual(format(x, '>'), str(x))
743 self.assertEqual(format(x, '2'), str(x))
744
745 self.assertEqual(format(1.0, 'f'), '1.000000')
746
747 self.assertEqual(format(-1.0, 'f'), '-1.000000')
748
749 self.assertEqual(format( 1.0, ' f'), ' 1.000000')
750 self.assertEqual(format(-1.0, ' f'), '-1.000000')
751 self.assertEqual(format( 1.0, '+f'), '+1.000000')
752 self.assertEqual(format(-1.0, '+f'), '-1.000000')
753
754 # % formatting
755 self.assertEqual(format(-1.0, '%'), '-100.000000%')
756
757 # conversion to string should fail
758 self.assertRaises(ValueError, format, 3.0, "s")
759
760 # confirm format options expected to fail on floats, such as integer
761 # presentation types
762 for format_spec in 'sbcdoxX':
763 self.assertRaises(ValueError, format, 0.0, format_spec)
764 self.assertRaises(ValueError, format, 1.0, format_spec)
765 self.assertRaises(ValueError, format, -1.0, format_spec)
766 self.assertRaises(ValueError, format, 1e100, format_spec)
767 self.assertRaises(ValueError, format, -1e100, format_spec)
768 self.assertRaises(ValueError, format, 1e-100, format_spec)
769 self.assertRaises(ValueError, format, -1e-100, format_spec)
770
771 # issue 3382
772 self.assertEqual(format(NAN, 'f'), 'nan')
773 self.assertEqual(format(NAN, 'F'), 'NAN')
774 self.assertEqual(format(INF, 'f'), 'inf')
775 self.assertEqual(format(INF, 'F'), 'INF')
776
777 # thousands separators
778 x = 123_456.123_456
779 self.assertEqual(format(x, '_f'), '123_456.123456')
780 self.assertEqual(format(x, ',f'), '123,456.123456')
781 self.assertEqual(format(x, '._f'), '123456.123_456')
782 self.assertEqual(format(x, '.,f'), '123456.123,456')
783 self.assertEqual(format(x, '_._f'), '123_456.123_456')
784 self.assertEqual(format(x, ',.,f'), '123,456.123,456')
785 self.assertEqual(format(x, '.10_f'), '123456.123_456_000_0')
786 self.assertEqual(format(x, '.10,f'), '123456.123,456,000,0')
787 self.assertEqual(format(x, '>21._f'), ' 123456.123_456')
788 self.assertEqual(format(x, '<21._f'), '123456.123_456 ')
789 self.assertEqual(format(x, '+.11_e'), '+1.234_561_234_56e+05')
790 self.assertEqual(format(x, '+.11,e'), '+1.234,561,234,56e+05')
791 self.assertEqual(format(x, '021_._f'), '0_000_123_456.123_456')
792 self.assertEqual(format(x, '020_._f'), '0_000_123_456.123_456')
793 self.assertEqual(format(x, '+021_._f'), '+0_000_123_456.123_456')
794 self.assertEqual(format(x, '21_._f'), ' 123_456.123_456')
795 self.assertEqual(format(x, '>021_._f'), '000000123_456.123_456')
796 self.assertEqual(format(x, '<021_._f'), '123_456.123_456000000')
797 self.assertEqual(format(x, '023_.10_f'), '0_123_456.123_456_000_0')
798 self.assertEqual(format(x, '022_.10_f'), '0_123_456.123_456_000_0')
799 self.assertEqual(format(x, '+023_.10_f'), '+0_123_456.123_456_000_0')
800 self.assertEqual(format(x, '023_.9_f'), '000_123_456.123_456_000')
801 self.assertEqual(format(x, '021_._e'), '0_000_001.234_561e+05')
802 self.assertEqual(format(x, '020_._e'), '0_000_001.234_561e+05')
803 self.assertEqual(format(x, '+021_._e'), '+0_000_001.234_561e+05')
804 self.assertEqual(format(x, '023_.10_e'), '0_001.234_561_234_6e+05')
805 self.assertEqual(format(x, '022_.10_e'), '0_001.234_561_234_6e+05')
806 self.assertEqual(format(x, '023_.9_e'), '000_001.234_561_235e+05')
807
808 self.assertRaises(ValueError, format, x, '._6f')
809 self.assertRaises(ValueError, format, x, '.,_f')
810 self.assertRaises(ValueError, format, x, '.6,_f')
811 self.assertRaises(ValueError, format, x, '.6_,f')
812 self.assertRaises(ValueError, format, x, '.6_n')
813 self.assertRaises(ValueError, format, x, '.6,n')
814
815 @support.requires_IEEE_754
816 @unittest.skipUnless(sys.float_repr_style == 'short',
817 "applies only when using short float repr style")
818 def test_format_testfile(self):
819 with open(format_testfile, encoding="utf-8") as testfile:
820 for line in testfile:
821 if line.startswith('--'):
822 continue
823 line = line.strip()
824 if not line:
825 continue
826
827 lhs, rhs = map(str.strip, line.split('->'))
828 fmt, arg = lhs.split()
829 f = float(arg)
830 self.assertEqual(fmt % f, rhs)
831 self.assertEqual(fmt % -f, '-' + rhs)
832 if fmt != '%r':
833 fmt2 = fmt[1:]
834 self.assertEqual(format(f, fmt2), rhs)
835 self.assertEqual(format(-f, fmt2), '-' + rhs)
836
837 def test_issue5864(self):
838 self.assertEqual(format(123.456, '.4'), '123.5')
839 self.assertEqual(format(1234.56, '.4'), '1.235e+03')
840 self.assertEqual(format(12345.6, '.4'), '1.235e+04')
841
842 def test_issue35560(self):
843 self.assertEqual(format(123.0, '00'), '123.0')
844 self.assertEqual(format(123.34, '00f'), '123.340000')
845 self.assertEqual(format(123.34, '00e'), '1.233400e+02')
846 self.assertEqual(format(123.34, '00g'), '123.34')
847 self.assertEqual(format(123.34, '00.10f'), '123.3400000000')
848 self.assertEqual(format(123.34, '00.10e'), '1.2334000000e+02')
849 self.assertEqual(format(123.34, '00.10g'), '123.34')
850 self.assertEqual(format(123.34, '01f'), '123.340000')
851
852 self.assertEqual(format(-123.0, '00'), '-123.0')
853 self.assertEqual(format(-123.34, '00f'), '-123.340000')
854 self.assertEqual(format(-123.34, '00e'), '-1.233400e+02')
855 self.assertEqual(format(-123.34, '00g'), '-123.34')
856 self.assertEqual(format(-123.34, '00.10f'), '-123.3400000000')
857 self.assertEqual(format(-123.34, '00.10f'), '-123.3400000000')
858 self.assertEqual(format(-123.34, '00.10e'), '-1.2334000000e+02')
859 self.assertEqual(format(-123.34, '00.10g'), '-123.34')
860
861 class ReprTestCase(unittest.TestCase):
862 def test_repr(self):
863 with open(os.path.join(os.path.split(__file__)[0],
864 'mathdata',
865 'floating_points.txt'), encoding="utf-8") as floats_file:
866 for line in floats_file:
867 line = line.strip()
868 if not line or line.startswith('#'):
869 continue
870 v = eval(line)
871 self.assertEqual(v, eval(repr(v)))
872
873 @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
874 "applies only when using short float repr style")
875 def test_short_repr(self):
876 # test short float repr introduced in Python 3.1. One aspect
877 # of this repr is that we get some degree of str -> float ->
878 # str roundtripping. In particular, for any numeric string
879 # containing 15 or fewer significant digits, those exact same
880 # digits (modulo trailing zeros) should appear in the output.
881 # No more repr(0.03) -> "0.029999999999999999"!
882
883 test_strings = [
884 # output always includes *either* a decimal point and at
885 # least one digit after that point, or an exponent.
886 '0.0',
887 '1.0',
888 '0.01',
889 '0.02',
890 '0.03',
891 '0.04',
892 '0.05',
893 '1.23456789',
894 '10.0',
895 '100.0',
896 # values >= 1e16 get an exponent...
897 '1000000000000000.0',
898 '9999999999999990.0',
899 '1e+16',
900 '1e+17',
901 # ... and so do values < 1e-4
902 '0.001',
903 '0.001001',
904 '0.00010000000000001',
905 '0.0001',
906 '9.999999999999e-05',
907 '1e-05',
908 # values designed to provoke failure if the FPU rounding
909 # precision isn't set correctly
910 '8.72293771110361e+25',
911 '7.47005307342313e+26',
912 '2.86438000439698e+28',
913 '8.89142905246179e+28',
914 '3.08578087079232e+35',
915 ]
916
917 for s in test_strings:
918 negs = '-'+s
919 self.assertEqual(s, repr(float(s)))
920 self.assertEqual(negs, repr(float(negs)))
921 # Since Python 3.2, repr and str are identical
922 self.assertEqual(repr(float(s)), str(float(s)))
923 self.assertEqual(repr(float(negs)), str(float(negs)))
924
925 @support.requires_IEEE_754
926 class RoundTestCase(unittest.TestCase, FloatsAreIdenticalMixin):
927
928 def test_inf_nan(self):
929 self.assertRaises(OverflowError, round, INF)
930 self.assertRaises(OverflowError, round, -INF)
931 self.assertRaises(ValueError, round, NAN)
932 self.assertRaises(TypeError, round, INF, 0.0)
933 self.assertRaises(TypeError, round, -INF, 1.0)
934 self.assertRaises(TypeError, round, NAN, "ceci n'est pas un integer")
935 self.assertRaises(TypeError, round, -0.0, 1j)
936
937 def test_inf_nan_ndigits(self):
938 self.assertEqual(round(INF, 0), INF)
939 self.assertEqual(round(-INF, 0), -INF)
940 self.assertTrue(math.isnan(round(NAN, 0)))
941
942 def test_large_n(self):
943 for n in [324, 325, 400, 2**31-1, 2**31, 2**32, 2**100]:
944 self.assertEqual(round(123.456, n), 123.456)
945 self.assertEqual(round(-123.456, n), -123.456)
946 self.assertEqual(round(1e300, n), 1e300)
947 self.assertEqual(round(1e-320, n), 1e-320)
948 self.assertEqual(round(1e150, 300), 1e150)
949 self.assertEqual(round(1e300, 307), 1e300)
950 self.assertEqual(round(-3.1415, 308), -3.1415)
951 self.assertEqual(round(1e150, 309), 1e150)
952 self.assertEqual(round(1.4e-315, 315), 1e-315)
953
954 def test_small_n(self):
955 for n in [-308, -309, -400, 1-2**31, -2**31, -2**31-1, -2**100]:
956 self.assertFloatsAreIdentical(round(123.456, n), 0.0)
957 self.assertFloatsAreIdentical(round(-123.456, n), -0.0)
958 self.assertFloatsAreIdentical(round(1e300, n), 0.0)
959 self.assertFloatsAreIdentical(round(1e-320, n), 0.0)
960
961 def test_overflow(self):
962 self.assertRaises(OverflowError, round, 1.6e308, -308)
963 self.assertRaises(OverflowError, round, -1.7e308, -308)
964
965 @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
966 "applies only when using short float repr style")
967 def test_previous_round_bugs(self):
968 # particular cases that have occurred in bug reports
969 self.assertEqual(round(562949953421312.5, 1),
970 562949953421312.5)
971 self.assertEqual(round(56294995342131.5, 3),
972 56294995342131.5)
973 # round-half-even
974 self.assertEqual(round(25.0, -1), 20.0)
975 self.assertEqual(round(35.0, -1), 40.0)
976 self.assertEqual(round(45.0, -1), 40.0)
977 self.assertEqual(round(55.0, -1), 60.0)
978 self.assertEqual(round(65.0, -1), 60.0)
979 self.assertEqual(round(75.0, -1), 80.0)
980 self.assertEqual(round(85.0, -1), 80.0)
981 self.assertEqual(round(95.0, -1), 100.0)
982
983 @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short',
984 "applies only when using short float repr style")
985 def test_matches_float_format(self):
986 # round should give the same results as float formatting
987 for i in range(500):
988 x = i/1000.
989 self.assertEqual(float(format(x, '.0f')), round(x, 0))
990 self.assertEqual(float(format(x, '.1f')), round(x, 1))
991 self.assertEqual(float(format(x, '.2f')), round(x, 2))
992 self.assertEqual(float(format(x, '.3f')), round(x, 3))
993
994 for i in range(5, 5000, 10):
995 x = i/1000.
996 self.assertEqual(float(format(x, '.0f')), round(x, 0))
997 self.assertEqual(float(format(x, '.1f')), round(x, 1))
998 self.assertEqual(float(format(x, '.2f')), round(x, 2))
999 self.assertEqual(float(format(x, '.3f')), round(x, 3))
1000
1001 for i in range(500):
1002 x = random.random()
1003 self.assertEqual(float(format(x, '.0f')), round(x, 0))
1004 self.assertEqual(float(format(x, '.1f')), round(x, 1))
1005 self.assertEqual(float(format(x, '.2f')), round(x, 2))
1006 self.assertEqual(float(format(x, '.3f')), round(x, 3))
1007
1008 def test_format_specials(self):
1009 # Test formatting of nans and infs.
1010
1011 def test(fmt, value, expected):
1012 # Test with both % and format().
1013 self.assertEqual(fmt % value, expected, fmt)
1014 fmt = fmt[1:] # strip off the %
1015 self.assertEqual(format(value, fmt), expected, fmt)
1016
1017 for fmt in ['%e', '%f', '%g', '%.0e', '%.6f', '%.20g',
1018 '%#e', '%#f', '%#g', '%#.20e', '%#.15f', '%#.3g']:
1019 pfmt = '%+' + fmt[1:]
1020 sfmt = '% ' + fmt[1:]
1021 test(fmt, INF, 'inf')
1022 test(fmt, -INF, '-inf')
1023 test(fmt, NAN, 'nan')
1024 test(fmt, -NAN, 'nan')
1025 # When asking for a sign, it's always provided. nans are
1026 # always positive.
1027 test(pfmt, INF, '+inf')
1028 test(pfmt, -INF, '-inf')
1029 test(pfmt, NAN, '+nan')
1030 test(pfmt, -NAN, '+nan')
1031 # When using ' ' for a sign code, only infs can be negative.
1032 # Others have a space.
1033 test(sfmt, INF, ' inf')
1034 test(sfmt, -INF, '-inf')
1035 test(sfmt, NAN, ' nan')
1036 test(sfmt, -NAN, ' nan')
1037
1038 def test_None_ndigits(self):
1039 for x in round(1.23), round(1.23, None), round(1.23, ndigits=None):
1040 self.assertEqual(x, 1)
1041 self.assertIsInstance(x, int)
1042 for x in round(1.78), round(1.78, None), round(1.78, ndigits=None):
1043 self.assertEqual(x, 2)
1044 self.assertIsInstance(x, int)
1045
1046 @support.cpython_only
1047 def test_round_with_none_arg_direct_call(self):
1048 for val in [(1.0).__round__(None),
1049 round(1.0),
1050 round(1.0, None)]:
1051 self.assertEqual(val, 1)
1052 self.assertIs(type(val), int)
1053
1054 # Beginning with Python 2.6 float has cross platform compatible
1055 # ways to create and represent inf and nan
1056 class InfNanTest(unittest.TestCase):
1057 def test_inf_from_str(self):
1058 self.assertTrue(isinf(float("inf")))
1059 self.assertTrue(isinf(float("+inf")))
1060 self.assertTrue(isinf(float("-inf")))
1061 self.assertTrue(isinf(float("infinity")))
1062 self.assertTrue(isinf(float("+infinity")))
1063 self.assertTrue(isinf(float("-infinity")))
1064
1065 self.assertEqual(repr(float("inf")), "inf")
1066 self.assertEqual(repr(float("+inf")), "inf")
1067 self.assertEqual(repr(float("-inf")), "-inf")
1068 self.assertEqual(repr(float("infinity")), "inf")
1069 self.assertEqual(repr(float("+infinity")), "inf")
1070 self.assertEqual(repr(float("-infinity")), "-inf")
1071
1072 self.assertEqual(repr(float("INF")), "inf")
1073 self.assertEqual(repr(float("+Inf")), "inf")
1074 self.assertEqual(repr(float("-iNF")), "-inf")
1075 self.assertEqual(repr(float("Infinity")), "inf")
1076 self.assertEqual(repr(float("+iNfInItY")), "inf")
1077 self.assertEqual(repr(float("-INFINITY")), "-inf")
1078
1079 self.assertEqual(str(float("inf")), "inf")
1080 self.assertEqual(str(float("+inf")), "inf")
1081 self.assertEqual(str(float("-inf")), "-inf")
1082 self.assertEqual(str(float("infinity")), "inf")
1083 self.assertEqual(str(float("+infinity")), "inf")
1084 self.assertEqual(str(float("-infinity")), "-inf")
1085
1086 self.assertRaises(ValueError, float, "info")
1087 self.assertRaises(ValueError, float, "+info")
1088 self.assertRaises(ValueError, float, "-info")
1089 self.assertRaises(ValueError, float, "in")
1090 self.assertRaises(ValueError, float, "+in")
1091 self.assertRaises(ValueError, float, "-in")
1092 self.assertRaises(ValueError, float, "infinit")
1093 self.assertRaises(ValueError, float, "+Infin")
1094 self.assertRaises(ValueError, float, "-INFI")
1095 self.assertRaises(ValueError, float, "infinitys")
1096
1097 self.assertRaises(ValueError, float, "++Inf")
1098 self.assertRaises(ValueError, float, "-+inf")
1099 self.assertRaises(ValueError, float, "+-infinity")
1100 self.assertRaises(ValueError, float, "--Infinity")
1101
1102 def test_inf_as_str(self):
1103 self.assertEqual(repr(1e300 * 1e300), "inf")
1104 self.assertEqual(repr(-1e300 * 1e300), "-inf")
1105
1106 self.assertEqual(str(1e300 * 1e300), "inf")
1107 self.assertEqual(str(-1e300 * 1e300), "-inf")
1108
1109 def test_nan_from_str(self):
1110 self.assertTrue(isnan(float("nan")))
1111 self.assertTrue(isnan(float("+nan")))
1112 self.assertTrue(isnan(float("-nan")))
1113
1114 self.assertEqual(repr(float("nan")), "nan")
1115 self.assertEqual(repr(float("+nan")), "nan")
1116 self.assertEqual(repr(float("-nan")), "nan")
1117
1118 self.assertEqual(repr(float("NAN")), "nan")
1119 self.assertEqual(repr(float("+NAn")), "nan")
1120 self.assertEqual(repr(float("-NaN")), "nan")
1121
1122 self.assertEqual(str(float("nan")), "nan")
1123 self.assertEqual(str(float("+nan")), "nan")
1124 self.assertEqual(str(float("-nan")), "nan")
1125
1126 self.assertRaises(ValueError, float, "nana")
1127 self.assertRaises(ValueError, float, "+nana")
1128 self.assertRaises(ValueError, float, "-nana")
1129 self.assertRaises(ValueError, float, "na")
1130 self.assertRaises(ValueError, float, "+na")
1131 self.assertRaises(ValueError, float, "-na")
1132
1133 self.assertRaises(ValueError, float, "++nan")
1134 self.assertRaises(ValueError, float, "-+NAN")
1135 self.assertRaises(ValueError, float, "+-NaN")
1136 self.assertRaises(ValueError, float, "--nAn")
1137
1138 def test_nan_as_str(self):
1139 self.assertEqual(repr(1e300 * 1e300 * 0), "nan")
1140 self.assertEqual(repr(-1e300 * 1e300 * 0), "nan")
1141
1142 self.assertEqual(str(1e300 * 1e300 * 0), "nan")
1143 self.assertEqual(str(-1e300 * 1e300 * 0), "nan")
1144
1145 def test_inf_signs(self):
1146 self.assertEqual(copysign(1.0, float('inf')), 1.0)
1147 self.assertEqual(copysign(1.0, float('-inf')), -1.0)
1148
1149 def test_nan_signs(self):
1150 # The sign of float('nan') should be predictable.
1151 self.assertEqual(copysign(1.0, float('nan')), 1.0)
1152 self.assertEqual(copysign(1.0, float('-nan')), -1.0)
1153
1154
1155 fromHex = float.fromhex
1156 toHex = float.hex
1157 class HexFloatTestCase(FloatsAreIdenticalMixin, unittest.TestCase):
1158 MAX = fromHex('0x.fffffffffffff8p+1024') # max normal
1159 MIN = fromHex('0x1p-1022') # min normal
1160 TINY = fromHex('0x0.0000000000001p-1022') # min subnormal
1161 EPS = fromHex('0x0.0000000000001p0') # diff between 1.0 and next float up
1162
1163 def identical(self, x, y):
1164 self.assertFloatsAreIdentical(x, y)
1165
1166 def test_ends(self):
1167 self.identical(self.MIN, ldexp(1.0, -1022))
1168 self.identical(self.TINY, ldexp(1.0, -1074))
1169 self.identical(self.EPS, ldexp(1.0, -52))
1170 self.identical(self.MAX, 2.*(ldexp(1.0, 1023) - ldexp(1.0, 970)))
1171
1172 def test_invalid_inputs(self):
1173 invalid_inputs = [
1174 'infi', # misspelt infinities and nans
1175 '-Infinit',
1176 '++inf',
1177 '-+Inf',
1178 '--nan',
1179 '+-NaN',
1180 'snan',
1181 'NaNs',
1182 'nna',
1183 'an',
1184 'nf',
1185 'nfinity',
1186 'inity',
1187 'iinity',
1188 '0xnan',
1189 '',
1190 ' ',
1191 'x1.0p0',
1192 '0xX1.0p0',
1193 '+ 0x1.0p0', # internal whitespace
1194 '- 0x1.0p0',
1195 '0 x1.0p0',
1196 '0x 1.0p0',
1197 '0x1 2.0p0',
1198 '+0x1 .0p0',
1199 '0x1. 0p0',
1200 '-0x1.0 1p0',
1201 '-0x1.0 p0',
1202 '+0x1.0p +0',
1203 '0x1.0p -0',
1204 '0x1.0p 0',
1205 '+0x1.0p+ 0',
1206 '-0x1.0p- 0',
1207 '++0x1.0p-0', # double signs
1208 '--0x1.0p0',
1209 '+-0x1.0p+0',
1210 '-+0x1.0p0',
1211 '0x1.0p++0',
1212 '+0x1.0p+-0',
1213 '-0x1.0p-+0',
1214 '0x1.0p--0',
1215 '0x1.0.p0',
1216 '0x.p0', # no hex digits before or after point
1217 '0x1,p0', # wrong decimal point character
1218 '0x1pa',
1219 '0x1p\uff10', # fullwidth Unicode digits
1220 '\uff10x1p0',
1221 '0x\uff11p0',
1222 '0x1.\uff10p0',
1223 '0x1p0 \n 0x2p0',
1224 '0x1p0\0 0x1p0', # embedded null byte is not end of string
1225 ]
1226 for x in invalid_inputs:
1227 try:
1228 result = fromHex(x)
1229 except ValueError:
1230 pass
1231 else:
1232 self.fail('Expected float.fromhex(%r) to raise ValueError; '
1233 'got %r instead' % (x, result))
1234
1235
1236 def test_whitespace(self):
1237 value_pairs = [
1238 ('inf', INF),
1239 ('-Infinity', -INF),
1240 ('nan', NAN),
1241 ('1.0', 1.0),
1242 ('-0x.2', -0.125),
1243 ('-0.0', -0.0)
1244 ]
1245 whitespace = [
1246 '',
1247 ' ',
1248 '\t',
1249 '\n',
1250 '\n \t',
1251 '\f',
1252 '\v',
1253 '\r'
1254 ]
1255 for inp, expected in value_pairs:
1256 for lead in whitespace:
1257 for trail in whitespace:
1258 got = fromHex(lead + inp + trail)
1259 self.identical(got, expected)
1260
1261
1262 def test_from_hex(self):
1263 MIN = self.MIN
1264 MAX = self.MAX
1265 TINY = self.TINY
1266 EPS = self.EPS
1267
1268 # two spellings of infinity, with optional signs; case-insensitive
1269 self.identical(fromHex('inf'), INF)
1270 self.identical(fromHex('+Inf'), INF)
1271 self.identical(fromHex('-INF'), -INF)
1272 self.identical(fromHex('iNf'), INF)
1273 self.identical(fromHex('Infinity'), INF)
1274 self.identical(fromHex('+INFINITY'), INF)
1275 self.identical(fromHex('-infinity'), -INF)
1276 self.identical(fromHex('-iNFiNitY'), -INF)
1277
1278 # nans with optional sign; case insensitive
1279 self.identical(fromHex('nan'), NAN)
1280 self.identical(fromHex('+NaN'), NAN)
1281 self.identical(fromHex('-NaN'), NAN)
1282 self.identical(fromHex('-nAN'), NAN)
1283
1284 # variations in input format
1285 self.identical(fromHex('1'), 1.0)
1286 self.identical(fromHex('+1'), 1.0)
1287 self.identical(fromHex('1.'), 1.0)
1288 self.identical(fromHex('1.0'), 1.0)
1289 self.identical(fromHex('1.0p0'), 1.0)
1290 self.identical(fromHex('01'), 1.0)
1291 self.identical(fromHex('01.'), 1.0)
1292 self.identical(fromHex('0x1'), 1.0)
1293 self.identical(fromHex('0x1.'), 1.0)
1294 self.identical(fromHex('0x1.0'), 1.0)
1295 self.identical(fromHex('+0x1.0'), 1.0)
1296 self.identical(fromHex('0x1p0'), 1.0)
1297 self.identical(fromHex('0X1p0'), 1.0)
1298 self.identical(fromHex('0X1P0'), 1.0)
1299 self.identical(fromHex('0x1P0'), 1.0)
1300 self.identical(fromHex('0x1.p0'), 1.0)
1301 self.identical(fromHex('0x1.0p0'), 1.0)
1302 self.identical(fromHex('0x.1p4'), 1.0)
1303 self.identical(fromHex('0x.1p04'), 1.0)
1304 self.identical(fromHex('0x.1p004'), 1.0)
1305 self.identical(fromHex('0x1p+0'), 1.0)
1306 self.identical(fromHex('0x1P-0'), 1.0)
1307 self.identical(fromHex('+0x1p0'), 1.0)
1308 self.identical(fromHex('0x01p0'), 1.0)
1309 self.identical(fromHex('0x1p00'), 1.0)
1310 self.identical(fromHex(' 0x1p0 '), 1.0)
1311 self.identical(fromHex('\n 0x1p0'), 1.0)
1312 self.identical(fromHex('0x1p0 \t'), 1.0)
1313 self.identical(fromHex('0xap0'), 10.0)
1314 self.identical(fromHex('0xAp0'), 10.0)
1315 self.identical(fromHex('0xaP0'), 10.0)
1316 self.identical(fromHex('0xAP0'), 10.0)
1317 self.identical(fromHex('0xbep0'), 190.0)
1318 self.identical(fromHex('0xBep0'), 190.0)
1319 self.identical(fromHex('0xbEp0'), 190.0)
1320 self.identical(fromHex('0XBE0P-4'), 190.0)
1321 self.identical(fromHex('0xBEp0'), 190.0)
1322 self.identical(fromHex('0xB.Ep4'), 190.0)
1323 self.identical(fromHex('0x.BEp8'), 190.0)
1324 self.identical(fromHex('0x.0BEp12'), 190.0)
1325
1326 # moving the point around
1327 pi = fromHex('0x1.921fb54442d18p1')
1328 self.identical(fromHex('0x.006487ed5110b46p11'), pi)
1329 self.identical(fromHex('0x.00c90fdaa22168cp10'), pi)
1330 self.identical(fromHex('0x.01921fb54442d18p9'), pi)
1331 self.identical(fromHex('0x.03243f6a8885a3p8'), pi)
1332 self.identical(fromHex('0x.06487ed5110b46p7'), pi)
1333 self.identical(fromHex('0x.0c90fdaa22168cp6'), pi)
1334 self.identical(fromHex('0x.1921fb54442d18p5'), pi)
1335 self.identical(fromHex('0x.3243f6a8885a3p4'), pi)
1336 self.identical(fromHex('0x.6487ed5110b46p3'), pi)
1337 self.identical(fromHex('0x.c90fdaa22168cp2'), pi)
1338 self.identical(fromHex('0x1.921fb54442d18p1'), pi)
1339 self.identical(fromHex('0x3.243f6a8885a3p0'), pi)
1340 self.identical(fromHex('0x6.487ed5110b46p-1'), pi)
1341 self.identical(fromHex('0xc.90fdaa22168cp-2'), pi)
1342 self.identical(fromHex('0x19.21fb54442d18p-3'), pi)
1343 self.identical(fromHex('0x32.43f6a8885a3p-4'), pi)
1344 self.identical(fromHex('0x64.87ed5110b46p-5'), pi)
1345 self.identical(fromHex('0xc9.0fdaa22168cp-6'), pi)
1346 self.identical(fromHex('0x192.1fb54442d18p-7'), pi)
1347 self.identical(fromHex('0x324.3f6a8885a3p-8'), pi)
1348 self.identical(fromHex('0x648.7ed5110b46p-9'), pi)
1349 self.identical(fromHex('0xc90.fdaa22168cp-10'), pi)
1350 self.identical(fromHex('0x1921.fb54442d18p-11'), pi)
1351 # ...
1352 self.identical(fromHex('0x1921fb54442d1.8p-47'), pi)
1353 self.identical(fromHex('0x3243f6a8885a3p-48'), pi)
1354 self.identical(fromHex('0x6487ed5110b46p-49'), pi)
1355 self.identical(fromHex('0xc90fdaa22168cp-50'), pi)
1356 self.identical(fromHex('0x1921fb54442d18p-51'), pi)
1357 self.identical(fromHex('0x3243f6a8885a30p-52'), pi)
1358 self.identical(fromHex('0x6487ed5110b460p-53'), pi)
1359 self.identical(fromHex('0xc90fdaa22168c0p-54'), pi)
1360 self.identical(fromHex('0x1921fb54442d180p-55'), pi)
1361
1362
1363 # results that should overflow...
1364 self.assertRaises(OverflowError, fromHex, '-0x1p1024')
1365 self.assertRaises(OverflowError, fromHex, '0x1p+1025')
1366 self.assertRaises(OverflowError, fromHex, '+0X1p1030')
1367 self.assertRaises(OverflowError, fromHex, '-0x1p+1100')
1368 self.assertRaises(OverflowError, fromHex, '0X1p123456789123456789')
1369 self.assertRaises(OverflowError, fromHex, '+0X.8p+1025')
1370 self.assertRaises(OverflowError, fromHex, '+0x0.8p1025')
1371 self.assertRaises(OverflowError, fromHex, '-0x0.4p1026')
1372 self.assertRaises(OverflowError, fromHex, '0X2p+1023')
1373 self.assertRaises(OverflowError, fromHex, '0x2.p1023')
1374 self.assertRaises(OverflowError, fromHex, '-0x2.0p+1023')
1375 self.assertRaises(OverflowError, fromHex, '+0X4p+1022')
1376 self.assertRaises(OverflowError, fromHex, '0x1.ffffffffffffffp+1023')
1377 self.assertRaises(OverflowError, fromHex, '-0X1.fffffffffffff9p1023')
1378 self.assertRaises(OverflowError, fromHex, '0X1.fffffffffffff8p1023')
1379 self.assertRaises(OverflowError, fromHex, '+0x3.fffffffffffffp1022')
1380 self.assertRaises(OverflowError, fromHex, '0x3fffffffffffffp+970')
1381 self.assertRaises(OverflowError, fromHex, '0x10000000000000000p960')
1382 self.assertRaises(OverflowError, fromHex, '-0Xffffffffffffffffp960')
1383
1384 # ...and those that round to +-max float
1385 self.identical(fromHex('+0x1.fffffffffffffp+1023'), MAX)
1386 self.identical(fromHex('-0X1.fffffffffffff7p1023'), -MAX)
1387 self.identical(fromHex('0X1.fffffffffffff7fffffffffffffp1023'), MAX)
1388
1389 # zeros
1390 self.identical(fromHex('0x0p0'), 0.0)
1391 self.identical(fromHex('0x0p1000'), 0.0)
1392 self.identical(fromHex('-0x0p1023'), -0.0)
1393 self.identical(fromHex('0X0p1024'), 0.0)
1394 self.identical(fromHex('-0x0p1025'), -0.0)
1395 self.identical(fromHex('0X0p2000'), 0.0)
1396 self.identical(fromHex('0x0p123456789123456789'), 0.0)
1397 self.identical(fromHex('-0X0p-0'), -0.0)
1398 self.identical(fromHex('-0X0p-1000'), -0.0)
1399 self.identical(fromHex('0x0p-1023'), 0.0)
1400 self.identical(fromHex('-0X0p-1024'), -0.0)
1401 self.identical(fromHex('-0x0p-1025'), -0.0)
1402 self.identical(fromHex('-0x0p-1072'), -0.0)
1403 self.identical(fromHex('0X0p-1073'), 0.0)
1404 self.identical(fromHex('-0x0p-1074'), -0.0)
1405 self.identical(fromHex('0x0p-1075'), 0.0)
1406 self.identical(fromHex('0X0p-1076'), 0.0)
1407 self.identical(fromHex('-0X0p-2000'), -0.0)
1408 self.identical(fromHex('-0x0p-123456789123456789'), -0.0)
1409
1410 # values that should underflow to 0
1411 self.identical(fromHex('0X1p-1075'), 0.0)
1412 self.identical(fromHex('-0X1p-1075'), -0.0)
1413 self.identical(fromHex('-0x1p-123456789123456789'), -0.0)
1414 self.identical(fromHex('0x1.00000000000000001p-1075'), TINY)
1415 self.identical(fromHex('-0x1.1p-1075'), -TINY)
1416 self.identical(fromHex('0x1.fffffffffffffffffp-1075'), TINY)
1417
1418 # check round-half-even is working correctly near 0 ...
1419 self.identical(fromHex('0x1p-1076'), 0.0)
1420 self.identical(fromHex('0X2p-1076'), 0.0)
1421 self.identical(fromHex('0X3p-1076'), TINY)
1422 self.identical(fromHex('0x4p-1076'), TINY)
1423 self.identical(fromHex('0X5p-1076'), TINY)
1424 self.identical(fromHex('0X6p-1076'), 2*TINY)
1425 self.identical(fromHex('0x7p-1076'), 2*TINY)
1426 self.identical(fromHex('0X8p-1076'), 2*TINY)
1427 self.identical(fromHex('0X9p-1076'), 2*TINY)
1428 self.identical(fromHex('0xap-1076'), 2*TINY)
1429 self.identical(fromHex('0Xbp-1076'), 3*TINY)
1430 self.identical(fromHex('0xcp-1076'), 3*TINY)
1431 self.identical(fromHex('0Xdp-1076'), 3*TINY)
1432 self.identical(fromHex('0Xep-1076'), 4*TINY)
1433 self.identical(fromHex('0xfp-1076'), 4*TINY)
1434 self.identical(fromHex('0x10p-1076'), 4*TINY)
1435 self.identical(fromHex('-0x1p-1076'), -0.0)
1436 self.identical(fromHex('-0X2p-1076'), -0.0)
1437 self.identical(fromHex('-0x3p-1076'), -TINY)
1438 self.identical(fromHex('-0X4p-1076'), -TINY)
1439 self.identical(fromHex('-0x5p-1076'), -TINY)
1440 self.identical(fromHex('-0x6p-1076'), -2*TINY)
1441 self.identical(fromHex('-0X7p-1076'), -2*TINY)
1442 self.identical(fromHex('-0X8p-1076'), -2*TINY)
1443 self.identical(fromHex('-0X9p-1076'), -2*TINY)
1444 self.identical(fromHex('-0Xap-1076'), -2*TINY)
1445 self.identical(fromHex('-0xbp-1076'), -3*TINY)
1446 self.identical(fromHex('-0xcp-1076'), -3*TINY)
1447 self.identical(fromHex('-0Xdp-1076'), -3*TINY)
1448 self.identical(fromHex('-0xep-1076'), -4*TINY)
1449 self.identical(fromHex('-0Xfp-1076'), -4*TINY)
1450 self.identical(fromHex('-0X10p-1076'), -4*TINY)
1451
1452 # ... and near MIN ...
1453 self.identical(fromHex('0x0.ffffffffffffd6p-1022'), MIN-3*TINY)
1454 self.identical(fromHex('0x0.ffffffffffffd8p-1022'), MIN-2*TINY)
1455 self.identical(fromHex('0x0.ffffffffffffdap-1022'), MIN-2*TINY)
1456 self.identical(fromHex('0x0.ffffffffffffdcp-1022'), MIN-2*TINY)
1457 self.identical(fromHex('0x0.ffffffffffffdep-1022'), MIN-2*TINY)
1458 self.identical(fromHex('0x0.ffffffffffffe0p-1022'), MIN-2*TINY)
1459 self.identical(fromHex('0x0.ffffffffffffe2p-1022'), MIN-2*TINY)
1460 self.identical(fromHex('0x0.ffffffffffffe4p-1022'), MIN-2*TINY)
1461 self.identical(fromHex('0x0.ffffffffffffe6p-1022'), MIN-2*TINY)
1462 self.identical(fromHex('0x0.ffffffffffffe8p-1022'), MIN-2*TINY)
1463 self.identical(fromHex('0x0.ffffffffffffeap-1022'), MIN-TINY)
1464 self.identical(fromHex('0x0.ffffffffffffecp-1022'), MIN-TINY)
1465 self.identical(fromHex('0x0.ffffffffffffeep-1022'), MIN-TINY)
1466 self.identical(fromHex('0x0.fffffffffffff0p-1022'), MIN-TINY)
1467 self.identical(fromHex('0x0.fffffffffffff2p-1022'), MIN-TINY)
1468 self.identical(fromHex('0x0.fffffffffffff4p-1022'), MIN-TINY)
1469 self.identical(fromHex('0x0.fffffffffffff6p-1022'), MIN-TINY)
1470 self.identical(fromHex('0x0.fffffffffffff8p-1022'), MIN)
1471 self.identical(fromHex('0x0.fffffffffffffap-1022'), MIN)
1472 self.identical(fromHex('0x0.fffffffffffffcp-1022'), MIN)
1473 self.identical(fromHex('0x0.fffffffffffffep-1022'), MIN)
1474 self.identical(fromHex('0x1.00000000000000p-1022'), MIN)
1475 self.identical(fromHex('0x1.00000000000002p-1022'), MIN)
1476 self.identical(fromHex('0x1.00000000000004p-1022'), MIN)
1477 self.identical(fromHex('0x1.00000000000006p-1022'), MIN)
1478 self.identical(fromHex('0x1.00000000000008p-1022'), MIN)
1479 self.identical(fromHex('0x1.0000000000000ap-1022'), MIN+TINY)
1480 self.identical(fromHex('0x1.0000000000000cp-1022'), MIN+TINY)
1481 self.identical(fromHex('0x1.0000000000000ep-1022'), MIN+TINY)
1482 self.identical(fromHex('0x1.00000000000010p-1022'), MIN+TINY)
1483 self.identical(fromHex('0x1.00000000000012p-1022'), MIN+TINY)
1484 self.identical(fromHex('0x1.00000000000014p-1022'), MIN+TINY)
1485 self.identical(fromHex('0x1.00000000000016p-1022'), MIN+TINY)
1486 self.identical(fromHex('0x1.00000000000018p-1022'), MIN+2*TINY)
1487
1488 # ... and near 1.0.
1489 self.identical(fromHex('0x0.fffffffffffff0p0'), 1.0-EPS)
1490 self.identical(fromHex('0x0.fffffffffffff1p0'), 1.0-EPS)
1491 self.identical(fromHex('0X0.fffffffffffff2p0'), 1.0-EPS)
1492 self.identical(fromHex('0x0.fffffffffffff3p0'), 1.0-EPS)
1493 self.identical(fromHex('0X0.fffffffffffff4p0'), 1.0-EPS)
1494 self.identical(fromHex('0X0.fffffffffffff5p0'), 1.0-EPS/2)
1495 self.identical(fromHex('0X0.fffffffffffff6p0'), 1.0-EPS/2)
1496 self.identical(fromHex('0x0.fffffffffffff7p0'), 1.0-EPS/2)
1497 self.identical(fromHex('0x0.fffffffffffff8p0'), 1.0-EPS/2)
1498 self.identical(fromHex('0X0.fffffffffffff9p0'), 1.0-EPS/2)
1499 self.identical(fromHex('0X0.fffffffffffffap0'), 1.0-EPS/2)
1500 self.identical(fromHex('0x0.fffffffffffffbp0'), 1.0-EPS/2)
1501 self.identical(fromHex('0X0.fffffffffffffcp0'), 1.0)
1502 self.identical(fromHex('0x0.fffffffffffffdp0'), 1.0)
1503 self.identical(fromHex('0X0.fffffffffffffep0'), 1.0)
1504 self.identical(fromHex('0x0.ffffffffffffffp0'), 1.0)
1505 self.identical(fromHex('0X1.00000000000000p0'), 1.0)
1506 self.identical(fromHex('0X1.00000000000001p0'), 1.0)
1507 self.identical(fromHex('0x1.00000000000002p0'), 1.0)
1508 self.identical(fromHex('0X1.00000000000003p0'), 1.0)
1509 self.identical(fromHex('0x1.00000000000004p0'), 1.0)
1510 self.identical(fromHex('0X1.00000000000005p0'), 1.0)
1511 self.identical(fromHex('0X1.00000000000006p0'), 1.0)
1512 self.identical(fromHex('0X1.00000000000007p0'), 1.0)
1513 self.identical(fromHex('0x1.00000000000007ffffffffffffffffffffp0'),
1514 1.0)
1515 self.identical(fromHex('0x1.00000000000008p0'), 1.0)
1516 self.identical(fromHex('0x1.00000000000008000000000000000001p0'),
1517 1+EPS)
1518 self.identical(fromHex('0X1.00000000000009p0'), 1.0+EPS)
1519 self.identical(fromHex('0x1.0000000000000ap0'), 1.0+EPS)
1520 self.identical(fromHex('0x1.0000000000000bp0'), 1.0+EPS)
1521 self.identical(fromHex('0X1.0000000000000cp0'), 1.0+EPS)
1522 self.identical(fromHex('0x1.0000000000000dp0'), 1.0+EPS)
1523 self.identical(fromHex('0x1.0000000000000ep0'), 1.0+EPS)
1524 self.identical(fromHex('0X1.0000000000000fp0'), 1.0+EPS)
1525 self.identical(fromHex('0x1.00000000000010p0'), 1.0+EPS)
1526 self.identical(fromHex('0X1.00000000000011p0'), 1.0+EPS)
1527 self.identical(fromHex('0x1.00000000000012p0'), 1.0+EPS)
1528 self.identical(fromHex('0X1.00000000000013p0'), 1.0+EPS)
1529 self.identical(fromHex('0X1.00000000000014p0'), 1.0+EPS)
1530 self.identical(fromHex('0x1.00000000000015p0'), 1.0+EPS)
1531 self.identical(fromHex('0x1.00000000000016p0'), 1.0+EPS)
1532 self.identical(fromHex('0X1.00000000000017p0'), 1.0+EPS)
1533 self.identical(fromHex('0x1.00000000000017ffffffffffffffffffffp0'),
1534 1.0+EPS)
1535 self.identical(fromHex('0x1.00000000000018p0'), 1.0+2*EPS)
1536 self.identical(fromHex('0X1.00000000000018000000000000000001p0'),
1537 1.0+2*EPS)
1538 self.identical(fromHex('0x1.00000000000019p0'), 1.0+2*EPS)
1539 self.identical(fromHex('0X1.0000000000001ap0'), 1.0+2*EPS)
1540 self.identical(fromHex('0X1.0000000000001bp0'), 1.0+2*EPS)
1541 self.identical(fromHex('0x1.0000000000001cp0'), 1.0+2*EPS)
1542 self.identical(fromHex('0x1.0000000000001dp0'), 1.0+2*EPS)
1543 self.identical(fromHex('0x1.0000000000001ep0'), 1.0+2*EPS)
1544 self.identical(fromHex('0X1.0000000000001fp0'), 1.0+2*EPS)
1545 self.identical(fromHex('0x1.00000000000020p0'), 1.0+2*EPS)
1546
1547 # Regression test for a corner-case bug reported in b.p.o. 44954
1548 self.identical(fromHex('0x.8p-1074'), 0.0)
1549 self.identical(fromHex('0x.80p-1074'), 0.0)
1550 self.identical(fromHex('0x.81p-1074'), TINY)
1551 self.identical(fromHex('0x8p-1078'), 0.0)
1552 self.identical(fromHex('0x8.0p-1078'), 0.0)
1553 self.identical(fromHex('0x8.1p-1078'), TINY)
1554 self.identical(fromHex('0x80p-1082'), 0.0)
1555 self.identical(fromHex('0x81p-1082'), TINY)
1556 self.identical(fromHex('.8p-1074'), 0.0)
1557 self.identical(fromHex('8p-1078'), 0.0)
1558 self.identical(fromHex('-.8p-1074'), -0.0)
1559 self.identical(fromHex('+8p-1078'), 0.0)
1560
1561 def test_roundtrip(self):
1562 def roundtrip(x):
1563 return fromHex(toHex(x))
1564
1565 for x in [NAN, INF, self.MAX, self.MIN, self.MIN-self.TINY, self.TINY, 0.0]:
1566 self.identical(x, roundtrip(x))
1567 self.identical(-x, roundtrip(-x))
1568
1569 # fromHex(toHex(x)) should exactly recover x, for any non-NaN float x.
1570 import random
1571 for i in range(10000):
1572 e = random.randrange(-1200, 1200)
1573 m = random.random()
1574 s = random.choice([1.0, -1.0])
1575 try:
1576 x = s*ldexp(m, e)
1577 except OverflowError:
1578 pass
1579 else:
1580 self.identical(x, fromHex(toHex(x)))
1581
1582 def test_subclass(self):
1583 class F(float):
1584 def __new__(cls, value):
1585 return float.__new__(cls, value + 1)
1586
1587 f = F.fromhex((1.5).hex())
1588 self.assertIs(type(f), F)
1589 self.assertEqual(f, 2.5)
1590
1591 class F2(float):
1592 def __init__(self, value):
1593 self.foo = 'bar'
1594
1595 f = F2.fromhex((1.5).hex())
1596 self.assertIs(type(f), F2)
1597 self.assertEqual(f, 1.5)
1598 self.assertEqual(getattr(f, 'foo', 'none'), 'bar')
1599
1600
1601 if __name__ == '__main__':
1602 unittest.main()