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