@explorable-viz/fluid 0.10.2 → 0.10.3

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

@@ -1,221 +1,246 @@
--- 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 (String 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 (String _ y str anchor baseline) = String 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 (String _ _ _ _ _) = 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 = String x (0 - distance - 4) str "middle" "hanging";
-    label Vert x distance str = String (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 [
-      String (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';
+def coords(Group(gs)): Point(0, 0)
+def coords(Rect(x, y, _, _, _)): Point(x, y)
+def coords(String(x, y, _, _, _)): Point(x, y)
+def coords(Viewport(x, y, _, _, _, _, _, _, _)): Point(x, y);
+
+def get_x(g):
+  def Point(x, _): coords(g);
+
+  x;
+
+def get_y(g):
+  def Point(_, y): coords(g);
+
+  x;
+
+def set_x(x, Group(gs)):
+  error("Group has immutable coordinates")
+def set_x(x, Rect(_, y, w, h, fill)):
+  Rect(x, y, w, h, fill)
+def set_x(x, String(_, y, str, anchor, baseline)):
+  String(x, y, str, anchor, baseline)
+def set_x(x, Viewport(_, y, w, h, fill, margin, scale, translate, g)):
+  Viewport(x, y, w, h, fill, margin, scale, translate, g);
+
+def dimensions2((Point(x1, y1), Point(x2, y2))):
+  Point(max(x1, x2), max(y1, y2));
+
+def dimensions(Group(gs)):
+  foldl(curry(dimensions2), Point(0, 0), map(coords_op, gs))
+def dimensions(Polyline(ps, _, _)):
+  foldl(curry(dimensions2), Point(0, 0), ps)
+def dimensions(Rect(_, _, w, h, _)): Point(w, h)
+def dimensions(String(_, _, _, _, _)): Point(0, 0)
+def dimensions(Viewport(_, _, w, h, _, _, _, _, _)): Point(w, h)
+def coords_op(g):
+  def (Point(x, y), Point(w, h)):
+    prod(coords, dimensions, g);
+
+  Point(x + w, y + h);
+
+def width(g):
+  def Point(w, _): dimensions(g);
+
+  w;
+
+def height(g):
+  def Point(_, h): dimensions(g);
+
+  h;
+
+def spaceRight(z, sep, gs):
+  zipWith(set_x, iterate(length(gs), (+)(sep), z), gs);
+
+def colours1: [
+  "#66c2a5",
+  "#a6d854",
+  "#ffd92f",
+  "#e5c494",
+  "#fc8d62",
+  "#b3b3b3",
+  "#8da0cb",
+  "#e78ac3"
+];
+
+def colours2: [
+  "#e41a1c",
+  "#377eb8",
+  "#4daf4a",
+  "#984ea3",
+  "#ff7f00",
+  "#ffff33",
+  "#a65628",
+  "#f781bf"
+];
+
+def scaleToWidth(w, Rect(x, y, _, h, fill)):
+  Rect(x, y, w, h, fill)
+def scaleToWidth(w, Viewport(x, y, w0, h, fill, margin, Scale(x_scale, y_scale), translate, g)):
+  def scale:
+    Scale((x_scale * w) / w0, y_scale);
+
+  Viewport(x, y, w, h, fill, margin, scale, translate, g);
+
+def stackRight(sep, gs):
+  map(scaleToWidth(1 - sep), spaceRight(sep / 2, 1, gs));
+
+def groupRight(sep, gs):
+  Viewport(0, 0, length(gs), maximum(map(height, gs)), "none", 0, Scale(1, 1), Translate(0, 0), Group(stackRight(sep, gs)));
+
+def tickEvery(n):
+  def m:
+    floor(logBase(10, n));
+
+  if n <= 2 * 10 ** m: 2 * 10 ** (m - 1)
+  else: 10 ** m;
+
+def axisStrokeWidth: 0.5
+def axisColour: "black"
+def backgroundColour: "white"
+def defaultMargin: 24
+def markerRadius: 3.5
+def tickLength: 4;
+
+def tick(Horiz, colour, len):
+  Line(Point(0, 0), Point(0, 0 - len), colour, axisStrokeWidth)
+def tick(Vert, colour, len):
+  Line(Point(0, 0), Point(0 - len, 0), colour, axisStrokeWidth);
+
+def label(Horiz, x, distance, str):
+  String(x, (0 - distance) - 4, str, "middle", "hanging")
+def label(Vert, x, distance, str):
+  String(0 - distance, x, str, "end", "central");
+
+def labelledTick(orient, colour, len, str):
+  Group([
+    tick(orient, colour, len),
+    label(orient, 0, len, str)
+  ]);
+
+def mkPoint(Horiz, x, y): Point(y, x)
+def mkPoint(Vert, x, y): Point(x, y);
+
+def axis(orient, x, start, end):
+  def tickSp:
+    tickEvery(end - start)
+  def firstTick:
+    ceilingToNearest(start, tickSp)
+  def lastTick:
+    ceilingToNearest(end, tickSp)
+  def n:
+    floor((end - firstTick) / tickSp) + 1
+  def ys:
+    iterate(n, (+)(tickSp), firstTick)
+  def ys:
+    match firstTick > start:
+      case True: start :| ys
+      case False: ys
+  def ys:
+    match lastTick > end:
+      case True:
+        concat2(ys, [lastTick])
+      case False: ys
+  def ps:
+    map(mkPoint(orient, x), ys)
+  def ax:
+    Group([
+      Line(head(ps), last(ps), axisColour, axisStrokeWidth),
+      Polymarkers(ps, flip(map, ys, compose(labelledTick(orient, axisColour, tickLength), numToStr)))
+    ]);
+
+  (ax, lastTick);
+
+def catAxis(orient, x, catValues):
+  def ys:
+    iterate(length(catValues) + 1, (+)(1), 0)
+  def ps:
+    map(mkPoint(orient, x), ys);
+
+  Group([
+    Line(head(ps), last(ps), axisColour, axisStrokeWidth),
+    Polymarkers(tail(ps), map(const(tick(orient, axisColour, tickLength)), catValues)),
+    Polymarkers(flip(map, tail(ps), (lambda Point(x, y): Point(x - 0.5, y))), map(label(orient, -0.5, 0), catValues))
+  ]);
+
+def 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));
+
+def lineChart(withAxes, colours, x_start, data):
+  def xs: map(fst, data)
+  def nCat:
+    length(snd(head(data)));
+
+  def plot((n, colour)):
+    def ps:
+      map((lambda (x, kvs): Point(x, snd(nth(n, kvs)))), data);
+
+    Group([
+      Polyline(ps, colour, 1),
+      Polymarkers(ps, repeat(length(ps), Circle(0, 0, markerRadius, colour)))
+    ]);
+
+  def lines:
+    zipWith(curry(plot), iterate(nCat, (+)(1), 0), colours)
+  def x_finish: last(xs)
+  def y_finish:
+    maximum(flip(map, data, (lambda (_, kvs): maximum(map(snd, kvs)))));
+
+  match withAxes:
+    case True:
+      def (x_axis, x_finish):
+        axis(Horiz, 0, x_start, x_finish)
+      def (y_axis, y_finish'):
+        axis(Vert, x_start, 0, y_finish);
+
+      viewport(x_start, x_finish, y_finish', defaultMargin, x_axis :| y_axis :| lines)
+    case False:
+      viewport(x_start, x_finish, y_finish, 0, lines);
+
+def categoricalChart(plotValue, withAxes, colours, sep, data):
+  def gs:
+    stackRight(sep, plotValue(colours, map(snd, data)))
+  def w: length(gs)
+  def h:
+    maximum(map(height, gs));
+
+  match withAxes:
+    case True:
+      def x_axis:
+        catAxis(Horiz, 0, map(fst, data))
+      def (y_axis, h'): axis(Vert, 0, 0, h);
+
+      viewport(0, w, h', defaultMargin, concat2(gs, [x_axis, y_axis]))
+    case False:
+      viewport(0, w, h, 0, gs);
+
+def rects(colours, ns):
+  zipWith((lambda colour, n: Rect(0, 0, 1, n, colour)), colours, ns);
+
+def stackedBar(colours, ns):
+  def heights: map(snd, ns)
+  def subtotals:
+    scanl1((+), 0, heights)
+  def dims:
+    zip(0 :| subtotals, heights)
+  def rects:
+    map((lambda ((y, height), colour): Rect(0, y, 1, height, colour)), zip(dims, colours));
+
+  Viewport(0, 0, 1, last(subtotals), "none", 0, Scale(1, 1), Translate(0, 0), Group(rects));
+
+def barChart:
+  categoricalChart(rects);
+
+def groupedBarChart:
+  categoricalChart(compose(map, flip(barChart(False), 0)));
+
+def stackedBarChart:
+  categoricalChart(compose(map, stackedBar));
+
+def caption(str, Viewport(x, y, w, h, fill, margin, scale, translate, g)):
+  def g':
+    Group([
+      String(x + w / 2, -2, str, "middle", "hanging"),
+      Viewport(0, 0, w, h, fill, margin, scale, translate, g)
+    ]);
+
+  Viewport(x, y, w, h, backgroundColour, defaultMargin / 2 + 4, Scale(1, 1), Translate(0, 0), g');

package/dist/fluid/fluid/lib/matrix.fld

@@ -1,41 +1,44 @@
-let zero m n image =
-    let (m_max, n_max) = dims image
-    in if (m >= 1) `and` (m <= m_max) `and` (n >= 1) `and` (n <= n_max)
-    then image!(m, n)
-    else 0;
-
-let wrap m n image =
-    let (m_max, n_max) = dims image
-    in image!( ((m - 1) `mod` m_max) + 1, ((n - 1) `mod` n_max) + 1);
-
-let extend m n image =
-    let (m_max, n_max) = dims image;
-        m' = min (max m 1) m_max;
-        n' = min (max n 1) n_max
-    in image!(m', n');
-
-let matrixSum matr =
-    let (m, n) = dims matr
-    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 =
-              @doc("""Intermediate matrix for element (${m'}, ${n'})""")
-              [| let x = m' + i' - 1 - half_i;
-                     y = n' + j' - 1 - half_j in
-                @doc("""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 @doc("""Intermediate matrix""")
-        [| sum [ a!(i', k) * b!(k, j') | k <- enumFromTo 1 n]
-        | (i', j') in (m, j) |];
+def zero(m, n, image):
+  def (m_max, n_max): dims(image);
+
+  if m >= 1 |and| m <= m_max |and| n >= 1 |and| n <= n_max: image ! (m, n)
+  else: 0;
+
+def wrap(m, n, image):
+  def (m_max, n_max): dims(image);
+
+  image ! (m - 1 |mod| m_max + 1, n - 1 |mod| n_max + 1);
+
+def extend(m, n, image):
+  def (m_max, n_max): dims(image)
+  def m':
+    min(max(m, 1), m_max)
+  def n':
+    min(max(n, 1), n_max);
+
+  image ! (m', n');
+
+def matrixSum(matr):
+  def (m, n): dims(matr);
+
+  foldl((+), 0, [matr ! (i, j) for (i, j) in range((1, 1), (m, n))]);
+
+def convolve(image, kernel, lookup):
+  def ((m, n), (i, j)):
+    (dims(image), dims(kernel))
+  def (half_i, half_j):
+    (i |quot| 2, j |quot| 2)
+  def area: i * j;
+  def interMatrix(m', n'):
+    @doc("""Intermediate matrix for element ( ${m'} , ${n'} )""")
+    [| @doc("""Multiply these two elements""") lookup(((m' + i') - 1) - half_i, ((n' + j') - 1) - half_j, image) * kernel ! (i', j') for (i', j') in (i, j) |];
+
+  [| matrixSum(interMatrix(m', n')) |quot| area for (m', n') in (m, n) |];
+
+def matMul(a, b):
+  def ((m, n), (i, j)): (dims(a), dims(b));
+
+  if not(n == i):
+    error("Dimensions don't line up")
+  else:
+    @doc("""Intermediate matrix""") [| sum([a ! (i', k) * b ! (k, j') for k in enumFromTo(1, n)]) for (i', j') in (m, j) |];