From 8b871940eb695be3550bd923f7bff6efe4bb9117 Mon Sep 17 00:00:00 2001
From: 7400 <>
Date: Fri, 17 Nov 2023 08:30:23 -0800
Subject: [PATCH] WIP: IEEE754

---
 test/TestIEEE754.py  | 31 ++++++++++++++++++++++++++-----
 test/TestIEEE754.sol | 22 +++++++++++++++-------
 2 files changed, 41 insertions(+), 12 deletions(-)

diff --git a/test/TestIEEE754.py b/test/TestIEEE754.py
index 44c5236..58e46ea 100755
--- a/test/TestIEEE754.py
+++ b/test/TestIEEE754.py
@@ -20,9 +20,30 @@ def fixedPoint(n, shift) :
     else :
         return Fraction(n) / (1<<-shift)
 
-number = fixedPoint(0xffffff, 127-23) # Largest number
-number = fixedPoint(0x1, -128) # Smallest number
+def print_float_fix(number) :
+    float_int32, float_bytes = to_float_bits(number)
+    print (f"float hex: 0x{float_int32:08x} 0x{int(number*(1<<128)):x}")
+    # print ("float hex:",  float_bytes.hex(), hex(int(number*(1<<128))))
 
-float_int32, float_bytes = to_float_bits(number)
-print ("float hex:",  float_bytes.hex(), hex(int(number*(1<<128))))
-print ("float hex:",  hex(float_int32), hex(int(number*(1<<128))))
+print("Assuming 128.128 fixed point")
+print("largest number:")
+number = fixedPoint(0xffffff, 127-24) # Largest number that converts to FP and fits in 128.128
+assert number < 1<<256
+# print (hex(1<<255))
+# print (hex(int(number)<<128))
+print_float_fix(number)
+print("negative largest number:")
+number = fixedPoint(-0xffffff, 127-24) # Largest number
+print_float_fix(number)
+print("smallest number:")
+number = fixedPoint(0x1, -128) # Smallest number
+print_float_fix(number)
+print("negative smallest number:")
+number = fixedPoint(-0x1, -128)
+print_float_fix(number)
+print()
+
+# number = fixedPoint(0x7fffff, 127-23)
+# print_float_fix(number)
+# number = fixedPoint(0xffffff, 127-23)
+# print_float_fix(number)
diff --git a/test/TestIEEE754.sol b/test/TestIEEE754.sol
index 1b10c40..ae17fe2 100644
--- a/test/TestIEEE754.sol
+++ b/test/TestIEEE754.sol
@@ -40,7 +40,8 @@ library IEEE754 {
         // Extract mantisa
     
         int256 mant = int32(floatingPoint & MANT_MASK);
-        if (exp != ESUBNORM) mant |= MSB;                 // Add implied MSB to non-subnormal
+        if (exp == ESUBNORM) mant <<= 1;
+        else mant |= MSB;                 // Add implied MSB to non-subnormal
         if (floatingPoint & SIGN_MASK != 0) mant = -mant; // Negate if sign bit set
 
         // Compute shift amount
@@ -110,23 +111,30 @@ contract TestIEEE754 is Test {
         int256 fixedPoint;
     }
 
-    function testFloat2fixed() external pure {
+    function xtestFloat2fixed() external pure {
         console2.log('TestIEEE754.testFloat2fixed()');
 
-        Item[6] memory items = [
+        Item[11] memory items = [
             Item(0x3f800000, 0, 1 << 0),      // 1.0
             Item(0x3f800000, 128, 1 << 128),  // 1.0
             Item(0x3f800000, 254, 1 << 254),  // 1.0
             Item(0xbf800000, 128, -1 << 128), // -1.0
             Item(0x40000000, 128, 2 << 128),  // 1.0
-            Item(0xc0000000, 128, -2 << 128)  // 1.0
-            // ,Item(0xbf800001, 128, -1 << 128) // Failing case for test debugging purposes
+            Item(0xc0000000, 128, -2 << 128),  // 1.0
+            Item(0x00200000, 128, int256(uint256(0x1))), // smallest positive is subnormal
+            Item(0x80200000, 128, int256(uint256(int256(-0x1)))), // smallest negative is subnormal
+            Item(0x7effffff, 128, int256(uint256(0x7fffff8000000000000000000000000000000000000000000000000000000000))), // largest positive
+            Item(0xff7fffff, 128, -int256(uint256(0xffffff0000000000000000000000000000000000000000000000000000000000))), // largest negative
+            Item(0x7f7fffff, 120, int256(uint256(0xffffff0000000000000000000000000000000000000000000000000000000000)))
         ];
 
         for (uint i=0; i<items.length; i++) {
-            require(items[i].fixedPoint == IEEE754.float2fixed(
+            console2.log("exp: %x", uint256(items[i].fixedPoint));
+            int256 fixedPoint = IEEE754.float2fixed(
                 items[i].floatingPoint, items[i].fixedBits
-                ));
+                );
+            console2.log("got: %x", uint256(fixedPoint));
+            require(items[i].fixedPoint == fixedPoint);
         }
 
     }