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