@explorable-viz/fluid 0.7.8 → 0.7.10

package/dist/fluid/fluid/example/slicing/section-5-example.fld

@@ -0,0 +1,14 @@
+let map f [] = [];
+    map f (x : xs) = f x : map f xs;
+let data = [
+   { energyType: "Bio", output: 6.2 },
+   { energyType: "Hydro", output: 260 },
+   { energyType: "Solar", output: 19.9 },
+   { energyType: "Wind", output: 91 },
+   { energyType: "Geo", output: 14.4 }
+];
+   output = [
+   row.output | type <- ["Hydro", "Solar", "Geo"],
+                row <- data, row.energyType == type
+] in
+map (fun x -> floor (x / sum output * 100)) output

package/dist/fluid/fluid/example/slicing/zeros-1.expect.fld

@@ -0,0 +1,3 @@
+let zeros [] = ⸨[]⸩;
+    zeros (x : xs) = ⸨(0 : zeros xs)⸩ in
+zeros ⸨[⸩ 1, 2 ⸨]⸩

package/dist/fluid/fluid/example/slicing/zeros-2.expect.fld

@@ -0,0 +1,3 @@
+let zeros [] = ⸨[]⸩;
+    zeros (x : xs) = (0 : zeros xs) in
+zeros [1, 2 ⸨]⸩

package/dist/fluid/fluid/example/slicing/zeros.fld

@@ -0,0 +1,4 @@
+let zeros [] = [];
+    zeros (x : xs) = 0 : zeros xs
+in
+zeros [1, 2]

package/dist/fluid/fluid/example/slicing/zipWith-1.expect.fld

@@ -0,0 +1,4 @@
+let zipWith op [] ys = [];
+    zipWith op (x : xs) [] = [];
+    zipWith op (x : xs) (y : ys) = (op x y : zipWith op xs ys) in
+zipWith (fun x y = x ** ⸨2⸩ + y ** ⸨2⸩) [2, ⸨3⸩, 4] [3, ⸨4⸩, 5, 6]

package/dist/fluid/fluid/example/slicing/zipWith.fld

@@ -0,0 +1,4 @@
+let zipWith op [] ys = [];
+    zipWith op (x : xs) [] = [];
+    zipWith op (x : xs) (y : ys) = op x y : zipWith op xs ys
+in zipWith (fun x y -> x ** 2 + y ** 2) [2, 3, 4] [3, 4, 5, 6]

package/dist/fluid/fluid/example/text-viz/explainable-table.fld

@@ -0,0 +1,7 @@
+[
+    { scenario: "SSP1-1.9", bestEstNear: 1.5, lowNear: 1.2, highNear: 1.7, bestEstMid: 1.6, lowMid: 1.2, highMid: 2.0, bestEstLate: 1.4, lowLate: 1.0, highLate: 1.8},
+    { scenario: "SSP1-2.6", bestEstNear: 1.5, lowNear: 1.2, highNear: 1.8, bestEstMid: 1.7, lowMid: 1.3, highMid: 2.2, bestEstLate: 1.8, lowLate: 1.3, highLate: 2.4},
+    { scenario: "SSP2-4.5", bestEstNear: 1.5, lowNear: 1.2, highNear: 1.8, bestEstMid: 2.0, lowMid: 1.6, highMid: 2.5, bestEstLate: 2.7, lowLate: 2.1, highLate: 3.5},
+    { scenario: "SSP3-7.0", bestEstNear: 1.5, lowNear: 1.2, highNear: 1.8, bestEstMid: 2.1, lowMid: 1.7, highMid: 2.6, bestEstLate: 3.6, lowLate: 2.8, highLate: 4.6},
+    { scenario: "SSP5-8.5", bestEstNear: 1.6, lowNear: 1.3, highNear: 1.9, bestEstMid: 2.4, lowMid: 1.9, highMid: 3.0, bestEstLate: 4.4, lowLate: 3.3, highLate: 5.7}
+]

package/dist/fluid/fluid/example/text-viz/fake-probabilities.fld

@@ -0,0 +1,3 @@
+[
+    { model: "SSP1-1.9", probability: 0.92 }
+]

package/dist/fluid/fluid/example/text-viz/figure-spm-4.fld

