2 from random
import randint
3 from random
import seed
5 from sfpy
import Float64
8 return x
& 0x000fffffffffffff
11 return ((x
& 0x7ff0000000000000) >> 52) - 1023
14 return ((x
& 0x8000000000000000) >> 63)
17 return get_exponent(x
) == 1024 and get_mantissa(x
) != 0
20 return get_exponent(x
) == 1024 and get_mantissa(x
) == 0
23 return is_inf(x
) and not get_sign(x
)
26 return is_inf(x
) and get_sign(x
)
30 (is_pos_inf(x
) and is_pos_inf(y
)) or
31 (is_neg_inf(x
) and is_neg_inf(y
)) or
32 (is_nan(x
) and is_nan(y
)) or
36 def get_case(dut
, a
, b
):
37 yield dut
.in_a
.v
.eq(a
)
38 yield dut
.in_a
.stb
.eq(1)
41 a_ack
= (yield dut
.in_a
.ack
)
43 yield dut
.in_b
.v
.eq(b
)
44 yield dut
.in_b
.stb
.eq(1)
45 b_ack
= (yield dut
.in_b
.ack
)
50 out_z_stb
= (yield dut
.out_z
.stb
)
53 yield dut
.in_a
.stb
.eq(0)
54 yield dut
.in_b
.stb
.eq(0)
55 yield dut
.out_z
.ack
.eq(1)
57 yield dut
.out_z
.ack
.eq(0)
62 out_z
= yield dut
.out_z
.v
65 def check_case(dut
, a
, b
, z
):
66 out_z
= yield from get_case(dut
, a
, b
)
67 assert out_z
== z
, "Output z 0x%x not equal to expected 0x%x" % (out_z
, z
)
70 def run_test(dut
, stimulus_a
, stimulus_b
, op
):
72 expected_responses
= []
74 for a
, b
in zip(stimulus_a
, stimulus_b
):
75 af
= Float64
.from_bits(a
)
76 bf
= Float64
.from_bits(b
)
78 expected_responses
.append(z
.get_bits())
80 actual
= yield from get_case(dut
, a
, b
)
81 actual_responses
.append(actual
)
83 if len(actual_responses
) < len(expected_responses
):
84 print ("Fail ... not enough results")
87 for exp
, act
, a
, b
in zip(expected_responses
, actual_responses
,
88 stimulus_a
, stimulus_b
):
89 passed
= match(exp
, act
)
93 print ("Fail ... expected:", hex(exp
), "actual:", hex(act
))
96 print ("a mantissa:", a
& 0x000fffffffffffff)
97 print ("a exponent:", ((a
& 0x7ff0000000000000) >> 52)\
99 print ("a sign:", ((a
& 0x8000000000000000) >> 63))
102 print ("b mantissa:", b
& 0x000fffffffffffff)
103 print ("b exponent:", ((b
& 0x7ff0000000000000) >> 52)\
105 print ("b sign:", ((b
& 0x8000000000000000) >> 63))
108 print ("expected mantissa:", exp
& 0x000fffffffffffff)
109 print ("expected exponent:", ((exp
& 0x7ff0000000000000) >> 52)\
111 print ("expected sign:", ((exp
& 0x8000000000000000) >> 63))
114 print ("actual mantissa:", act
& 0x000fffffffffffff)
115 print ("actual exponent:", ((act
& 0x7ff0000000000000) >> 52)\
117 print ("actual sign:", ((act
& 0x8000000000000000) >> 63))
122 def run_corner_cases(dut
, count
, op
):
124 from itertools
import permutations
125 stimulus_a
= [i
[0] for i
in permutations([
133 stimulus_b
= [i
[1] for i
in permutations([
141 yield from run_test(dut
, stimulus_a
, stimulus_b
, op
)
142 count
+= len(stimulus_a
)
143 print (count
, "vectors passed")
146 def run_edge_cases(dut
, count
, op
):
148 stimulus_a
= [0x8000000000000000 for i
in range(1000)]
149 stimulus_b
= [randint(0, 1<<64) for i
in range(1000)]
150 yield from run_test(dut
, stimulus_a
, stimulus_b
, op
)
151 count
+= len(stimulus_a
)
152 print (count
, "vectors passed")
154 stimulus_a
= [0x0000000000000000 for i
in range(1000)]
155 stimulus_b
= [randint(0, 1<<64) for i
in range(1000)]
156 yield from run_test(dut
, stimulus_a
, stimulus_b
, op
)
157 count
+= len(stimulus_a
)
158 print (count
, "vectors passed")
160 stimulus_b
= [0x8000000000000000 for i
in range(1000)]
161 stimulus_a
= [randint(0, 1<<64) for i
in range(1000)]
162 yield from run_test(dut
, stimulus_a
, stimulus_b
, op
)
163 count
+= len(stimulus_a
)
164 print (count
, "vectors passed")
166 stimulus_b
= [0x0000000000000000 for i
in range(1000)]
167 stimulus_a
= [randint(0, 1<<64) for i
in range(1000)]
168 yield from run_test(dut
, stimulus_a
, stimulus_b
, op
)
169 count
+= len(stimulus_a
)
170 print (count
, "vectors passed")
172 stimulus_a
= [0x7FF8000000000000 for i
in range(1000)]
173 stimulus_b
= [randint(0, 1<<64) for i
in range(1000)]
174 yield from run_test(dut
, stimulus_a
, stimulus_b
, op
)
175 count
+= len(stimulus_a
)
176 print (count
, "vectors passed")
178 stimulus_a
= [0xFFF8000000000000 for i
in range(1000)]
179 stimulus_b
= [randint(0, 1<<64) for i
in range(1000)]
180 yield from run_test(dut
, stimulus_a
, stimulus_b
, op
)
181 count
+= len(stimulus_a
)
182 print (count
, "vectors passed")
184 stimulus_b
= [0x7FF8000000000000 for i
in range(1000)]
185 stimulus_a
= [randint(0, 1<<64) for i
in range(1000)]
186 yield from run_test(dut
, stimulus_a
, stimulus_b
, op
)
187 count
+= len(stimulus_a
)
188 print (count
, "vectors passed")
190 stimulus_b
= [0xFFF8000000000000 for i
in range(1000)]
191 stimulus_a
= [randint(0, 1<<64) for i
in range(1000)]
192 yield from run_test(dut
, stimulus_a
, stimulus_b
, op
)
193 count
+= len(stimulus_a
)
194 print (count
, "vectors passed")
196 stimulus_a
= [0x7FF0000000000000 for i
in range(1000)]
197 stimulus_b
= [randint(0, 1<<64) for i
in range(1000)]
198 yield from run_test(dut
, stimulus_a
, stimulus_b
, op
)
199 count
+= len(stimulus_a
)
200 print (count
, "vectors passed")
202 stimulus_a
= [0xFFF0000000000000 for i
in range(1000)]
203 stimulus_b
= [randint(0, 1<<64) for i
in range(1000)]
204 yield from run_test(dut
, stimulus_a
, stimulus_b
, op
)
205 count
+= len(stimulus_a
)
206 print (count
, "vectors passed")
208 stimulus_b
= [0x7FF0000000000000 for i
in range(1000)]
209 stimulus_a
= [randint(0, 1<<64) for i
in range(1000)]
210 yield from run_test(dut
, stimulus_a
, stimulus_b
, op
)
211 count
+= len(stimulus_a
)
212 print (count
, "vectors passed")
214 stimulus_b
= [0xFFF0000000000000 for i
in range(1000)]
215 stimulus_a
= [randint(0, 1<<64) for i
in range(1000)]
216 yield from run_test(dut
, stimulus_a
, stimulus_b
, op
)
217 count
+= len(stimulus_a
)
218 print (count
, "vectors passed")
221 for i
in range(100000):
222 stimulus_a
= [randint(0, 1<<64) for i
in range(1000)]
223 stimulus_b
= [randint(0, 1<<64) for i
in range(1000)]
224 yield from run_test(dut
, stimulus_a
, stimulus_b
, op
)
226 print (count
, "random vectors passed")