[pypy-svn] r75798 - in pypy/branch/fast-forward/pypy/objspace/std: . test
benjamin at codespeak.net
benjamin at codespeak.net
Fri Jul 2 22:32:45 CEST 2010
Author: benjamin
Date: Fri Jul 2 22:32:44 2010
New Revision: 75798
Modified:
pypy/branch/fast-forward/pypy/objspace/std/floatobject.py
pypy/branch/fast-forward/pypy/objspace/std/floattype.py
pypy/branch/fast-forward/pypy/objspace/std/test/test_floatobject.py
Log:
add float.fromhex and float.hex
Modified: pypy/branch/fast-forward/pypy/objspace/std/floatobject.py
==============================================================================
--- pypy/branch/fast-forward/pypy/objspace/std/floatobject.py (original)
+++ pypy/branch/fast-forward/pypy/objspace/std/floatobject.py Fri Jul 2 22:32:44 2010
@@ -7,6 +7,7 @@
from pypy.objspace.std.register_all import register_all
from pypy.objspace.std.noneobject import W_NoneObject
from pypy.objspace.std.longobject import W_LongObject
+from pypy.module.sys import system
from pypy.rlib.rarithmetic import ovfcheck_float_to_int, intmask, isinf, isnan
from pypy.rlib.rarithmetic import formatd, LONG_BIT, FL_MAXINT, FL_MININT
from pypy.rlib.rbigint import rbigint
@@ -86,6 +87,44 @@
def float_w__Float(space, w_float):
return w_float.floatval
+def _char_from_hex(number):
+ return "0123456789abcdef"[number]
+
+TOHEX_NBITS = system.DBL_MANT_DIG + 3 - (system.DBL_MANT_DIG + 2) % 4
+
+def float_hex__Float(space, w_float):
+ value = w_float.floatval
+ if isinf(value) or isnan(value):
+ return str__Float(space, w_float)
+ if value == 0.0:
+ if math.copysign(1., value) == -1.:
+ return space.wrap("-0x0.0p+0")
+ else:
+ return space.wrap("0x0.0p+0")
+ mant, exp = math.frexp(value)
+ shift = 1 - max(system.DBL_MIN_EXP - exp, 0)
+ mant = math.ldexp(mant, shift)
+ mant = abs(mant)
+ exp -= shift
+ result = ['\0'] * ((TOHEX_NBITS - 1) // 4 + 2)
+ result[0] = _char_from_hex(int(mant))
+ mant -= int(mant)
+ result[1] = "."
+ for i in range((TOHEX_NBITS - 1) // 4):
+ mant *= 16.0
+ result[i + 2] = _char_from_hex(int(mant))
+ mant -= int(mant)
+ if exp < 0:
+ sign = "-"
+ else:
+ sign = "+"
+ exp = abs(exp)
+ s = ''.join(result)
+ if value < 0.0:
+ return space.wrap("-0x%sp%s%d" % (s, sign, exp))
+ else:
+ return space.wrap("0x%sp%s%d" % (s, sign, exp))
+
def float2string(space, w_float, format):
x = w_float.floatval
# we special-case explicitly inf and nan here
@@ -417,7 +456,8 @@
def getnewargs__Float(space, w_float):
return space.newtuple([W_FloatObject(w_float.floatval)])
-register_all(vars())
+from pypy.objspace.std import floattype
+register_all(vars(), floattype)
# pow delegation for negative 2nd arg
def pow_neg__Long_Long_None(space, w_int1, w_int2, thirdarg):
Modified: pypy/branch/fast-forward/pypy/objspace/std/floattype.py
==============================================================================
--- pypy/branch/fast-forward/pypy/objspace/std/floattype.py (original)
+++ pypy/branch/fast-forward/pypy/objspace/std/floattype.py Fri Jul 2 22:32:44 2010
@@ -1,9 +1,17 @@
+import math
+import sys
+from pypy.rlib.unroll import unrolling_iterable
from pypy.interpreter import gateway
from pypy.interpreter.baseobjspace import ObjSpace, W_Root
from pypy.interpreter.error import OperationError
-from pypy.objspace.std.stdtypedef import StdTypeDef
+from pypy.objspace.std.stdtypedef import StdTypeDef, SMM
from pypy.objspace.std.strutil import ParseStringError
from pypy.objspace.std.strutil import interp_string_to_float
+from pypy.module.sys import system
+
+
+float_hex = SMM("hex", 1)
+
def descr__new__(space, w_floattype, w_x=0.0):
from pypy.objspace.std.floatobject import W_FloatObject
@@ -47,6 +55,157 @@
raise OperationError(space.w_ValueError,
space.wrap("only float and double are valid"))
+_alpha = zip("abcdef", range(10, 16)) + zip("ABCDEF", range(10, 16))
+_hex_to_int = zip("0123456789", range(10)) + _alpha
+_hex_to_int_iterable = unrolling_iterable(_hex_to_int)
+def _hex_from_char(c):
+ for h, v in _hex_to_int_iterable:
+ if h == c:
+ return v
+ return -1
+
+def _hex_digit(s, j, co_end, float_digits):
+ if j < float_digits:
+ i = co_end - j
+ else:
+ i = co_end - 1 - j
+ return _hex_from_char(s[i])
+
+def descr_fromhex(space, w_cls, s):
+ length = len(s)
+ i = 0
+ while i < length and s[i].isspace():
+ i += 1
+ if i == length:
+ raise OperationError(space.w_ValueError,
+ space.wrap("invalid hex string"))
+ sign = 1
+ if s[i] == "-":
+ sign = -1
+ i += 1
+ elif s[i] == "+":
+ i += 1
+ if length == i:
+ raise OperationError(space.w_ValueError,
+ space.wrap("invalid hex string"))
+ if s[i] == "i" or s[i] == "I":
+ i += 1
+ if length - i >= 2 and s[i:i + 2].lower() == "nf":
+ i += 2
+ value = float("inf")
+ if length - i >= 5 and s[i:i + 5].lower() == "inity":
+ i += 5
+ elif s[i] == "n" or s[i] == "N":
+ i += 1
+ if length - i >= 2 and s[i:i + 2].lower() == "an":
+ i += 2
+ value = float("nan")
+ else:
+ if (s[i] == "0" and length - i > 1 and
+ (s[i + 1] == "x" or s[i + 1] == "X")):
+ i += 2
+ co_start = i
+ while i < length and _hex_from_char(s[i]) >= 0:
+ i += 1
+ whole_end = i
+ if i < length and s[i] == ".":
+ i += 1
+ while i < length and _hex_from_char(s[i]) >= 0:
+ i += 1
+ co_end = i - 1
+ else:
+ co_end = i
+ total_digits = co_end - co_start
+ float_digits = co_end - whole_end
+ if not total_digits:
+ raise OperationError(space.w_ValueError,
+ space.wrap("invalid hex string"))
+ const_one = system.DBL_MIN_EXP - system.DBL_MANT_DIG + sys.maxint // 2
+ const_two = sys.maxint // 2 + 1 - system.DBL_MAX_EXP
+ if total_digits > min(const_one, const_two) // 4:
+ raise OperationError(space.w_ValueError, space.wrap("way too long"))
+ if i < length and (s[i] == "p" or s[i] == "P"):
+ if i == length:
+ raise OperationError(space.w_ValueError,
+ space.wrap("invalid hex string"))
+ i += 1
+ exp_start = i
+ if s[i] == "-" or s[i] == "+":
+ i += 1
+ if i == length:
+ raise OperationError(space.w_ValueError,
+ space.wrap("invalid hex string"))
+ if not s[i].isdigit():
+ raise OperationError(space.w_ValueError,
+ space.wrap("invalid hex string"))
+ i += 1
+ while i < length and s[i].isdigit():
+ i += 1
+ exp = int(s[exp_start:i])
+ else:
+ exp = 0
+ while (total_digits and
+ _hex_digit(s, total_digits - 1, co_end, float_digits) == 0):
+ total_digits -= 1
+ if not total_digits or exp < -sys.maxint / 2:
+ value = 0.0
+ elif exp > sys.maxint // 2:
+ raise OperationError(space.w_OverflowError, space.wrap("too large"))
+ else:
+ exp -= 4 * float_digits
+ top_exp = exp + 4 * (total_digits - 1)
+ digit = _hex_digit(s, total_digits - 1, co_end, float_digits)
+ while digit:
+ top_exp += 1
+ digit //= 2
+ if top_exp < system.DBL_MIN_EXP - system.DBL_MANT_DIG:
+ value = 0.0
+ elif top_exp > system.DBL_MAX_EXP:
+ raise OperationError(space.w_OverflowError,
+ space.wrap("too large"))
+ else:
+ lsb = max(top_exp, system.DBL_MIN_EXP) - system.DBL_MANT_DIG
+ value = 0
+ if exp >= lsb:
+ for j in range(total_digits - 1, -1, -1):
+ value = 16.0 * value + _hex_digit(s, j, co_end,
+ float_digits)
+ value = math.ldexp(value, exp)
+ else:
+ half_eps = 1 << ((lsb - exp - 1) % 4)
+ key_digit = (lsb - exp - 1) // 4
+ for j in range(total_digits - 1, key_digit, -1):
+ value = 16.0 * value + _hex_digit(s, j, co_end,
+ float_digits)
+ digit = _hex_digit(s, key_digit, co_end, float_digits)
+ value = 16.0 * value + (digit & (16 - 2*half_eps))
+ if digit & half_eps:
+ round_up = False
+ if (digit & (3 * half_eps - 1) or
+ (half_eps == 8 and
+ _hex_digit(s, key_digit + 1, co_end, float_digits) & 1)):
+ round_up = True
+ else:
+ for j in range(key_digit - 1, -1, -1):
+ if _hex_digit(s, j, co_end, float_digits):
+ round_up = True
+ break
+ if round_up:
+ value += 2 * half_eps
+ mant_dig = system.DBL_MANT_DIG
+ if (top_exp == system.DBL_MAX_EXP and
+ value == math.ldexp(2 * half_eps, mant_dig)):
+ raise OperationError(space.w_OverflowError,
+ space.wrap("too large"))
+ value = math.ldexp(value, (exp + 4*key_digit))
+ while i < length and s[i].isspace():
+ i += 1
+ if i != length:
+ raise OperationError(space.w_ValueError,
+ space.wrap("invalid hex string"))
+ w_float = space.wrap(sign * value)
+ return space.call_function(w_cls, w_float)
+
# ____________________________________________________________
@@ -58,4 +217,8 @@
__getformat__ = gateway.interp2app(descr___getformat__,
unwrap_spec=[ObjSpace, W_Root, str],
as_classmethod=True),
+ fromhex = gateway.interp2app(descr_fromhex,
+ unwrap_spec=[ObjSpace, W_Root, str],
+ as_classmethod=True),
)
+float_typedef.registermethods(globals())
Modified: pypy/branch/fast-forward/pypy/objspace/std/test/test_floatobject.py
==============================================================================
--- pypy/branch/fast-forward/pypy/objspace/std/test/test_floatobject.py (original)
+++ pypy/branch/fast-forward/pypy/objspace/std/test/test_floatobject.py Fri Jul 2 22:32:44 2010
@@ -343,3 +343,337 @@
#if hasattr(long, '__eq__'): # for py.test -A: CPython is inconsistent
# assert 5L .__eq__(3.14) is NotImplemented
# assert 3.14 .__eq__(5L) is False
+
+
+class AppTestFloatHex:
+
+ def setup_class(cls):
+ space = cls.space
+ cls.w_identical = space.appexec((), """():
+ import math
+ def identical(x, y):
+ # check that floats x and y are identical, or that both
+ # are NaNs
+ if math.isnan(x) or math.isnan(y):
+ if math.isnan(x) == math.isnan(y):
+ return
+ assert (x == y and (x != 0.0 or
+ math.copysign(1.0, x) == math.copysign(1.0, y)))
+ return identical
+ """)
+
+
+ def test_from_hex(self):
+ fromHex = float.fromhex
+ import sys
+ INF = float("inf")
+ NAN = float("nan")
+ MIN = sys.float_info.min
+ MAX = sys.float_info.max
+ TINY = fromHex('0x0.0000000000001p-1022') # min subnormal
+ EPS = sys.float_info.epsilon
+
+ # two spellings of infinity, with optional signs; case-insensitive
+ self.identical(fromHex('inf'), INF)
+ self.identical(fromHex('+Inf'), INF)
+ self.identical(fromHex('-INF'), -INF)
+ self.identical(fromHex('iNf'), INF)
+ self.identical(fromHex('Infinity'), INF)
+ self.identical(fromHex('+INFINITY'), INF)
+ self.identical(fromHex('-infinity'), -INF)
+ self.identical(fromHex('-iNFiNitY'), -INF)
+
+ # nans with optional sign; case insensitive
+ self.identical(fromHex('nan'), NAN)
+ self.identical(fromHex('+NaN'), NAN)
+ self.identical(fromHex('-NaN'), NAN)
+ self.identical(fromHex('-nAN'), NAN)
+
+ # variations in input format
+ self.identical(fromHex('1'), 1.0)
+ self.identical(fromHex('+1'), 1.0)
+ self.identical(fromHex('1.'), 1.0)
+ self.identical(fromHex('1.0'), 1.0)
+ self.identical(fromHex('1.0p0'), 1.0)
+ self.identical(fromHex('01'), 1.0)
+ self.identical(fromHex('01.'), 1.0)
+ self.identical(fromHex('0x1'), 1.0)
+ self.identical(fromHex('0x1.'), 1.0)
+ self.identical(fromHex('0x1.0'), 1.0)
+ self.identical(fromHex('+0x1.0'), 1.0)
+ self.identical(fromHex('0x1p0'), 1.0)
+ self.identical(fromHex('0X1p0'), 1.0)
+ self.identical(fromHex('0X1P0'), 1.0)
+ self.identical(fromHex('0x1P0'), 1.0)
+ self.identical(fromHex('0x1.p0'), 1.0)
+ self.identical(fromHex('0x1.0p0'), 1.0)
+ self.identical(fromHex('0x.1p4'), 1.0)
+ self.identical(fromHex('0x.1p04'), 1.0)
+ self.identical(fromHex('0x.1p004'), 1.0)
+ self.identical(fromHex('0x1p+0'), 1.0)
+ self.identical(fromHex('0x1P-0'), 1.0)
+ self.identical(fromHex('+0x1p0'), 1.0)
+ self.identical(fromHex('0x01p0'), 1.0)
+ self.identical(fromHex('0x1p00'), 1.0)
+ self.identical(fromHex(u'0x1p0'), 1.0)
+ self.identical(fromHex(' 0x1p0 '), 1.0)
+ self.identical(fromHex('\n 0x1p0'), 1.0)
+ self.identical(fromHex('0x1p0 \t'), 1.0)
+ self.identical(fromHex('0xap0'), 10.0)
+ self.identical(fromHex('0xAp0'), 10.0)
+ self.identical(fromHex('0xaP0'), 10.0)
+ self.identical(fromHex('0xAP0'), 10.0)
+ self.identical(fromHex('0xbep0'), 190.0)
+ self.identical(fromHex('0xBep0'), 190.0)
+ self.identical(fromHex('0xbEp0'), 190.0)
+ self.identical(fromHex('0XBE0P-4'), 190.0)
+ self.identical(fromHex('0xBEp0'), 190.0)
+ self.identical(fromHex('0xB.Ep4'), 190.0)
+ self.identical(fromHex('0x.BEp8'), 190.0)
+ self.identical(fromHex('0x.0BEp12'), 190.0)
+
+ # moving the point around
+ pi = fromHex('0x1.921fb54442d18p1')
+ self.identical(fromHex('0x.006487ed5110b46p11'), pi)
+ self.identical(fromHex('0x.00c90fdaa22168cp10'), pi)
+ self.identical(fromHex('0x.01921fb54442d18p9'), pi)
+ self.identical(fromHex('0x.03243f6a8885a3p8'), pi)
+ self.identical(fromHex('0x.06487ed5110b46p7'), pi)
+ self.identical(fromHex('0x.0c90fdaa22168cp6'), pi)
+ self.identical(fromHex('0x.1921fb54442d18p5'), pi)
+ self.identical(fromHex('0x.3243f6a8885a3p4'), pi)
+ self.identical(fromHex('0x.6487ed5110b46p3'), pi)
+ self.identical(fromHex('0x.c90fdaa22168cp2'), pi)
+ self.identical(fromHex('0x1.921fb54442d18p1'), pi)
+ self.identical(fromHex('0x3.243f6a8885a3p0'), pi)
+ self.identical(fromHex('0x6.487ed5110b46p-1'), pi)
+ self.identical(fromHex('0xc.90fdaa22168cp-2'), pi)
+ self.identical(fromHex('0x19.21fb54442d18p-3'), pi)
+ self.identical(fromHex('0x32.43f6a8885a3p-4'), pi)
+ self.identical(fromHex('0x64.87ed5110b46p-5'), pi)
+ self.identical(fromHex('0xc9.0fdaa22168cp-6'), pi)
+ self.identical(fromHex('0x192.1fb54442d18p-7'), pi)
+ self.identical(fromHex('0x324.3f6a8885a3p-8'), pi)
+ self.identical(fromHex('0x648.7ed5110b46p-9'), pi)
+ self.identical(fromHex('0xc90.fdaa22168cp-10'), pi)
+ self.identical(fromHex('0x1921.fb54442d18p-11'), pi)
+ # ...
+ self.identical(fromHex('0x1921fb54442d1.8p-47'), pi)
+ self.identical(fromHex('0x3243f6a8885a3p-48'), pi)
+ self.identical(fromHex('0x6487ed5110b46p-49'), pi)
+ self.identical(fromHex('0xc90fdaa22168cp-50'), pi)
+ self.identical(fromHex('0x1921fb54442d18p-51'), pi)
+ self.identical(fromHex('0x3243f6a8885a30p-52'), pi)
+ self.identical(fromHex('0x6487ed5110b460p-53'), pi)
+ self.identical(fromHex('0xc90fdaa22168c0p-54'), pi)
+ self.identical(fromHex('0x1921fb54442d180p-55'), pi)
+
+
+ # results that should overflow...
+ raises(OverflowError, fromHex, '-0x1p1024')
+ raises(OverflowError, fromHex, '0x1p+1025')
+ raises(OverflowError, fromHex, '+0X1p1030')
+ raises(OverflowError, fromHex, '-0x1p+1100')
+ raises(OverflowError, fromHex, '0X1p123456789123456789')
+ raises(OverflowError, fromHex, '+0X.8p+1025')
+ raises(OverflowError, fromHex, '+0x0.8p1025')
+ raises(OverflowError, fromHex, '-0x0.4p1026')
+ raises(OverflowError, fromHex, '0X2p+1023')
+ raises(OverflowError, fromHex, '0x2.p1023')
+ raises(OverflowError, fromHex, '-0x2.0p+1023')
+ raises(OverflowError, fromHex, '+0X4p+1022')
+ raises(OverflowError, fromHex, '0x1.ffffffffffffffp+1023')
+ raises(OverflowError, fromHex, '-0X1.fffffffffffff9p1023')
+ raises(OverflowError, fromHex, '0X1.fffffffffffff8p1023')
+ raises(OverflowError, fromHex, '+0x3.fffffffffffffp1022')
+ raises(OverflowError, fromHex, '0x3fffffffffffffp+970')
+ raises(OverflowError, fromHex, '0x10000000000000000p960')
+ raises(OverflowError, fromHex, '-0Xffffffffffffffffp960')
+
+ # ...and those that round to +-max float
+ self.identical(fromHex('+0x1.fffffffffffffp+1023'), MAX)
+ self.identical(fromHex('-0X1.fffffffffffff7p1023'), -MAX)
+ self.identical(fromHex('0X1.fffffffffffff7fffffffffffffp1023'), MAX)
+
+ # zeros
+ self.identical(fromHex('0x0p0'), 0.0)
+ self.identical(fromHex('0x0p1000'), 0.0)
+ self.identical(fromHex('-0x0p1023'), -0.0)
+ self.identical(fromHex('0X0p1024'), 0.0)
+ self.identical(fromHex('-0x0p1025'), -0.0)
+ self.identical(fromHex('0X0p2000'), 0.0)
+ self.identical(fromHex('0x0p123456789123456789'), 0.0)
+ self.identical(fromHex('-0X0p-0'), -0.0)
+ self.identical(fromHex('-0X0p-1000'), -0.0)
+ self.identical(fromHex('0x0p-1023'), 0.0)
+ self.identical(fromHex('-0X0p-1024'), -0.0)
+ self.identical(fromHex('-0x0p-1025'), -0.0)
+ self.identical(fromHex('-0x0p-1072'), -0.0)
+ self.identical(fromHex('0X0p-1073'), 0.0)
+ self.identical(fromHex('-0x0p-1074'), -0.0)
+ self.identical(fromHex('0x0p-1075'), 0.0)
+ self.identical(fromHex('0X0p-1076'), 0.0)
+ self.identical(fromHex('-0X0p-2000'), -0.0)
+ self.identical(fromHex('-0x0p-123456789123456789'), -0.0)
+
+ # values that should underflow to 0
+ self.identical(fromHex('0X1p-1075'), 0.0)
+ self.identical(fromHex('-0X1p-1075'), -0.0)
+ self.identical(fromHex('-0x1p-123456789123456789'), -0.0)
+ self.identical(fromHex('0x1.00000000000000001p-1075'), TINY)
+ self.identical(fromHex('-0x1.1p-1075'), -TINY)
+ self.identical(fromHex('0x1.fffffffffffffffffp-1075'), TINY)
+
+ # check round-half-even is working correctly near 0 ...
+ self.identical(fromHex('0x1p-1076'), 0.0)
+ self.identical(fromHex('0X2p-1076'), 0.0)
+ self.identical(fromHex('0X3p-1076'), TINY)
+ self.identical(fromHex('0x4p-1076'), TINY)
+ self.identical(fromHex('0X5p-1076'), TINY)
+ self.identical(fromHex('0X6p-1076'), 2*TINY)
+ self.identical(fromHex('0x7p-1076'), 2*TINY)
+ self.identical(fromHex('0X8p-1076'), 2*TINY)
+ self.identical(fromHex('0X9p-1076'), 2*TINY)
+ self.identical(fromHex('0xap-1076'), 2*TINY)
+ self.identical(fromHex('0Xbp-1076'), 3*TINY)
+ self.identical(fromHex('0xcp-1076'), 3*TINY)
+ self.identical(fromHex('0Xdp-1076'), 3*TINY)
+ self.identical(fromHex('0Xep-1076'), 4*TINY)
+ self.identical(fromHex('0xfp-1076'), 4*TINY)
+ self.identical(fromHex('0x10p-1076'), 4*TINY)
+ self.identical(fromHex('-0x1p-1076'), -0.0)
+ self.identical(fromHex('-0X2p-1076'), -0.0)
+ self.identical(fromHex('-0x3p-1076'), -TINY)
+ self.identical(fromHex('-0X4p-1076'), -TINY)
+ self.identical(fromHex('-0x5p-1076'), -TINY)
+ self.identical(fromHex('-0x6p-1076'), -2*TINY)
+ self.identical(fromHex('-0X7p-1076'), -2*TINY)
+ self.identical(fromHex('-0X8p-1076'), -2*TINY)
+ self.identical(fromHex('-0X9p-1076'), -2*TINY)
+ self.identical(fromHex('-0Xap-1076'), -2*TINY)
+ self.identical(fromHex('-0xbp-1076'), -3*TINY)
+ self.identical(fromHex('-0xcp-1076'), -3*TINY)
+ self.identical(fromHex('-0Xdp-1076'), -3*TINY)
+ self.identical(fromHex('-0xep-1076'), -4*TINY)
+ self.identical(fromHex('-0Xfp-1076'), -4*TINY)
+ self.identical(fromHex('-0X10p-1076'), -4*TINY)
+
+ # ... and near MIN ...
+ self.identical(fromHex('0x0.ffffffffffffd6p-1022'), MIN-3*TINY)
+ self.identical(fromHex('0x0.ffffffffffffd8p-1022'), MIN-2*TINY)
+ self.identical(fromHex('0x0.ffffffffffffdap-1022'), MIN-2*TINY)
+ self.identical(fromHex('0x0.ffffffffffffdcp-1022'), MIN-2*TINY)
+ self.identical(fromHex('0x0.ffffffffffffdep-1022'), MIN-2*TINY)
+ self.identical(fromHex('0x0.ffffffffffffe0p-1022'), MIN-2*TINY)
+ self.identical(fromHex('0x0.ffffffffffffe2p-1022'), MIN-2*TINY)
+ self.identical(fromHex('0x0.ffffffffffffe4p-1022'), MIN-2*TINY)
+ self.identical(fromHex('0x0.ffffffffffffe6p-1022'), MIN-2*TINY)
+ self.identical(fromHex('0x0.ffffffffffffe8p-1022'), MIN-2*TINY)
+ self.identical(fromHex('0x0.ffffffffffffeap-1022'), MIN-TINY)
+ self.identical(fromHex('0x0.ffffffffffffecp-1022'), MIN-TINY)
+ self.identical(fromHex('0x0.ffffffffffffeep-1022'), MIN-TINY)
+ self.identical(fromHex('0x0.fffffffffffff0p-1022'), MIN-TINY)
+ self.identical(fromHex('0x0.fffffffffffff2p-1022'), MIN-TINY)
+ self.identical(fromHex('0x0.fffffffffffff4p-1022'), MIN-TINY)
+ self.identical(fromHex('0x0.fffffffffffff6p-1022'), MIN-TINY)
+ self.identical(fromHex('0x0.fffffffffffff8p-1022'), MIN)
+ self.identical(fromHex('0x0.fffffffffffffap-1022'), MIN)
+ self.identical(fromHex('0x0.fffffffffffffcp-1022'), MIN)
+ self.identical(fromHex('0x0.fffffffffffffep-1022'), MIN)
+ self.identical(fromHex('0x1.00000000000000p-1022'), MIN)
+ self.identical(fromHex('0x1.00000000000002p-1022'), MIN)
+ self.identical(fromHex('0x1.00000000000004p-1022'), MIN)
+ self.identical(fromHex('0x1.00000000000006p-1022'), MIN)
+ self.identical(fromHex('0x1.00000000000008p-1022'), MIN)
+ self.identical(fromHex('0x1.0000000000000ap-1022'), MIN+TINY)
+ self.identical(fromHex('0x1.0000000000000cp-1022'), MIN+TINY)
+ self.identical(fromHex('0x1.0000000000000ep-1022'), MIN+TINY)
+ self.identical(fromHex('0x1.00000000000010p-1022'), MIN+TINY)
+ self.identical(fromHex('0x1.00000000000012p-1022'), MIN+TINY)
+ self.identical(fromHex('0x1.00000000000014p-1022'), MIN+TINY)
+ self.identical(fromHex('0x1.00000000000016p-1022'), MIN+TINY)
+ self.identical(fromHex('0x1.00000000000018p-1022'), MIN+2*TINY)
+
+ # ... and near 1.0.
+ self.identical(fromHex('0x0.fffffffffffff0p0'), 1.0-EPS)
+ self.identical(fromHex('0x0.fffffffffffff1p0'), 1.0-EPS)
+ self.identical(fromHex('0X0.fffffffffffff2p0'), 1.0-EPS)
+ self.identical(fromHex('0x0.fffffffffffff3p0'), 1.0-EPS)
+ self.identical(fromHex('0X0.fffffffffffff4p0'), 1.0-EPS)
+ self.identical(fromHex('0X0.fffffffffffff5p0'), 1.0-EPS/2)
+ self.identical(fromHex('0X0.fffffffffffff6p0'), 1.0-EPS/2)
+ self.identical(fromHex('0x0.fffffffffffff7p0'), 1.0-EPS/2)
+ self.identical(fromHex('0x0.fffffffffffff8p0'), 1.0-EPS/2)
+ self.identical(fromHex('0X0.fffffffffffff9p0'), 1.0-EPS/2)
+ self.identical(fromHex('0X0.fffffffffffffap0'), 1.0-EPS/2)
+ self.identical(fromHex('0x0.fffffffffffffbp0'), 1.0-EPS/2)
+ self.identical(fromHex('0X0.fffffffffffffcp0'), 1.0)
+ self.identical(fromHex('0x0.fffffffffffffdp0'), 1.0)
+ self.identical(fromHex('0X0.fffffffffffffep0'), 1.0)
+ self.identical(fromHex('0x0.ffffffffffffffp0'), 1.0)
+ self.identical(fromHex('0X1.00000000000000p0'), 1.0)
+ self.identical(fromHex('0X1.00000000000001p0'), 1.0)
+ self.identical(fromHex('0x1.00000000000002p0'), 1.0)
+ self.identical(fromHex('0X1.00000000000003p0'), 1.0)
+ self.identical(fromHex('0x1.00000000000004p0'), 1.0)
+ self.identical(fromHex('0X1.00000000000005p0'), 1.0)
+ self.identical(fromHex('0X1.00000000000006p0'), 1.0)
+ self.identical(fromHex('0X1.00000000000007p0'), 1.0)
+ self.identical(fromHex('0x1.00000000000007ffffffffffffffffffffp0'),
+ 1.0)
+ self.identical(fromHex('0x1.00000000000008p0'), 1.0)
+ self.identical(fromHex('0x1.00000000000008000000000000000001p0'),
+ 1+EPS)
+ self.identical(fromHex('0X1.00000000000009p0'), 1.0+EPS)
+ self.identical(fromHex('0x1.0000000000000ap0'), 1.0+EPS)
+ self.identical(fromHex('0x1.0000000000000bp0'), 1.0+EPS)
+ self.identical(fromHex('0X1.0000000000000cp0'), 1.0+EPS)
+ self.identical(fromHex('0x1.0000000000000dp0'), 1.0+EPS)
+ self.identical(fromHex('0x1.0000000000000ep0'), 1.0+EPS)
+ self.identical(fromHex('0X1.0000000000000fp0'), 1.0+EPS)
+ self.identical(fromHex('0x1.00000000000010p0'), 1.0+EPS)
+ self.identical(fromHex('0X1.00000000000011p0'), 1.0+EPS)
+ self.identical(fromHex('0x1.00000000000012p0'), 1.0+EPS)
+ self.identical(fromHex('0X1.00000000000013p0'), 1.0+EPS)
+ self.identical(fromHex('0X1.00000000000014p0'), 1.0+EPS)
+ self.identical(fromHex('0x1.00000000000015p0'), 1.0+EPS)
+ self.identical(fromHex('0x1.00000000000016p0'), 1.0+EPS)
+ self.identical(fromHex('0X1.00000000000017p0'), 1.0+EPS)
+ self.identical(fromHex('0x1.00000000000017ffffffffffffffffffffp0'),
+ 1.0+EPS)
+ self.identical(fromHex('0x1.00000000000018p0'), 1.0+2*EPS)
+ self.identical(fromHex('0X1.00000000000018000000000000000001p0'),
+ 1.0+2*EPS)
+ self.identical(fromHex('0x1.00000000000019p0'), 1.0+2*EPS)
+ self.identical(fromHex('0X1.0000000000001ap0'), 1.0+2*EPS)
+ self.identical(fromHex('0X1.0000000000001bp0'), 1.0+2*EPS)
+ self.identical(fromHex('0x1.0000000000001cp0'), 1.0+2*EPS)
+ self.identical(fromHex('0x1.0000000000001dp0'), 1.0+2*EPS)
+ self.identical(fromHex('0x1.0000000000001ep0'), 1.0+2*EPS)
+ self.identical(fromHex('0X1.0000000000001fp0'), 1.0+2*EPS)
+ self.identical(fromHex('0x1.00000000000020p0'), 1.0+2*EPS)
+
+ def test_roundtrip(self):
+ def roundtrip(x):
+ return float.fromhex(x.hex())
+ import sys
+ import math
+ TINY = float.fromhex('0x0.0000000000001p-1022') # min subnormal
+
+ for x in [float("nan"), float("inf"), sys.float_info.max,
+ sys.float_info.min, sys.float_info.min-TINY, TINY, 0.0]:
+ self.identical(x, roundtrip(x))
+ self.identical(-x, roundtrip(-x))
+
+ # fromHex(toHex(x)) should exactly recover x, for any non-NaN float x.
+ import random
+ for i in xrange(500):
+ e = random.randrange(-1200, 1200)
+ m = random.random()
+ s = random.choice([1.0, -1.0])
+ try:
+ x = s*math.ldexp(m, e)
+ except OverflowError:
+ pass
+ else:
+ self.identical(x, float.fromhex(x.hex()))
More information about the Pypy-commit
mailing list