Many more tests

Author: awf

src/gfloat/decode_ndarray.py

@@ -39,37 +39,38 @@ def decode_ndarray(fi: FormatInfo, codes: np.ndarray, np=np) -> np.ndarray:
         signmask = None
         sign = 1.0
 
-    exp = (codes >> t) & ((1 << w) - 1)
+    exp = ((codes >> t) & ((1 << w) - 1)).astype(np.int64)
     significand = codes & ((1 << t) - 1)
     if fi.is_twos_complement:
         significand = np.where(sign < 0, (1 << t) - significand, significand)
 
     expBias = fi.expBias
 
-    iszero = (exp == 0) & (significand == 0) if fi.has_zero else False
-    issubnormal = (exp == 0) & (significand != 0) if fi.has_subnormals else False
+    iszero = (exp == 0) & (significand == 0) & fi.has_zero
+    issubnormal = (exp == 0) & (significand != 0) & fi.has_subnormals
     isnormal = ~iszero & ~issubnormal
     expval = np.where(~isnormal, 1 - expBias, exp - expBias)
     fsignificand = np.where(~isnormal, significand * 2**-t, 1.0 + significand * 2**-t)
 
     # Normal/Subnormal/Zero case, other values will be overwritten
     fval = np.where(iszero, 0.0, sign * fsignificand * 2.0**expval)
 
-    # All-bits-special exponent (ABSE)
-    if w > 0:
-        abse = exp == 2**w - 1
-        min_i_with_nan = 2 ** (p - 1) - fi.num_high_nans
-        fval = np.where(abse & (significand >= min_i_with_nan), np.nan, fval)
-        if fi.has_infs:
-            fval = np.where(
-                abse & (significand == min_i_with_nan - 1), np.inf * sign, fval
-            )
+    if fi.has_infs:
+        fval = np.where(codes == fi.code_of_posinf, np.inf, fval)
+        fval = np.where(codes == fi.code_of_neginf, -np.inf, fval)
+
+    if fi.num_nans > 0:
+        code_is_nan = codes == fi.code_of_nan
+        if w > 0:
+            # All-bits-special exponent (ABSE)
+            abse = exp == 2**w - 1
+            min_code_with_nan = 2 ** (p - 1) - fi.num_high_nans
+            code_is_nan |= abse & (significand >= min_code_with_nan)
+
+        fval = np.where(code_is_nan, np.nan, fval)
 
     # Negative zero
     if fi.has_nz:
         fval = np.where(iszero & (sign < 0), -0.0, fval)
-    else:
-        # Negative zero slot is nan
-        fval = np.where(codes == fi.code_of_negzero, np.nan, fval)
 
     return fval

test/test_decode.py

@@ -24,7 +24,7 @@ def dec(code: int) -> float:
     if method == "array":
 
         def dec(code: int) -> float:
-            asnp = np.tile(np.array(code, dtype=np.int64), (2, 3))
+            asnp = np.tile(np.array(code, dtype=np.uint64), (2, 3))
             vals = decode_ndarray(fi, asnp)
             val = vals.item(0)
             np.testing.assert_equal(val, vals)
@@ -50,10 +50,10 @@ def test_spot_check_ocp_e5m2(method) -> None:
     assert fclass(0x00) == FloatClass.ZERO
 
 
-def test_spot_check_ocp_e4m3() -> None:
+@pytest.mark.parametrize("method", methods)
+def test_spot_check_ocp_e4m3(method) -> None:
     fi = format_info_ocp_e4m3
-    dec = lambda code: decode_float(fi, code).fval
-
+    dec = get_method(method, fi)
     assert dec(0x40) == 2.0
     assert dec(0x01) == 2.0**-9
     assert _isnegzero(dec(0x80))
@@ -62,9 +62,10 @@ def test_spot_check_ocp_e4m3() -> None:
     assert np.floor(np.log2(dec(0x7E))) == fi.emax
 
 
-def test_spot_check_p3109_p3() -> None:
+@pytest.mark.parametrize("method", methods)
+def test_spot_check_p3109_p3(method: str) -> None:
     fi = format_info_p3109(3)
-    dec = lambda code: decode_float(fi, code).fval
+    dec = get_method(method, fi)
 
     assert dec(0x01) == 2.0**-17
     assert dec(0x40) == 1.0
@@ -73,9 +74,10 @@ def test_spot_check_p3109_p3() -> None:
     assert np.floor(np.log2(dec(0x7E))) == fi.emax
 
 
-def test_spot_check_p3109_p1() -> None:
+@pytest.mark.parametrize("method", methods)
+def test_spot_check_p3109_p1(method: str) -> None:
     fi = format_info_p3109(1)
-    dec = lambda code: decode_float(fi, code).fval
+    dec = get_method(method, fi)
 
     assert dec(0x01) == 2.0**-62
     assert dec(0x40) == 2.0
