@explorable-viz/fluid 0.7.89 → 0.7.91

package/README.md

@@ -9,7 +9,7 @@ Fluid is an experimental programming language which integrates a bidirectional d
 
 ### Software required
 - git
-- Node.js >=14.0.0
+- Node.js >=18.0.0
 - yarn >= 1.22
 
 Additionally, for Windows users only:
@@ -20,11 +20,12 @@ Additionally, for Windows users only:
 
 - Clone the repository (for Windows users, do this under the Ubuntu WSL)
 - Run `./script/setup/dev-setup.sh` from the top-level directory
-- Run `yarn build`
+- `yarn install` to install Node dependencies
+- `yarn build`
 
 ## Use
 
-The following assumes you have already succesfully run `yarn build` (see above).
+The following assumes you have already successfully run `yarn build` (see above).
 
 ### Running programs from the command line
 
@@ -41,10 +42,14 @@ Note that the path is relative and should not include the `.fld` extension, e.g.
 Success
 ```
 
-### Running the fluid.org website locally
+### Running websites locally (as part of Fluid development)
+As an example, to build and run the website `literate-execution`:
+- `yarn build` to ensure Fluid source code has been compiled (can be skipped on subsequent runs)
+- `yarn bundle-website -w literate-execution` (can be skipped if the website being run is `fluid-org`)
+- `yarn serve literate-execution` (you may be prompted to proceed; press `y`)
+- Open a browser to the served URL (defaults to `127.0.0.1:8080`)
 
-- `yarn serve fluid-org` (you may be prompted to proceed: type `y`).
-- Open a browser at the served URL (usually `127.0.0.1:8080`)
+Note: `yarn bundle-serve literate-execution` is a convenient shorthand for `bundle-website -w` followed by `serve`.
 
 ## Testing
 

package/dist/fluid/fluid/lib/{convolution.fld → matrix.fld}

@@ -16,16 +16,26 @@ let extend m n image =
 
 let matrixSum matr =
     let (m, n) = dims matr
-    in sum [ matr!(i, j) | (i, j) <- range (1, 1) (m, n)];
+    in foldl (+) 0 [ matr!(i, j) | (i, j) <- range (1, 1) (m, n)];
 
 let convolve image kernel lookup =
     let ((m, n), (i, j)) = (dims image, dims kernel);
         (half_i, half_j) = (i `quot` 2, j `quot` 2);
         area = i * j
-    in [|let interMatrix = [|
+    in [| let interMatrix = """Intermediate matrix for element (${m'}, ${n'})"""
+        [|
         let x = m' + i' - 1 - half_i;
-            y = n' + j' - 1 - half_j
-        in lookup x y image * kernel!(i', j')
+            y = n' + j' - 1 - half_j in
+        """Multiply these two elements"""
+        lookup x y image * kernel!(i', j')
      | (i', j') in (i, j) |]
      in matrixSum interMatrix `quot` area
      | (m', n') in (m, n) |];
+
+let matMul a b = 
+    let ((m, n), (i, j)) = (dims a, dims b) in 
+    if not (n == i)
+    then error "Dimensions don't line up"
+    else """Intermediate matrix"""
+        [| sum [ a!(i', k) * b!(k, j') | k <- enumFromTo 1 n]
+        | (i', j') in (m, j) |];

package/dist/fluid/fluid/lib/prelude.fld

@@ -267,9 +267,9 @@ let slice begin end xs =
 
 
 -- (a -> Boolean) -> List a -> (List a, List a)
-let splitOn p data = 
+let splitOn p data =
     let go fls trs [] = (reverse fls, reverse trs);
-        go fls trs (x : xs) = 
+        go fls trs (x : xs) =
             if p x
             then go fls (x : trs) xs
             else go (x : fls) trs xs

package/dist/fluid/fluid/lib/stats.fld

@@ -19,46 +19,45 @@ let mergesort xs =
           let (ys, zs) = split xs in
           merge (mergesort ys) (mergesort zs);
 
--- assume data is sorted
-let findQuantile q p data = 
-    let rank = (p / q) * (length data - 1)
+-- assume xs is sorted
+let findQuantile q p xs =
+    let rank = (p / q) * (length xs - 1)
     in if rank == floor rank
-    then nth rank data
+    then nth rank xs
     else let x1 = floor rank;
              x2 = ceiling rank;
-             left = nth x1 data;
-             right = nth x2 data
+             left = nth x1 xs;
+             right = nth x2 xs
         in left + (rank - x1) * (right - left);
 
 let findPercentile = findQuantile 100;
 
 let accumBins data Nil = [];
     accumBins data [l] = [];
-    accumBins data (l : r : es) =  
+    accumBins data (l : r : es) =
         let (ge, le) = splitOn (fun x -> x <= r) data
-        in (le , r - l) : accumBins ge (r : es);
+        in (le, r - l) : accumBins ge (r : es);
 
-let cut data nbins = 
-    let low = minimum data;
-        binwidth = (maximum data - low) / nbins;
+let cut xs nbins =
+    let low = minimum xs;
+        binwidth = (maximum xs - low) / nbins;
         edges = [ low + (x * binwidth) | x <- enumFromTo 0 nbins ]
-    in accumBins data edges;
+    in accumBins xs edges;
 
-let qcut data qs = 
-        let low = minimum data;
-            high = maximum data;
-            edges = append (low : [ findPercentile x data | x <- qs], [high])
-        in accumBins data edges;
+let qcut xs qs =
+    let (low, high) = (minimum xs, maximum xs);
+        edges = append (low : [ findPercentile x xs | x <- qs], [high])
+    in accumBins xs edges;
 
-let likelihoodLE data target = 
-    length (filter (fun x -> x <= target) data) / length data;
+let likelihoodLE xs target =
+    length (filter (fun x -> x <= target) xs) / length xs;
 
-let likelihoodGE data target = 
-    length (filter (fun x -> x >= target) data) / length data;
+let likelihoodGE xs target =
+    length (filter (fun x -> x >= target) xs) / length xs;
 
 let likelihoodMap table prob = (fromSome (find (fun x -> x.prob <= prob) table)).msg;
 
-let mkPercent num = (numToStr (num * 100)) ++ "%";
+let mkPercent num = numToStr (num * 100) ++ "%";
 
 let leqP n m =
     if n <= m