@@ -0,0 +1,42 @@
+let getByX x table = fromSome (findWithKey "x" x table);
+
+let referToBar bar = "the bar representing scenario " ++ bar.x ++ " has a z value of " ++ (numToStr (head bar.bars).z);
+
+let stackedBarHeight stackedBar = sum [ bar.z | bar <- stackedBar.bars ];
+
+let getTotal (BarChart record) = fromSome (findWithKey "x" "Total" record.stackedBars);
+let getCO2 (BarChart record)= fromSome (findWithKey "x" "CO2" record.stackedBars);
+let getNonCO2 (BarChart record) = fromSome (findWithKey "x" "Non-CO2" record.stackedBars);
+
+
+let barHeight (BarChart bc) x =
+    let bar = fromSome (findWithKey "x" x bc.stackedBars)
+    in sum [ segment.z | segment <- bar.bars ];
+
+let explainBars bars x = 
+    if length bars == length (filter (fun bar -> bar.x == x) bars)
+    then "(°C; " ++ x ++ " bar)"
+    else error "absurd";
+
+let mkBarChart scenName table = 
+    BarChart {
+        caption: "Example bar chart for scenario " ++ scenName,
+        size: { width: 275, height: 185 },
+        stackedBars: map (fun record -> { x: record.type, bars: [ { y: "emissions", z: record.emissions } ]}) table
+    };
+
+let getHeight bar offset = (head bar.bars).z + offset;
+
+let ssp119 = mkBarChart "SSP1-1.9" ssp119Source;
+    ssp245 = mkBarChart "SSP2-4.5" ssp245Source;
+    total = map getTotal [ssp119, ssp245];
+    co2 = map getCO2 [ssp119, ssp245];
+    nonco2 = map getNonCO2 [ssp119, ssp245];
+    meanTotal = (sum (map stackedBarHeight total)) / (length total)
+in MultiView {
+    leftBarChart: ssp119,
+    rightBarChart: ssp245,
+    explanation:
+        LinkedText [ "Within each scenario bar plot, the bars represent: total warming ", explainBars total "Total",
+                     ", warming contributions from CO2 ", explainBars co2 "CO2", " and from non-CO2 GHG's ", explainBars nonco2 "Non-CO2"]
+}

package/dist/fluid/fluid/example/text-viz/left-barchart-table.fld

@@ -0,0 +1,5 @@
+[
+    { type: "Total", emissions: 1.35 }, 
+    { type: "CO2", emissions: 1.1 },
+    { type: "Non-CO2", emissions: 0.41 }
+]

package/dist/fluid/fluid/example/text-viz/likelihoods.fld

@@ -0,0 +1,9 @@
+[
+  { prob: 0.99, msg: "virtually certain" },
+  { prob: 0.9, msg: "very likely"},
+  { prob: 0.66, msg: "likely"},
+  { prob: 0.33, msg: "about as likely as not"},
+  { prob: 0.1, msg: "unlikely"},
+  { prob: 0.01, msg: "very unlikely"},
+  { prob: 0.0, msg: "exceptionally unlikely"}
+]

package/dist/fluid/fluid/example/text-viz/right-barchart-table.fld

@@ -0,0 +1,5 @@
+[
+    { type: "Total", emissions: 2.7 },
+    { type: "CO2", emissions: 2.1 },
+    { type: "Non-CO2", emissions: 0.6 }
+]

package/dist/fluid/fluid/example/text-viz/table-spm-1.fld

