Add Float support

Parsing float constants; float +-*/, auto-widening float expressions.

3 files changed, 42 insertions, 10 deletions

diff --git a/chapter12/src/test/java/com/seaofnodes/simple/Chapter08Test.java b/chapter12/src/test/java/com/seaofnodes/simple/Chapter08Test.java
index 730da36a..ac891050 100644
--- a/chapter12/src/test/java/com/seaofnodes/simple/Chapter08Test.java
+++ b/chapter12/src/test/java/com/seaofnodes/simple/Chapter08Test.java
@@ -2,7 +2,6 @@ package com.seaofnodes.simple;
 
 import com.seaofnodes.simple.evaluator.Evaluator;
 import com.seaofnodes.simple.node.*;
-import com.seaofnodes.simple.type.TypeInteger;
 import org.junit.Assert;
 import org.junit.Test;
 
diff --git a/chapter12/src/test/java/com/seaofnodes/simple/Chapter12Test.java b/chapter12/src/test/java/com/seaofnodes/simple/Chapter12Test.java
index 9c352533..63ceaae4 100644
--- a/chapter12/src/test/java/com/seaofnodes/simple/Chapter12Test.java
+++ b/chapter12/src/test/java/com/seaofnodes/simple/Chapter12Test.java
@@ -8,16 +8,34 @@ import org.junit.Test;
 import static org.junit.Assert.assertEquals;
 
 public class Chapter12Test {
-    // A placeholder test used to rapidly rotate through fuzzer produced issues
     @Test
-    public void testFuzzer() {
+    public void testFloat() {
         Parser parser = new Parser(
 """
-return 0;
+return 3.14;
 """);
         StopNode stop = parser.parse(false).iterate(true);
-        assertEquals("return 0;", stop.toString());
-        assertEquals(0L, Evaluator.evaluate(stop,  0));
+        assertEquals("return 3.14;", stop.toString());
+        assertEquals(3.14, Evaluator.evaluate(stop,  0));
     }
 
+    @Test
+    public void testSquareRoot() {
+        Parser parser = new Parser(
+"""
+flt guess = arg;
+while( 1 ) {
+    flt next = (arg/guess + guess)/2;
+    if( next == guess ) break;
+    guess = next;
+}
+return guess;
+""");
+        StopNode stop = parser.parse(false).iterate(true);
+        assertEquals("return Phi(Loop9,(flt)arg,(((ToFloat*Phi_guess)+Phi_guess)*2.0));", stop.toString());
+        assertEquals(3.0, Evaluator.evaluate(stop,  9));
+        assertEquals(1.414213562373095, Evaluator.evaluate(stop,  2));
+    }
+
+
 }
diff --git a/chapter12/src/test/java/com/seaofnodes/simple/evaluator/Evaluator.java b/chapter12/src/test/java/com/seaofnodes/simple/evaluator/Evaluator.java
index 4a405a3b..09bda290 100644
--- a/chapter12/src/test/java/com/seaofnodes/simple/evaluator/Evaluator.java
+++ b/chapter12/src/test/java/com/seaofnodes/simple/evaluator/Evaluator.java
@@ -2,10 +2,7 @@ package com.seaofnodes.simple.evaluator;
 
 import com.seaofnodes.simple.Utils;
 import com.seaofnodes.simple.node.*;
-import com.seaofnodes.simple.type.Field;
-import com.seaofnodes.simple.type.TypeInteger;
-import com.seaofnodes.simple.type.TypeMemPtr;
-import com.seaofnodes.simple.type.TypeStruct;
+import com.seaofnodes.simple.type.*;
 
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
@@ -80,6 +77,10 @@ public class Evaluator {
         long in2 = vall(div.in(2));
         return in2 == 0 ? 0 : vall(div.in(1)) / in2;
     }
+    private double div(DivFNode div) {
+        double in2 = vald(div.in(2));
+        return in2 == 0 ? 0 : vald(div.in(1)) / in2;
+    }
 
     private Object alloc(NewNode alloc) {
         var type = ((TypeMemPtr)alloc.compute())._obj;
@@ -115,10 +116,16 @@ public class Evaluator {
         if (v instanceof Number n) return n.longValue();
         throw new AssertionError("Not a long " + v);
     }
+    private double vald(Node node) {
+        var v = val(node);
+        if (v instanceof Number n) return n.doubleValue();
+        throw new AssertionError("Not a double " + v);
+    }
 
     private Object cons(ConstantNode cons) {
         var type = cons.compute();
         if (type instanceof TypeInteger i) return i.value();
+        if (type instanceof TypeFloat i) return i.value();
         assert type instanceof TypeMemPtr;
         return null;
     }
@@ -127,15 +134,23 @@ public class Evaluator {
         return switch (node) {
             case ConstantNode cons  -> cons(cons);
             case AddNode      add   -> vall(add.in(1)) + vall(add.in(2));
+            case AddFNode     add   -> vald(add.in(1)) + vald(add.in(2));
             case BoolNode.EQ  eq    -> Objects.equals(val(eq.in(1)), val(eq.in(2))) ? 1L : 0L;
             case BoolNode.LE  le    -> vall(le.in(1)) <= vall(le.in(2)) ? 1L : 0L;
             case BoolNode.LT  lt    -> vall(lt.in(1)) <  vall(lt.in(2)) ? 1L : 0L;
+            case BoolNode.EQF eq    -> Objects.equals(val(eq.in(1)), val(eq.in(2))) ? 1L : 0L;
+            case BoolNode.LEF le    -> vald(le.in(1)) <= vald(le.in(2)) ? 1L : 0L;
+            case BoolNode.LTF lt    -> vald(lt.in(1)) <  vald(lt.in(2)) ? 1L : 0L;
             case DivNode      div   -> div(div);
+            case DivFNode     div   -> div(div);
             case MinusNode    minus -> -vall(minus.in(1));
             case MulNode      mul   -> vall(mul.in(1)) * vall(mul.in(2));
+            case MulFNode     mul   -> vald(mul.in(1)) * vald(mul.in(2));
             case NotNode      not   -> isTrue(val(not.in(1))) ? 0L : 1L;
             case SubNode      sub   -> vall(sub.in(1)) - vall(sub.in(2));
+            case SubFNode     sub   -> vald(sub.in(1)) - vald(sub.in(2));
             case CastNode     cast  -> val(cast.in(1));
+            case ToFloatNode  cast  -> (double)vall(cast.in(1));
             case LoadNode     load  -> load(load);
             case StoreNode    store -> store(store);
             case NewNode      alloc -> alloc(alloc);