@@ -84,9 +86,10 @@ def test_spot_check_p3109_p1() -> None:
     assert np.floor(np.log2(dec(0x7E))) == fi.emax
 
 
-def test_spot_check_binary16() -> None:
+@pytest.mark.parametrize("method", methods)
+def test_spot_check_binary16(method: str) -> None:
     fi = format_info_binary16
-    dec = lambda code: decode_float(fi, code).fval
+    dec = get_method(method, fi)
 
     assert dec(0x3C00) == 1.0
     assert dec(0x3C01) == 1.0 + 2**-10
@@ -98,9 +101,10 @@ def test_spot_check_binary16() -> None:
     assert np.isnan(dec(0x7FFF))
 
 
-def test_spot_check_bfloat16() -> None:
+@pytest.mark.parametrize("method", methods)
+def test_spot_check_bfloat16(method: str) -> None:
     fi = format_info_bfloat16
-    dec = lambda code: decode_float(fi, code).fval
+    dec = get_method(method, fi)
 
     assert dec(0x3F80) == 1
     assert dec(0x4000) == 2
@@ -111,10 +115,11 @@ def test_spot_check_bfloat16() -> None:
     assert np.isnan(dec(0x7FFF))
 
 
-def test_spot_check_ocp_e2m3() -> None:
+@pytest.mark.parametrize("method", methods)
+def test_spot_check_ocp_e2m3(method: str) -> None:
     # Test against Table 4 in "OCP Microscaling Formats (MX) v1.0 Spec"
     fi = format_info_ocp_e2m3
-    dec = lambda code: decode_float(fi, code).fval
+    dec = get_method(method, fi)
 
     assert fi.max == 7.5
     assert fi.smallest_subnormal == 0.125
@@ -128,10 +133,11 @@ def test_spot_check_ocp_e2m3() -> None:
     assert _isnegzero(dec(0b100000))
 
 
-def test_spot_check_ocp_e3m2() -> None:
+@pytest.mark.parametrize("method", methods)
+def test_spot_check_ocp_e3m2(method: str) -> None:
     # Test against Table 4 in "OCP Microscaling Formats (MX) v1.0 Spec"
     fi = format_info_ocp_e3m2
-    dec = lambda code: decode_float(fi, code).fval
+    dec = get_method(method, fi)
 
     assert fi.max == 28.0
     assert fi.smallest_subnormal == 0.0625
@@ -145,10 +151,11 @@ def test_spot_check_ocp_e3m2() -> None:
     assert _isnegzero(dec(0b100000))
 
 
-def test_spot_check_ocp_e2m1() -> None:
+@pytest.mark.parametrize("method", methods)
+def test_spot_check_ocp_e2m1(method: str) -> None:
     # Test against Table 5 in "OCP Microscaling Formats (MX) v1.0 Spec"
     fi = format_info_ocp_e2m1
-    dec = lambda code: decode_float(fi, code).fval
+    dec = get_method(method, fi)
 
     assert fi.max == 6.0
     assert fi.smallest_subnormal == 0.5
@@ -168,10 +175,11 @@ def test_spot_check_ocp_e2m1() -> None:
     assert _isnegzero(dec(0b1000))
 
 
-def test_spot_check_ocp_e8m0() -> None:
+@pytest.mark.parametrize("method", methods)
+def test_spot_check_ocp_e8m0(method: str) -> None:
     # Test against Table 7 in "OCP Microscaling Formats (MX) v1.0 Spec"
     fi = format_info_ocp_e8m0
-    dec = lambda code: decode_float(fi, code).fval
+    dec = get_method(method, fi)
     fclass = lambda code: decode_float(fi, code).fclass
     assert fi.expBias == 127
     assert fi.max == 2.0**127
@@ -187,10 +195,11 @@ def test_spot_check_ocp_e8m0() -> None:
     assert fclass(0x00) == FloatClass.NORMAL
 
 
-def test_spot_check_ocp_int8() -> None:
+@pytest.mark.parametrize("method", methods)
+def test_spot_check_ocp_int8(method: str) -> None:
     # Test against Table TODO in "OCP Microscaling Formats (MX) v1.0 Spec"
     fi = format_info_ocp_int8
-    dec = lambda code: decode_float(fi, code).fval
+    dec = get_method(method, fi)
 
     assert fi.max == 1.0 + 63.0 / 64
     assert fi.smallest == 2.0**-6
@@ -214,8 +223,9 @@ def test_specials(fi: FormatInfo) -> None:
 
 
 @pytest.mark.parametrize("fi", all_formats)
-def test_specials_decode(fi: FormatInfo) -> None:
-    dec = lambda v: decode_float(fi, v).fval
+@pytest.mark.parametrize("method", methods)
+def test_specials_decode(method: str, fi: FormatInfo) -> None:
+    dec = get_method(method, fi)
 
     if fi.has_zero:
         assert dec(fi.code_of_zero) == 0