@@ -0,0 +1,30 @@
+let newDataTable offset = map (fun s -> { scenario: s.scenario, beNear: s.bestEstNear + offset, nearRange: (s.lowNear, s.highNear), beMid: s.bestEstMid, midRange: (s.lowMid, s.highMid), beLong: s.bestEstLate, longRange: (s.lowLate, s.highLate)}) tableData;
+
+let getByScenario data scenario = fromSome (findWithKey "scenario" scenario data);
+
+let probAsText = likelihoodMap likelihoods;
+
+let mean list = (sum list) / (length list); 
+
+let calcLikelihood (min, max) target = 
+    if max < target
+    then 0.05
+    else if target <= min
+    then 0.95
+    else (target - min)/(max - min);
+
+let realTable = newDataTable 0;
+    getByScenario' = getByScenario realTable;
+    ssp119 = getByScenario' "SSP1-1.9";
+    ssp245 = getByScenario' "SSP2-4.5"
+in MultiView {
+    explanation119:
+        LinkedText [ "Under the low GHG emissions scenario (SSP1-1.9), global warming of 2°C would ",
+                      probAsText (calcLikelihood ssp119.longRange 2.0), 
+                     " be exceeded at the end of the 21st century." ],
+    explanation245:
+        LinkedText [ "Under the intermediate GHG emissions scenario (SSP2-4.5), global warming of 2°C would ",
+                     probAsText (calcLikelihood ssp245.longRange 2.0),
+                     " be exceeded by the end of the 21st century. In the mid-term period (2041-2060)",
+                     " crossing the 2°C mark is ", probAsText (calcLikelihood ssp245.midRange 2.0), "to occur" ]
+    }

package/dist/fluid/fluid/lib/convolution.fld

@@ -0,0 +1,16 @@
+let zero n = const n;
+    wrap n n_max = ((n - 1) `mod` n_max) + 1;
+    extend n = min (max n 1);
+
+let convolve image kernel method =
+    let ((m, n), (i, j)) = (dims image, dims kernel);
+        (half_i, half_j) = (i `quot` 2, j `quot` 2);
+        area = i * j
+    in  [| let weightedSum = sum [
+           image!(x, y) * kernel!(i' + 1, j' + 1)
+           | (i', j') <- range (0, 0) (i - 1, j - 1),
+             let x = method (m' + i' - half_i) m,
+             let y = method (n' + j' - half_j) n,
+             x >= 1, x <= m, y >= 1, y <= n
+         ] in weightedSum `quot` area
+         | (m', n') in (m, n) |];

package/dist/fluid/fluid/lib/dtw.fld

@@ -0,0 +1,47 @@
+let nextIndices n m window =
+  [(i, j) | i <- [1 .. n],
+            j <- [max 1 (i - window) .. min m (i + window)]];
+
+let costMatrixInit rows cols window =
+    [| let initV = if ((n == 1) `and` (m == 1)) `or` ((abs n m <= window) `and` not ((n == 1) `or` (m == 1)))
+                   then FNum 0
+                   else Infty
+        in initV | (n, m) in (rows, cols) |];
+
+let minAndPrev (i, j) im1 jm1 ijm1 =
+  let minim = minimal [im1, jm1, ijm1] in
+      if minim `eq` im1 then
+          ((i, j + 1), minim)
+      else
+          if minim `eq` jm1 then
+              ((i + 1, j ), minim)
+          else ((i, j), minim);
+
+let extractPath indmatrix (n, m) accum =
+    if (n == 1) `and` (m == 1)
+    then accum
+    else
+        extractPath indmatrix (indmatrix!(n, m)) ((n - 1, m - 1) : accum);
+
+let localMinUpdate seq1 seq2 cost (costmatrix, indmatrix) (i, j) =
+    let iEntr = nth (i - 1) seq1;
+        jEntr = nth (j - 1) seq2;
+        dist = cost iEntr jEntr;
+        ip = i + 1;
+        jp = j + 1;
+        im1 = costmatrix!(i , jp);
+        jm1 = costmatrix!(ip, j);
+        im1jm1 = costmatrix!(i, j);
+        (prev, FNum minim) = minAndPrev (i, j) im1 jm1 im1jm1;
+        newVal = FNum (dist + minim)
+    in (matrixUpdate costmatrix (ip, jp) newVal, matrixUpdate indmatrix (ip, jp) prev);
+
+let computeDTW seq1 seq2 cost window =
+  let n = length seq1;
+      m = length seq2;
+      initD = costMatrixInit (n + 1) (m + 1) window;
+      initI = [| 0 | (i,j) in (n + 1, m + 1)|];
+      indexing = nextIndices n m window;
+      (finished, indices) = foldl (localMinUpdate seq1 seq2 cost) (initD, initI) indexing
+  in
+  (finished, extractPath indices (n + 1, m + 1) Nil);

package/dist/fluid/fluid/lib/fnum.fld

