src/ieee754/fpcommon/test/unit_test_double.py

   1 import sys
   2 from random import randint
   3 from random import seed
   4
   5 from sfpy import Float64
   6
   7 max_e = 1024
   8
   9 def get_mantissa(x):
  10     return x & 0x000fffffffffffff
  11
  12 def get_exponent(x):
  13     return ((x & 0x7ff0000000000000) >> 52) - 1023
  14
  15 def set_exponent(x, e):
  16     return (x & ~0x7ff0000000000000) | ((e+1023) << 52)
  17
  18 def get_sign(x):
  19     return ((x & 0x8000000000000000) >> 63)
  20
  21 def is_nan(x):
  22     return get_exponent(x) == 1024 and get_mantissa(x) != 0
  23
  24 def is_inf(x):
  25     return get_exponent(x) == 1024 and get_mantissa(x) == 0
  26
  27 def is_pos_inf(x):
  28     return is_inf(x) and not get_sign(x)
  29
  30 def is_neg_inf(x):
  31     return is_inf(x) and get_sign(x)
  32
  33 def match(x, y):
  34     return (
  35         (is_pos_inf(x) and is_pos_inf(y)) or
  36         (is_neg_inf(x) and is_neg_inf(y)) or
  37         (is_nan(x) and is_nan(y)) or
  38         (x == y)
  39         )
  40
  41 def create(s, e, m):
  42     return set_exponent((s<<63) | m, e)
  43
  44 def inf(s):
  45     return create(s, 1024, 0)
  46
  47 def nan(s):
  48     return create(s, 1024, 1<<51)
  49
  50 def zero(s):
  51     return s<<63
  52
  53 def get_case(dut, a, b):
  54     yield dut.in_a.v.eq(a)
  55     yield dut.in_a.stb.eq(1)
  56     yield
  57     yield
  58     a_ack = (yield dut.in_a.ack)
  59     assert a_ack == 0
  60     yield dut.in_b.v.eq(b)
  61     yield dut.in_b.stb.eq(1)
  62     b_ack = (yield dut.in_b.ack)
  63     assert b_ack == 0
  64
  65     while True:
  66         yield
  67         out_z_stb = (yield dut.out_z.stb)
  68         if not out_z_stb:
  69             continue
  70         yield dut.in_a.stb.eq(0)
  71         yield dut.in_b.stb.eq(0)
  72         yield dut.out_z.ack.eq(1)
  73         yield
  74         yield dut.out_z.ack.eq(0)
  75         yield
  76         yield
  77         break
  78
  79     out_z = yield dut.out_z.v
  80     return out_z
  81
  82 def check_case(dut, a, b, z):
  83     out_z = yield from get_case(dut, a, b)
  84     assert out_z == z, "Output z 0x%x not equal to expected 0x%x" % (out_z, z)
  85
  86
  87 def run_fpunit(dut, stimulus_a, stimulus_b, op):
  88
  89     expected_responses = []
  90     actual_responses = []
  91     for a, b in zip(stimulus_a, stimulus_b):
  92         af = Float64.from_bits(a)
  93         bf = Float64.from_bits(b)
  94         z = op(af, bf)
  95         expected_responses.append(z.get_bits())
  96         #print (af, bf, z)
  97         actual = yield from get_case(dut, a, b)
  98         actual_responses.append(actual)
  99
 100     if len(actual_responses) < len(expected_responses):
 101         print ("Fail ... not enough results")
 102         exit(0)
 103
 104     for exp, act, a, b in zip(expected_responses, actual_responses,
 105                                       stimulus_a, stimulus_b):
 106         passed = match(exp, act)
 107
 108         if not passed:
 109
 110             print ("Fail ... expected:", hex(exp), "actual:", hex(act))
 111
 112             print (hex(a))
 113             print ("a mantissa:",              a & 0x000fffffffffffff)
 114             print ("a exponent:",            ((a & 0x7ff0000000000000) >> 52)\
 115                                                 - 1023)
 116             print ("a sign:",                ((a & 0x8000000000000000) >> 63))
 117
 118             print (hex(b))
 119             print ("b mantissa:",              b & 0x000fffffffffffff)
 120             print ("b exponent:",            ((b & 0x7ff0000000000000) >> 52)\
 121                                                  - 1023)
 122             print ("b sign:",                ((b & 0x8000000000000000) >> 63))
 123
 124             print (hex(exp))
 125             print ("expected mantissa:",   exp & 0x000fffffffffffff)
 126             print ("expected exponent:", ((exp & 0x7ff0000000000000) >> 52)\
 127                                                  - 1023)
 128             print ("expected sign:",     ((exp & 0x8000000000000000) >> 63))
 129
 130             print (hex(act))
 131             print ("actual mantissa:",       act & 0x000fffffffffffff)
 132             print ("actual exponent:",     ((act & 0x7ff0000000000000) >> 52)\
 133                                                  - 1023)
 134             print ("actual sign:",         ((act & 0x8000000000000000) >> 63))
 135
 136             sys.exit(0)
 137
 138
 139 def run_corner_cases(dut, count, op):
 140     #corner cases
 141     from itertools import permutations
 142     stimulus_a = [i[0] for i in permutations([
 143         0x8000000000000000,
 144         0x0000000000000000,
 145         0x7ff8000000000000,
 146         0xfff8000000000000,
 147         0x7ff0000000000000,
 148         0xfff0000000000000
 149     ], 2)]
 150     stimulus_b = [i[1] for i in permutations([
 151         0x8000000000000000,
 152         0x0000000000000000,
 153         0x7ff8000000000000,
 154         0xfff8000000000000,
 155         0x7ff0000000000000,
 156         0xfff0000000000000
 157     ], 2)]
 158     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 159     count += len(stimulus_a)
 160     print (count, "vectors passed")
 161
 162
 163 def run_edge_cases(dut, count, op, maxcount=1000, num_loops=1000):
 164     #edge cases
 165     stimulus_a = [0x8000000000000000 for i in range(maxcount)]
 166     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 167     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 168     count += len(stimulus_a)
 169     print (count, "vectors passed")
 170
 171     stimulus_a = [0x0000000000000000 for i in range(maxcount)]
 172     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 173     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 174     count += len(stimulus_a)
 175     print (count, "vectors passed")
 176
 177     stimulus_b = [0x8000000000000000 for i in range(maxcount)]
 178     stimulus_a = [randint(0, 1<<64)  for i in range(maxcount)]
 179     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 180     count += len(stimulus_a)
 181     print (count, "vectors passed")
 182
 183     stimulus_b = [0x0000000000000000 for i in range(maxcount)]
 184     stimulus_a = [randint(0, 1<<64)  for i in range(maxcount)]
 185     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 186     count += len(stimulus_a)
 187     print (count, "vectors passed")
 188
 189     stimulus_a = [0x7FF8000000000000 for i in range(maxcount)]
 190     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 191     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 192     count += len(stimulus_a)
 193     print (count, "vectors passed")
 194
 195     stimulus_a = [0xFFF8000000000000 for i in range(maxcount)]
 196     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 197     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 198     count += len(stimulus_a)
 199     print (count, "vectors passed")
 200
 201     stimulus_b = [0x7FF8000000000000 for i in range(maxcount)]
 202     stimulus_a = [randint(0, 1<<64) for i in range(maxcount)]
 203     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 204     count += len(stimulus_a)
 205     print (count, "vectors passed")
 206
 207     stimulus_b = [0xFFF8000000000000 for i in range(maxcount)]
 208     stimulus_a = [randint(0, 1<<64) for i in range(maxcount)]
 209     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 210     count += len(stimulus_a)
 211     print (count, "vectors passed")
 212
 213     stimulus_a = [0x7FF0000000000000 for i in range(maxcount)]
 214     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 215     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 216     count += len(stimulus_a)
 217     print (count, "vectors passed")
 218
 219     stimulus_a = [0xFFF0000000000000 for i in range(maxcount)]
 220     stimulus_b = [randint(0, 1<<64)  for i in range(maxcount)]
 221     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 222     count += len(stimulus_a)
 223     print (count, "vectors passed")
 224
 225     stimulus_b = [0x7FF0000000000000 for i in range(maxcount)]
 226     stimulus_a = [randint(0, 1<<64)  for i in range(maxcount)]
 227     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 228     count += len(stimulus_a)
 229     print (count, "vectors passed")
 230
 231     stimulus_b = [0xFFF0000000000000 for i in range(maxcount)]
 232     stimulus_a = [randint(0, 1<<64)  for i in range(maxcount)]
 233     yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 234     count += len(stimulus_a)
 235     print (count, "vectors passed")
 236
 237     #seed(0)
 238     for i in range(num_loops):
 239         stimulus_a = [randint(0, 1<<64) for i in range(maxcount)]
 240         stimulus_b = [randint(0, 1<<64) for i in range(maxcount)]
 241         yield from run_fpunit(dut, stimulus_a, stimulus_b, op)
 242         count += maxcount
 243         print (count, "random vectors passed")
 244