Merge pull request #7 from Zite0/main

Replace Cartesian Product Syntax

Author: ak-2485

doc/README.md

@@ -41,11 +41,11 @@ FPTaylor requires the [OCaml Num library](https://github.com/ocaml/num) which ca
 ```
 opam install num
 ```
-Now, in the directory `NumFuzz/examples/FPTaylor`, extract FPTaylor to the directory `FPTaylor-9.4.0` by running the command  
+Now, in the directory `NumFuzz/examples/FPTaylor`, extract FPTaylor to the directory `FPTaylor-0.9.4` by running the command  
 ```
 tar -xzf v0.9.4.tar.gz
 ```
-In the directory `FPTaylor-9.4.0` run
+In the directory `FPTaylor-0.9.4` run
 ```
 make all
 ```
@@ -249,7 +249,7 @@ v, w ::=                                        VALUES
       ()                                        value of unit type
       k in R                                    constants (reals > 0)
       (v,w)                                     tensor pairs
-      (|v,w|)                                   cartesian pairs
+      <v,w>                                     cartesian pairs
       inl v                                     injection into sum
       inr v                                     injection into sum
       fun (x:T) {e}                             ordinary function
@@ -266,8 +266,8 @@ e, f ::=                                        EXPRESSIONS
       fst v                                     cartesian pair destructor
       snd v                                     cartesian pair destructor
       let (x,y) = v; e                          tensor destructor
-      case v {inl x => e | inr x => f}        case analysis
-      if v then {e} else {f}			        conditional (case sugar)
+      case v {inl x => e | inr x => f}          case analysis
+      if v then {e} else {f}			      conditional (case sugar)
       let [x] = v; e                            co-monadic sequencing
       let x = v; e                              monadic sequencing
       x = e; f                                  pure sequencing
@@ -337,47 +337,50 @@ followed by the input function to be applied to each element in the input tuple.
 
 ### Arithmetic Operations with Rounding
 
-Arithmetic operations that perform rounding can be built from primitive operations. One example is `addfp`, which adds two numbers and rounds the result: 
+Arithmetic operations that perform rounding can be built from primitive operations. One example is `addfp64`, which adds two numbers and rounds the result to the nearest 64-bit floating point number: 
 
 ```ocaml
-function addfp (xy: <num, num>) 
+function addfp_64 (xy: <num, num>) 
 {
   s = add xy;
-  rnd s
+  rnd_64 s
 } 
 ```
 
-Several operations that perform rounding are included in the directory  `NumFuzz/examples/NumFuzz/float_ops`; we list them here with their type signatures.
+Several operations that perform rounding are included in the directory  `NumFuzz/examples/NumFuzz/float_ops`; we list the
+64-bit ones here with their type signatures.
 
-1. Addition `addfp: (num × num) -o M[eps64_up]num`
-2. Multiplication `mulfp: (num ⊗ num) -o M[eps64_up]num`
-3. Division `divfp: (num ⊗ num) -o M[eps64_up]num`
-4. Square root `sqrtfp: ![0.5]num -o M[eps64_up]num`
-5. Fused multiply-add `FMA: num -o num -o num -o M[eps64_up]num`
-6. Multiply-add `MA: num -o num -o num -o M[eps64_up]num`
+1. Addition `addfp64: (num × num) -o M[eps64_up]num`
+2. Multiplication `mulfp64: (num ⊗ num) -o M[eps64_up]num`
+3. Division `divfp64: (num ⊗ num) -o M[eps64_up]num`
+4. Square root `sqrtfp64: ![0.5]num -o M[eps64_up]num`
+5. Fused multiply-add `FMA64: num -o num -o num -o M[eps64_up]num`
+6. Multiply-add `MA64: num -o num -o num -o M[eps64_up]num`
 
 These operations can be used in NumFuzz programs using an include statement; e.g., 
 ```
-#include PATH/float_ops/addfp.fz
+#include PATH/float_ops/addfp64.fz
 ``` 
-where `PATH` is the path relative to the directory of your program.
+where `PATH` is the path relative to the directory of your program. Operations
+using 16, and 32 bit floating-point numbers are also available. For example, `addfp32`
+is the 32-bit addition operator.  
 
 ### A Simple Benchmark
 
 As an example, let us consider the benchmark `one_by_sqrtxx`, where we are tasked with computing a relative error bound for the expression $1/\sqrt{x^2}$. We can use NumFuzz to derive a bound using the following program.
 
 ```ocaml
-1.  #include "float_ops/mulfp.fz"
-2.  #include "float_ops/divfp.fz"
-3.  #include "float_ops/sqrtfp.fz"
+1.  #include "float_ops/mulfp64.fz"
+2.  #include "float_ops/divfp64.fz"
+3.  #include "float_ops/sqrtfp64.fz"
 4.
 5.  function one_by_sqrtxx (x : num)
 6.  {
-7.   sz = mulfp (x,x);
+7.   sz = mulfp64 (x,x);
 8.   let z = sz;
-9.   sy = sqrtfp ([z{0.5}]);
+9.   sy = sqrtfp64 ([z{0.5}]);
 10.  let y = sy;
-11.  divfp (1.0,y)
+11.  divfp64 (1.0,y)
 12. }
 13.
 14. one_by_sqrtxx

doc/syntax.txt

@@ -19,7 +19,7 @@ v, w ::=                                        VALUES
       ()                                        value of unit type
       k in R                                    constants (reals > 0)
       (v,w)                                     tensor pairs
-      (|v,w|)                                   cartesian pairs
+      <v,w>                                     cartesian pairs
       inl v                                     injection into sum
       inr v                                     injection into sum
       fun (x:T) {e}                             ordinary function

examples/NumFuzz/float_ops/fma16.fz

@@ -2,6 +2,6 @@ function FMA16
   (x : num) (y : num) (z : num) : M[eps16_up]num 
 {
   a = mul (x,y);
-  b = add (|a,z|);
+  b = add <a,z>;
   rnd16 b
 }

examples/NumFuzz/float_ops/fma32.fz

@@ -2,6 +2,6 @@ function FMA32
   (x : num) (y : num) (z : num) : M[eps32_up]num 
 {
   a = mul (x,y);
-  b = add (|a,z|);
+  b = add <a,z>;
   rnd32 b
 }

examples/NumFuzz/float_ops/fma64.fz

@@ -2,6 +2,6 @@ function FMA64
   (x : num) (y : num) (z : num) : M[eps64_up]num 
 {
   a = mul (x,y);
-  b = add (|a,z|);
+  b = add <a,z>;
   rnd64 b
 }

examples/NumFuzz/float_ops/ma64.fz

@@ -1,5 +1,7 @@
+#include "addfp64.fz"
+#include "mulfp64.fz"
 function MA64 (x : num) (y : num) (z : num) : M[4.441e-16]num {
   s = mulfp64 (x,y);
   let a = s;
-  addfp64 (|a,z|)
-}
+  addfp64 <a,z>
+}

examples/NumFuzz/hypot.fz

@@ -10,7 +10,7 @@ function hypot
   let x2 = s1;
   s2 = mulfp64(y,y);
   let y2 = s2;
-  s3 = addfp64(|x2,y2|);
+  s3 = addfp64<x2,y2|);
   let y3 = s3;
   sqrtfp64 [y3{0.5}]
 }

examples/NumFuzz/i4.fz

@@ -9,7 +9,7 @@ function i4
  s1 = mulfp64(y,y);
  let s2 = s1;
  let [x] = x';
- s3 = addfp64 (|x, s2|);
+ s3 = addfp64 <x, s2>;
  let s4 = s3;
  sqrtfp64 [s4{0.5}]
 }

examples/NumFuzz/large_benchmarks/Estrin10.fz

@@ -31,15 +31,15 @@ function Estrin10
     let t7' = t7;
     let t9' = t9;
 
-    z0 = addfp64(|a0,t1'|);
+    z0 = addfp64<a0,t1'>;
     let z0' = z0;
-    z2 = addfp64(|a2,t3'|);
+    z2 = addfp64<a2,t3'>;
     let z2' = z2;
-    z4 = addfp64(|a4,t5'|);
+    z4 = addfp64<a4,t5'>;
     let z4' = z4;
-    z6 = addfp64(|a6,t7'|);
+    z6 = addfp64<a6,t7'>;
     let z6' = z6;
-    z8 = addfp64(|a8,t9'|);
+    z8 = addfp64<a8,t9'>;
     let z8' = z8;
 
     p2 =  mulfp64(x,x);
@@ -57,11 +57,11 @@ function Estrin10
     s2 = mulfp64(a10,p10'); 
     let s2' = s2;
 
-    u0 = addfp64(|z0',s0'|);
+    u0 = addfp64<z0',s0'>;
     let u0' = u0;
-    u1 = addfp64(|z4',s1'|);
+    u1 = addfp64<z4',s1'>;
     let u1' = u1;
-    u2 = addfp64(|z8',s2'|);
+    u2 = addfp64<z8',s2'>;
     let u2' = u2;
 
     r4 =  pow4fp [x{4.0}];
@@ -71,13 +71,13 @@ function Estrin10
 
     v00 = mulfp64(u1',r4');
     let v00' = v00;
-    v0 = addfp64(|u0',v00'|);
+    v0 = addfp64<u0',v00'>;
     let v0' = v0;
 
     v1 = mulfp64(u2',r8');
     let v1' = v1;
 
-    addfp64(|v0',v1'|)
+    addfp64<v0',v1'>
 }
 
 Estrin10

examples/NumFuzz/large_benchmarks/dotprods/dotprod128.fz

@@ -267,7 +267,7 @@ let a125 = a125';
 let a126 = a126';
 let a127 = a127';
 v1 = (a0,(a1,(a2,(a3,(a4,(a5,(a6,(a7,(a8,(a9,(a10,(a11,(a12,(a13,(a14,(a15,(a16,(a17,(a18,(a19,(a20,(a21,(a22,(a23,(a24,(a25,(a26,(a27,(a28,(a29,(a30,(a31,(a32,(a33,(a34,(a35,(a36,(a37,(a38,(a39,(a40,(a41,(a42,(a43,(a44,(a45,(a46,(a47,(a48,(a49,(a50,(a51,(a52,(a53,(a54,(a55,(a56,(a57,(a58,(a59,(a60,(a61,(a62,(a63,(a64,(a65,(a66,(a67,(a68,(a69,(a70,(a71,(a72,(a73,(a74,(a75,(a76,(a77,(a78,(a79,(a80,(a81,(a82,(a83,(a84,(a85,(a86,(a87,(a88,(a89,(a90,(a91,(a92,(a93,(a94,(a95,(a96,(a97,(a98,(a99,(a100,(a101,(a102,(a103,(a104,(a105,(a106,(a107,(a108,(a109,(a110,(a111,(a112,(a113,(a114,(a115,(a116,(a117,(a118,(a119,(a120,(a121,(a122,(a123,(a124,(a125,(a126,a127)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))));
-g = fun (x: num) {fun (y: num) {addfp64 (|x,y|)}};
+g = fun (x: num) {fun (y: num) {addfp64 <x,y>}};
 fold128 v1 [g{127.0}]
 }