@@ -0,0 +1,22 @@
+let comp Infty Infty = EQ;
+    comp Infty (FNum y) = GT;
+    comp (FNum x) Infty = LT;
+    comp (FNum x) (FNum y) = compare x y;
+
+let fmin x y =
+    match comp x y as {
+        LT -> x;
+        EQ -> x;
+        GT -> y
+    };
+
+let minimal = foldl1 fmin;
+
+let add Infty _ = Infty;
+    add (FNum x) Infty = Infty;
+    add (FNum x) (FNum y) = FNum (x + y);
+
+let eq Infty Infty = True;
+    eq Infty (FNum x) = False;
+    eq (FNum x) Infty = False;
+    eq (FNum x) (FNum y) = x == y;

package/dist/fluid/fluid/lib/graphics.fld

@@ -0,0 +1,221 @@
+-- typedef Colour = Str
+-- typedef Colours = List Colour
+-- typedef Cat = Str
+
+-- Group has location (0, 0) because it doesn't interfere with positioning of its children.
+-- GraphicsElement -> Point
+let coords (Group gs) = Point 0 0;
+    coords (Rect x y _ _ _) = Point x y;
+    coords (Text x y _ _ _) = Point x y;
+    coords (Viewport x y _ _ _ _ _ _ _) = Point x y;
+
+-- GraphicsElement -> Float
+let get_x g = let Point x _ = coords g in x;
+
+-- GraphicsElement -> Float
+let get_y g = let Point _ y = coords g in x;
+
+-- Want some kind of typeclass mechanism plus record accessors/updaters.
+-- Float -> GraphicsElement -> GraphicsElement
+let set_x x (Group gs) = error "Group has immutable coordinates";
+    set_x x (Rect _ y w h fill) = Rect x y w h fill;
+    set_x x (Text _ y str anchor baseline) = Text x y str anchor baseline;
+    set_x x (Viewport _ y w h fill margin scale translate g) = Viewport x y w h fill margin scale translate g;
+
+-- (Point, Point) -> Point
+let dimensions2 (Point x1 y1, Point x2 y2) = Point (max x1 x2) (max y1 y2);
+
+-- For Group, dimensions are relative to implicit coords of (0, 0), since a Group's children are effectively
+-- positioned relative to parent of Group. For Polymarker, will probably have to ignore the markers themselves,
+-- since they are scale-invariant.
+-- GraphicsElement -> Point
+let
+   dimensions (Group gs) = foldl (curry dimensions2) (Point 0 0) (map (coords_op) gs);
+   dimensions (Polyline ps _ _) = foldl (curry dimensions2) (Point 0 0) ps;
+   dimensions (Rect _ _ w h _) = Point w h;
+   dimensions (Text _ _ _ _ _) = Point 0 0; -- treat text like markers; scale-invariant
+   dimensions (Viewport _ _ w h _ _ _ _ _) = Point w h;
+
+   coords_op g =
+      let (Point x y, Point w h) = prod coords dimensions g in
+      Point (x + w) (y + h);
+
+-- GraphicsElement -> Float
+let width g = let Point w _ = dimensions g in w;
+
+-- GraphicsElement -> Float
+let height g = let Point _ h = dimensions g in h;
+
+-- Float -> Float -> List GraphicsElement -> List GraphicsElement
+let spaceRight z sep gs =
+   zipWith set_x (iterate (length gs) ((+) sep) z) gs;
+
+-- Bake colour decisions into the library for the time being. Provide two palettes, so we can have two
+-- different sets of categorical values (e.g. countries and energy types). Palettes from colorbrewer2.org.
+let colours1 = ["#66c2a5", "#a6d854", "#ffd92f", "#e5c494", "#fc8d62", "#b3b3b3", "#8da0cb", "#e78ac3"];
+let colours2 = ["#e41a1c", "#377eb8", "#4daf4a", "#984ea3", "#ff7f00", "#ffff33", "#a65628", "#f781bf"];
+
+-- Compositionality principle: child coords/dimensions are always expressed directly using parent reference
+-- frame, to avoid depending on content of child, and so are not themselves scaled. Polyline can't be scaled
+-- directly because it inherits its frame of reference from its parent. For Viewport, margin will shrink the
+-- available area, possibly to zero, at which point nothing will be rendered.
+-- Float -> GraphicsElement -> GraphicsElement
+let scaleToWidth w (Rect x y _ h fill) = Rect x y w h fill;
+    scaleToWidth w (Viewport x y w0 h fill margin (Scale x_scale y_scale) translate g) =
+      let scale = Scale (x_scale * w / w0) y_scale in
+      Viewport x y w h fill margin scale translate g;
+
+-- Float -> List GraphicsElement -> List GraphicsElement
+let stackRight sep gs =
+   map (scaleToWidth (1 - sep)) (spaceRight (sep / 2) 1 gs);
+
+-- Float -> List GraphicsElement -> GraphicsElement
+let groupRight sep gs =
+   Viewport 0 0 (length gs) (maximum (map height gs)) "none" 0 (Scale 1 1) (Translate 0 0) (Group (stackRight sep gs));
+
+-- Heuristic saying how often to place a tick on an axis of length n.
+-- Float -> Float
+let tickEvery n =
+   let m = floor (logBase 10 n) in
+   if n <= 2 * 10 ** m
+   then 2 * 10 ** (m - 1)
+   else 10 ** m;
+
+let axisStrokeWidth = 0.5;
+    axisColour = "black";
+    backgroundColour = "white";
+    defaultMargin = 24;
+    markerRadius = 3.5;
+    tickLength = 4;
+
+-- Helpers for axis functions.
+-- Orient -> Colour -> Float -> GraphicsElement
+let tick Horiz colour len = Line (Point 0 0) (Point 0 (0 - len)) colour axisStrokeWidth;
+    tick Vert colour len = Line (Point 0 0) (Point (0 - len) 0) colour axisStrokeWidth;
+
+-- Orient -> Float -> Float -> Str -> GraphicsElement
+let label Horiz x distance str = Text x (0 - distance - 4) str "middle" "hanging";
+    label Vert x distance str = Text (0 - distance) x str "end" "central";
+
+-- Orient -> Colour -> Float -> Str -> GraphicsElement
+let labelledTick orient colour len str =
+   Group [tick orient colour len, label orient 0 len str];
+
+-- Orient -> Float -> Float -> Point
+let mkPoint Horiz x y = Point y x;
+    mkPoint Vert x y = Point x y;
+
+-- x is position of this axis on the other axis. Returns axis and position of last tick.
+-- Orient -> Float -> Float -> Float -> GraphicsElement
+let axis orient x start end =
+   let tickSp = tickEvery (end - start);
+       firstTick = ceilingToNearest start tickSp;
+       lastTick = ceilingToNearest end tickSp;
+       n = floor ((end - firstTick) / tickSp) + 1;
+       ys = iterate n ((+) tickSp) firstTick;
+       -- avoid redundant start and end points
+       ys = match firstTick > start as {
+          True -> start : ys;
+          False -> ys
+       };
+       ys = match lastTick > end as {
+          True -> concat2 ys [lastTick];
+          False -> ys
+       };
+       ps = map (mkPoint orient x) ys;
+       ax = Group [
+          Line (head ps) (last ps) axisColour axisStrokeWidth,
+          Polymarkers ps (flip map ys (compose (labelledTick orient axisColour tickLength) numToStr))
+       ]
+   in (ax, lastTick);
+
+-- x is position of this axis on the other axis.
+-- Orient -> Float -> List Cat -> GraphicsElement
+let catAxis orient x catValues =
+   let ys = iterate (length catValues + 1) ((+) 1) 0;
+       ps = map (mkPoint orient x) ys
+   in Group [
+      Line (head ps) (last ps) axisColour axisStrokeWidth,
+      Polymarkers (tail ps) (map (const (tick orient axisColour tickLength)) catValues),
+      Polymarkers (flip map (tail ps) (fun (Point x y) -> Point (x - 0.5) y)) (map (label orient -0.5 0) catValues)
+   ];
+
+-- Float -> Float -> Float -> Float -> List GraphicsElement -> GraphicsElement
+let viewport x_start x_finish y_finish margin gs =
+   Viewport 0 0 (x_finish - x_start) y_finish backgroundColour margin
+            (Scale 1 1) (Translate (0 - x_start) 0) (Group gs);
+
+-- Plot a map of x values to lists of (categorical value, y value) pairs. Importantly, assume all data is uniform
+-- (categorical keys are the same for each x value and are ordered the same each time).
+-- Bool -> Colours -> Float -> List (Float, List (Cat, Float)) -> GraphicsElement
+let lineChart withAxes colours x_start data =
+   let xs = map fst data;
+       nCat = length (snd (head data));
+   -- (Int, Colour) -> GraphicsElement
+   let plot (n, colour) =
+      let ps = map (fun (x, kvs) -> Point x (snd (nth n kvs))) data
+      in Group [
+         Polyline ps colour 1,
+         Polymarkers ps (repeat (length ps) (Circle 0 0 markerRadius colour))
+      ];
+   -- List GraphicsElement
+   let lines = zipWith (curry plot) (iterate nCat ((+) 1) 0) colours;
+       x_finish = last xs;
+       y_finish = maximum (flip map data (fun (_, kvs) -> maximum (map snd kvs)))
+   in match withAxes as {
+      True ->
+         let (x_axis, x_finish) = axis Horiz 0 x_start x_finish;
+             (y_axis, y_finish') = axis Vert x_start 0 y_finish
+         in viewport x_start x_finish y_finish' defaultMargin (x_axis : y_axis : lines);
+      False -> viewport x_start x_finish y_finish 0 lines
+   };
+
+-- Plot a chart of categorical values on the x-axis and renderings of the corresponding a-value on the y-axis.
+-- (Colours -> List a -> GraphicsElement) -> Bool -> Colours -> Float -> List (Cat, a) -> GraphicsElement
+let categoricalChart plotValue withAxes colours sep data =
+   let gs = stackRight sep (plotValue colours (map snd data));
+       w = length gs;
+       h = maximum (map height gs)
+   in match withAxes as {
+      True ->
+         let x_axis = catAxis Horiz 0 (map fst data);
+             (y_axis, h') = axis Vert 0 0 h
+         in viewport 0 w h' defaultMargin (concat2 gs [x_axis, y_axis]); -- axes on top
+      False -> viewport 0 w h 0 gs
+   };
+
+-- Colours -> List a -> GraphicsElement
+let rects colours ns =
+   zipWith (fun colour n -> Rect 0 0 1 n colour) colours ns;
+
+-- First component of data (categorical value) currently ignored; values just mapped positionally to colors.
+-- Can we use Group instead of Viewport here?
+-- Colours -> List (a, Num) -> GraphicsElement
+let stackedBar colours ns =
+   let heights = map snd ns;
+       subtotals = scanl1 (+) 0 heights;
+       dims = zip (0 : subtotals) heights;
+       rects = map
+          (fun ((y, height), colour) -> Rect 0 y 1 height colour)
+          (zip dims colours)
+   in Viewport 0 0 1 (last subtotals) "none" 0 (Scale 1 1) (Translate 0 0) (Group rects);
+
+-- Bool -> Colours -> Float -> List (a, Float) -> GraphicsElement
+let barChart = categoricalChart rects;
+
+-- For each categorical value of type a, plot a bar chart for the corresponding b-indexed data.
+-- Bool -> Colours -> Float -> List (a, List (b, Float)) -> GraphicsElement
+let groupedBarChart = categoricalChart (compose map (flip (barChart False) 0));
+
+-- See stackedBar for strong (unjustified) assumption about uniformity of data.
+-- Bool -> Colours -> Num -> List (a, List (b, Num)) -> GraphicsElement
+let stackedBarChart = categoricalChart (compose map stackedBar);
+
+-- Bit of a hack, but how text fits into our model is a bit unclear at the moment.
+-- Str -> GraphicsElement -> GraphicsElement
+let caption str (Viewport x y w h fill margin scale translate g) =
+   let g' = Group [
+      Text (x + w / 2) -2 str "middle" "hanging",
+      Viewport 0 0 w h fill margin scale translate g
+   ]
+   in Viewport x y w h backgroundColour (defaultMargin / 2 + 4) (Scale 1 1) (Translate 0 0) g';