1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
|
import math
import py
import sys
import random
import struct
from rpython.rlib.mutbuffer import MutableStringBuffer
from rpython.rlib.rstruct import ieee
from rpython.rlib.rfloat import NAN, INFINITY
from rpython.translator.c.test.test_genc import compile
class TestFloatSpecific:
def test_halffloat_exact(self):
#testcases generated from numpy.float16(x).view('uint16')
cases = [[0, 0], [10, 18688], [-10, 51456], [10e3, 28898],
[float('inf'), 31744], [-float('inf'), 64512]]
for c, h in cases:
hbit = ieee.float_pack(c, 2)
assert hbit == h
assert c == ieee.float_unpack(h, 2)
def test_halffloat_inexact(self):
#testcases generated from numpy.float16(x).view('uint16')
cases = [[10.001, 18688, 10.], [-10.001, 51456, -10],
[0.027588, 10000, 0.027587890625],
[22001, 30047, 22000]]
for c, h, f in cases:
hbit = ieee.float_pack(c, 2)
assert hbit == h
assert f == ieee.float_unpack(h, 2)
def test_halffloat_overunderflow(self):
cases = [[670000, float('inf')], [-67000, -float('inf')],
[1e-08, 0], [-1e-8, -0.]]
for f1, f2 in cases:
try:
f_out = ieee.float_unpack(ieee.float_pack(f1, 2), 2)
except OverflowError:
f_out = math.copysign(float('inf'), f1)
assert f_out == f2
assert math.copysign(1., f_out) == math.copysign(1., f2)
def test_float80_exact(self):
s = []
ieee.pack_float80(s, -1., 16, False)
assert repr(s[-1]) == repr('\x00\x00\x00\x00\x00\x00\x00\x80\xff\xbf\x00\x00\x00\x00\x00\x00')
ieee.pack_float80(s, -1., 16, True)
assert repr(s[-1]) == repr('\x00\x00\x00\x00\x00\x00\xbf\xff\x80\x00\x00\x00\x00\x00\x00\x00')
ieee.pack_float80(s, -123.456, 16, False)
assert repr(s[-1]) == repr('\x00\xb8\xf3\xfd\xd4x\xe9\xf6\x05\xc0\x00\x00\x00\x00\x00\x00')
ieee.pack_float80(s, -123.456, 16, True)
assert repr(s[-1]) == repr('\x00\x00\x00\x00\x00\x00\xc0\x05\xf6\xe9x\xd4\xfd\xf3\xb8\x00')
x = ieee.unpack_float80('\x00\x00\x00\x00\x00\x00\x00\x80\xff?\xc8\x01\x00\x00\x00\x00', False)
assert x == 1.0
x = ieee.unpack_float80('\x00\x00\x7f\x83\xe1\x91?\xff\x80\x00\x00\x00\x00\x00\x00\x00', True)
assert x == 1.0
class TestFloatPacking:
def check_float(self, x):
# check roundtrip
for size in [10, 12, 16]:
for be in [False, True]:
Q = []
ieee.pack_float80(Q, x, size, be)
Q = Q[0]
y = ieee.unpack_float80(Q, be)
assert repr(x) == repr(y), '%r != %r, Q=%r' % (x, y, Q)
for be in [False, True]:
buf = MutableStringBuffer(8)
ieee.pack_float(buf, 0, x, 8, be)
Q = buf.finish()
y = ieee.unpack_float(Q, be)
assert repr(x) == repr(y), '%r != %r, Q=%r' % (x, y, Q)
# check that packing agrees with the struct module
struct_pack8 = struct.unpack('<Q', struct.pack('<d', x))[0]
float_pack8 = ieee.float_pack(x, 8)
assert struct_pack8 == float_pack8
# check that packing agrees with the struct module
try:
struct_pack4 = struct.unpack('<L', struct.pack('<f', x))[0]
except OverflowError:
struct_pack4 = "overflow"
try:
float_pack4 = ieee.float_pack(x, 4)
except OverflowError:
float_pack4 = "overflow"
assert struct_pack4 == float_pack4
if float_pack4 == "overflow":
return
# if we didn't overflow, try round-tripping the binary32 value
roundtrip = ieee.float_pack(ieee.float_unpack(float_pack4, 4), 4)
assert float_pack4 == roundtrip
try:
float_pack2 = ieee.float_pack(x, 2)
except OverflowError:
return
roundtrip = ieee.float_pack(ieee.float_unpack(float_pack2, 2), 2)
assert (float_pack2, x) == (roundtrip, x)
def test_infinities(self):
self.check_float(float('inf'))
self.check_float(float('-inf'))
def test_zeros(self):
self.check_float(0.0)
self.check_float(-0.0)
def test_nans(self):
self.check_float(float('nan'))
def test_simple(self):
test_values = [1e-10, 0.00123, 0.5, 0.7, 1.0, 123.456, 1e10]
for value in test_values:
self.check_float(value)
self.check_float(-value)
def test_subnormal(self):
# special boundaries
self.check_float(2**-1074)
self.check_float(2**-1022)
self.check_float(2**-1021)
self.check_float((2**53-1)*2**-1074)
self.check_float((2**52-1)*2**-1074)
self.check_float((2**52+1)*2**-1074)
# other subnormals
self.check_float(1e-309)
self.check_float(1e-320)
def test_powers_of_two(self):
# exact powers of 2
for k in range(-1074, 1024):
self.check_float(2.**k)
# and values near powers of 2
for k in range(-1074, 1024):
self.check_float((2 - 2**-52) * 2.**k)
def test_float4_boundaries(self):
# Exercise IEEE 754 binary32 boundary cases.
self.check_float(2**128.)
# largest representable finite binary32 value
self.check_float((1 - 2.**-24) * 2**128.)
# halfway case: rounds up to an overflowing value
self.check_float((1 - 2.**-25) * 2**128.)
self.check_float(2**-125)
# smallest normal
self.check_float(2**-126)
# smallest positive binary32 value (subnormal)
self.check_float(2**-149)
# 2**-150 should round down to 0
self.check_float(2**-150)
# but anything even a tiny bit larger should round up to 2**-149
self.check_float((1 + 2**-52) * 2**-150)
def test_random(self):
# construct a Python float from random integer, using struct
mantissa_mask = (1 << 53) - 1
for _ in xrange(10000):
Q = random.randrange(2**64)
x = struct.unpack('<d', struct.pack('<Q', Q))[0]
# nans are tricky: we can't hope to reproduce the bit
# pattern exactly, so check_float will fail for a nan
# whose mantissa does not fit into float16's mantissa.
if math.isnan(x) and (Q & mantissa_mask) >= 1 << 11:
continue
self.check_float(x)
def test_various_nans(self):
# check patterns that should preserve the mantissa across nan conversions
maxmant64 = (1 << 52) - 1 # maximum double mantissa
maxmant16 = (1 << 10) - 1 # maximum float16 mantissa
assert maxmant64 >> 42 == maxmant16
exp = 0xfff << 52
for i in range(20):
val_to_preserve = exp | ((maxmant16 - i) << 42)
a = ieee.float_unpack(val_to_preserve, 8)
assert math.isnan(a), 'i %d, maxmant %s' % (i, hex(val_to_preserve))
b = ieee.float_pack(a, 8)
assert b == val_to_preserve, 'i %d, val %s b %s' % (i, hex(val_to_preserve), hex(b))
b = ieee.float_pack(a, 2)
assert b == 0xffff - i, 'i %d, b%s' % (i, hex(b))
class TestCompiled:
def test_pack_float(self):
def pack(x, size):
buf = MutableStringBuffer(size)
ieee.pack_float(buf, 0, x, size, False)
l = []
for c in buf.finish():
l.append(str(ord(c)))
return ','.join(l)
c_pack = compile(pack, [float, int])
def unpack(s):
l = s.split(',')
s = ''.join([chr(int(x)) for x in l])
return ieee.unpack_float(s, False)
c_unpack = compile(unpack, [str])
def check_roundtrip(x, size):
s = c_pack(x, size)
if not math.isnan(x):
# pack uses copysign which is ambiguous for NAN
assert s == pack(x, size)
assert unpack(s) == x
assert c_unpack(s) == x
else:
assert math.isnan(unpack(s))
assert math.isnan(c_unpack(s))
for size in [2, 4, 8]:
check_roundtrip(123.4375, size)
check_roundtrip(-123.4375, size)
check_roundtrip(INFINITY, size)
check_roundtrip(NAN, size)
|
