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