@explorable-viz/fluid 0.12.1 → 0.12.3

package/website/article/static/fluid/lib/graphics.fld

@@ -0,0 +1,274 @@
+# type Colour = Str
+# type Colours = List Colour
+# type Cat = Str
+
+# Group has location (0, 0) because it doesn't interfere with positioning of its children.
+# GraphicsElement -> Point
+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)
+
+# GraphicsElement -> Float
+def get_x(g):
+  def Point(x, _): coords(g)
+  x
+
+# GraphicsElement -> Float
+def get_y(g):
+  def Point(_, y): coords(g)
+  y
+
+# Want some kind of typeclass mechanism plus record accessors/updaters.
+# Float -> GraphicsElement -> GraphicsElement
+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)
+
+# (Point, Point) -> Point
+def 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
+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)
+
+# GraphicsElement -> Float
+def width(g):
+  def Point(w, _): dimensions(g)
+  w
+
+# GraphicsElement -> Float
+def height(g):
+  def Point(_, h): dimensions(g)
+  h
+
+# Float -> Float -> List GraphicsElement -> List GraphicsElement
+def space_right(z, sep, gs):
+  zip_with(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
+def colours1: [
+  "#66c2a5",
+  "#a6d854",
+  "#ffd92f",
+  "#e5c494",
+  "#fc8d62",
+  "#b3b3b3",
+  "#8da0cb",
+  "#e78ac3"
+]
+
+def 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
+def scale_to_width(w, Rect(x, y, _, h, fill)):
+  Rect(x, y, w, h, fill)
+def scale_to_width(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)
+
+# Float -> List GraphicsElement -> List GraphicsElement
+def stack_right(sep, gs):
+  map(scale_to_width(1 - sep), space_right(sep / 2, 1, gs))
+
+# Float -> List GraphicsElement -> GraphicsElement
+def group_right(sep, gs):
+  Viewport(0, 0, length(gs), maximum(map(height, gs)), "none", 0, Scale(1, 1), Translate(0, 0), Group(stack_right(sep, gs)))
+
+# Heuristic saying how often to place a tick on an axis of length n.
+# Float -> Float
+def tick_every(n):
+  def m: floor(log_base(10, n))
+
+  if n <= 2 * 10 ** m: 2 * 10 ** (m - 1)
+  else: 10 ** m
+
+def axis_stroke_width: 0.5
+def axis_colour: "black"
+def background_colour: "white"
+def default_margin: 24
+def marker_radius: 3.5
+def tick_length: 4
+
+# Helpers for axis functions.
+# Orient -> Colour -> Float -> GraphicsElement
+def tick(Horiz, colour, len):
+  Line(Point(0, 0), Point(0, 0 - len), colour, axis_stroke_width)
+def tick(Vert, colour, len):
+  Line(Point(0, 0), Point(0 - len, 0), colour, axis_stroke_width)
+
+# Orient -> Float -> Float -> Str -> GraphicsElement
+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")
+
+# Orient -> Colour -> Float -> Str -> GraphicsElement
+def labelled_tick(orient, colour, len, str):
+  Group([
+    tick(orient, colour, len),
+    label(orient, 0, len, str)
+  ])
+
+# Orient -> Float -> Float -> Point
+def mk_point(Horiz, x, y): Point(y, x)
+def mk_point(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
+def axis(orient, x, start, end):
+  def tick_sp: tick_every(end - start)
+  def first_tick: ceiling_to_nearest(start, tick_sp)
+  def last_tick: ceiling_to_nearest(end, tick_sp)
+  def n: floor((end - first_tick) / tick_sp) + 1
+  def ys: iterate(n, (+)(tick_sp), first_tick)
+  def ys:
+    if first_tick > start: start :| ys
+    else: ys
+  def ys:
+    if last_tick > end: concat2(ys, [last_tick])
+    else: ys
+  def ps: map(mk_point(orient, x), ys)
+  def ax:
+    Group([
+      Line(head(ps), last(ps), axis_colour, axis_stroke_width),
+      Polymarkers(ps, flip(map, ys, compose(labelled_tick(orient, axis_colour, tick_length), num_to_str)))
+    ])
+
+  (ax, last_tick)
+
+# x is position of this axis on the other axis.
+# Orient -> Float -> List Cat -> GraphicsElement
+def cat_axis(orient, x, cat_values):
+  def ys: iterate(length(cat_values) + 1, (+)(1), 0)
+  def ps: map(mk_point(orient, x), ys)
+
+  Group([
+    Line(head(ps), last(ps), axis_colour, axis_stroke_width),
+    Polymarkers(tail(ps), map(const(tick(orient, axis_colour, tick_length)), cat_values)),
+    Polymarkers(flip(map, tail(ps), lambda Point(x, y): Point(x - 0.5, y)), map(label(orient, -0.5, 0), cat_values))
+  ])
+
+# Float -> Float -> Float -> Float -> List GraphicsElement -> GraphicsElement
+def viewport(x_start, x_finish, y_finish, margin, gs):
+  Viewport(0, 0, x_finish - x_start, y_finish, background_colour, 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
+def line_chart(with_axes, colours, x_start, data):
+  def xs: map(fst, data)
+  def n_cat: length(snd(head(data)))
+
+  # (Int, Colour) -> GraphicsElement
+  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, marker_radius, colour)))
+    ])
+
+  # List GraphicsElement
+  def lines:
+    zip_with(curry(plot), iterate(n_cat, (+)(1), 0), colours)
+  def x_finish: last(xs)
+  def y_finish:
+    maximum(flip(map, data, lambda (_, kvs): maximum(map(snd, kvs))))
+
+  if with_axes:
+    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_, default_margin, x_axis :| y_axis :| lines)
+  else:
+    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
+def categorical_chart(plot_value, with_axes, colours, sep, data):
+  def gs:
+    stack_right(sep, plot_value(colours, map(snd, data)))
+  def w: length(gs)
+  def h: maximum(map(height, gs))
+
+  if with_axes:
+    def x_axis: cat_axis(Horiz, 0, map(fst, data))
+    def (y_axis, h_): axis(Vert, 0, 0, h)
+    viewport(0, w, h_, default_margin, concat2(gs, [x_axis, y_axis]))
+  else:
+    viewport(0, w, h, 0, gs)
+
+# Colours -> List a -> GraphicsElement
+def rects(colours, ns):
+  zip_with(lambda 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
+def stacked_bar(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))
+
+# Bool -> Colours -> Float -> List (a, Float) -> GraphicsElement
+def bar_chart:
+  categorical_chart(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
+def grouped_bar_chart:
+  categorical_chart(compose(map, flip(bar_chart(False), 0)))
+
+# See stacked_bar for strong (unjustified) assumption about uniformity of data.
+# Bool -> Colours -> Num -> List (a, List (b, Num)) -> GraphicsElement
+def stacked_bar_chart:
+  categorical_chart(compose(map, stacked_bar))
+
+# Bit of a hack, but how text fits into our model is a bit unclear at the moment.
+# Str -> GraphicsElement -> GraphicsElement
+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, background_colour, default_margin / 2 + 4, Scale(1, 1), Translate(0, 0), g_)

package/website/article/static/fluid/lib/matrix.fld

@@ -0,0 +1,40 @@
+def zero(m, n, image):
+  def (m_size, n_size): dims(image)
+  if m >= 0 and m < m_size and n >= 0 and n < n_size: image ! (m, n)
+  else: 0
+
+def wrap(m, n, image):
+  def (m_size, n_size): dims(image)
+  image ! (m % m_size, n % n_size)
+
+def extend(m, n, image):
+  def (m_size, n_size): dims(image)
+  def m_:
+    min(max(m, 0), m_size - 1)
+  def n_:
+    min(max(n, 0), n_size - 1)
+  image ! (m_, n_)
+
+def matrix_sum(matr):
+  def (m, n): dims(matr)
+  foldl((+), 0, [matr ! (i, j) for (i, j) in range2d((0, 0), (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_):
+    [| lookup(m_ + i_ - half_i, n_ + j_ - half_j, image) * kernel ! (i_, j_) for (i_, j_) in (i, j) |]
+
+  [| matrix_sum(interMatrix(m_, n_)) |quot| area for (m_, n_) in (m, n) |]
+
+def mat_mul(a, b):
+  def ((m, n), (i, j)): (dims(a), dims(b))
+
+  if not(n == i):
+    error("Dimensions don't line up")
+  else:
+    @doc(f"""Intermediate matrix""")
+    [| sum([a!(i_, k) * b!(k, j_) for k in range(0, n)]) for (i_, j_) in (m, j) |]

package/website/article/static/fluid/lib/prelude.fld

@@ -0,0 +1,348 @@
+# "Num" throughout means (Int + Float).
+
+# To resolve in new semantics: expected dependencies don't arise for and/or unless they  make a fresh value.
+# Bool -> Bool
+def and(False, y): False
+def and(True, True): True
+def and(True, False): False
+
+# Bool -> Bool
+def or(True, y): True
+def or(False, True): True
+def or(False, False): False
+
+# Bool -> Bool
+def not(True): False
+def not(False): True
+
+# Int -> Int -> Ordering
+def compare(x, y):
+  if x > y: GT
+  else:
+    if x < y: LT
+    else: EQ
+
+# (b -> b -> c) -> (a -> b) -> a -> a -> c
+def on(bin_op, prop, x, y):
+  bin_op(prop(x), prop(y))
+
+# Num -> Num
+def negate: (-)(0)
+
+# Log of x in base y.
+# Float -> Float -> Float
+def log_base(x, y): log(y) / log(x)
+
+# Float -> Float -> Float
+def ceiling_to_nearest(n, m): ceiling(n / m) * m
+
+# (b -> c) -> (a -> b) -> a -> c
+# Want infix <<<
+def compose(f, g, x): f(g(x))
+
+# ((a, b) -> c) -> a -> b -> c
+def curry(f, x, y): f((x, y))
+
+# (a -> b -> c) -> (a, b) -> c
+def uncurry(f, (x, y)): f(x, y)
+
+# a -> b -> a
+def const(x, _): x
+
+# (a -> b) -> (a, c) -> (b, c)
+def first(f, (a, c)): (f(a), c)
+
+# (a, b) -> b
+def snd((_, y)): y
+
+# (a -> b) -> (c, a) -> (c, b)
+def second(f, (c, a)): (c, f(a))
+
+# (a -> b -> c) -> b -> a -> c
+def flip(f, x, y): f(y, x)
+
+# (a, b) -> a
+def fst((x, _)): x
+
+# a -> a
+def id(x): x
+
+# (a -> b) -> (a -> c) -> a -> (b, c)
+# Want infix &&&
+def prod(f, g, x): (f(x), g(x))
+
+# (a, b) -> (b, a)
+def swap((a, b)): (b, a)
+
+# List a -> a
+def head([]):
+  error("Can't take head of empty list")
+def head(x :| _): x
+
+# List a -> List a
+def tail([]):
+  error("Can't take tail of empty list")
+def tail(_ :| xs): xs
+
+# Eq a => a -> List a -> Bool
+def elem(x, []): False
+def elem(x, y :| xs):
+  x == y or elem(x, xs)
+
+# (a -> Bool) -> List a -> Option a
+def find(p, []): None
+def find(p, x :| xs):
+  if p(x): Some(x)
+  else: find(p, xs)
+
+# String -> String -> List Dict -> Option Dict
+def find_with_key(k, v, rs):
+  find(lambda y: y[k] == v, rs)
+
+# Option a -> a
+def from_some(None): error("Expected Some!")
+def from_some(Some(x)): x
+
+# Option a -> a -> a
+def from_option(None, y): y
+def from_option(Some(x), _): x
+
+# (a -> Bool) -> List a -> List a
+def filter(p, []): []
+def filter(p, x :| xs):
+  def ys: filter(p, xs)
+
+  if p(x): x :| ys
+  else: ys
+
+# (a -> Option b) -> List a -> List b
+def filter_map(p, []): []
+def filter_map(p, x :| xs):
+  match p(x):
+    case None: filter_map(f, xs)
+    case Some(y):
+      y :| filter_map(f, xs)
+
+# Equivalent to but more efficient than length ∘ filter(p)
+def count_if(p):
+  def f(n, x):
+    if p(x): n + 1
+    else: n
+  foldl(f, 0)
+
+# Split list into longest initial segment whose elements satisfy a predicate, and the rest.
+# (a -> Bool) -> List a -> { init :: List a, rest :: List a }
+def span(p, Nil): { init: Nil, rest: Nil }
+def span(p, x :| xs_):
+  if p(x):
+    def { init: ys, rest: zs }: span(p, xs_)
+    { init: x :| ys, rest: zs }
+  else:
+    { init: Nil, rest: x :| xs_ }
+
+# Each returned list is non-empty.
+# (a -> a -> Bool) -> List a -> List (List a)
+def group_by(eq, Nil): Nil
+def group_by(eq, x :| xs):
+  def { init: ys, rest: zs }: span(eq(x), xs)
+  (x :| ys) :| group_by(eq, zs)
+
+# (a -> b -> a) -> a -> List b -> a
+def foldl(op, z, []): z
+def foldl(op, z, x :| xs):
+  foldl(op, op(z, x), xs)
+
+# (a -> b -> a) -> List b -> a
+def foldl1(op, x :| xs): foldl(op, x, xs)
+
+# (a -> b -> b) -> b -> List a -> b
+def foldr(op, z, []): z
+def foldr(op, z, x :| xs):
+  op(x, foldr(op, z, xs))
+
+# (a -> b -> b) -> List a -> b
+def foldr1(op, [x]): x
+def foldr1(op, x :| y :| xs):
+  op(x, foldr1(op, y :| xs))
+
+# (a -> b -> a) -> a -> List b -> List a
+def scanl1(op, z, xs):
+  def go(x, continue, acc):
+    def next: op(acc, x)
+    next :| continue(next)
+  foldr(go, const([]), xs, z)
+
+# (a -> b -> a) -> a -> List b -> List a
+def scanl(op, z, xs):
+  z :| scanl1(op, z, xs)
+
+# (a -> b) -> List a -> List b
+def map(f, []): []
+def map(f, x :| xs): f(x) :| map(f, xs)
+
+# (List a, List a) -> List a
+def append(([], ys)): ys
+def append((x :| xs, ys)):
+  x :| append((xs, ys))
+
+# List a -> List -> List a
+# Want infix ++
+def concat2([], ys): ys
+def concat2(x :| xs, ys):
+  x :| concat2(xs, ys)
+
+# List (List a) -> List a
+def concat: foldr(concat2, [])
+
+# (a -> List b) -> List a -> List b
+def concat_map(f, xs): concat(map(f, xs))
+
+# List String -> String
+def join: foldr((++), "")
+
+# List a -> a -> List a
+def intersperse([], _): []
+def intersperse([x], _): [x]
+def intersperse(x :| y :| ys, sep):
+  x :| sep :| intersperse(y :| ys, sep)
+
+# Int -> (a -> a) -> a -> List a
+def iterate(n, f, z):
+  if n == 0: []
+  else:
+    z :| map(f, iterate(n - 1, f, z))
+
+# List Num -> Num
+def sum: foldr((+), 0)
+
+# List Num -> Num
+def mean(xs):
+  def (s, n): foldl(lambda (s, n), x: (s + x, n + 1), (0, 0), xs)
+  s / n
+
+# List a -> a
+def last([x]): x
+def last(x :| y :| ys): last(y :| ys)
+
+# List a -> Int
+def length([]): 0
+def length(_ :| xs): 1 + length(xs)
+
+# List a -> List a
+def reverse([]): []
+def reverse(x :| xs):
+  append((reverse(xs), [x]))
+
+# Int -> a -> List a
+def repeat: flip(iterate, id)
+
+# Int -> List a -> List a
+def take(n, xs):
+  if n <= 0: []
+  else:
+    match xs:
+      case []: []
+      case x :| xs:
+        x :| take(n - 1, xs)
+
+# Int -> List a -> List a
+def drop(n, xs):
+  if n <= 0: xs
+  else:
+    match xs:
+      case []: []
+      case _ :| xs: drop(n - 1, xs)
+
+# Int -> List a -> List a
+def last_n(n, xs):
+  foldl(compose(const, drop(1)), xs, drop(n, xs))
+
+# Expects non-negative integer as first argument and non-empty list as second argument.
+# Int -> List a -> a
+def nth(n, x :| xs):
+  if n == 0: x
+  else: nth(n - 1, xs)
+
+# Int -> Int -> List (List Int) -> Int
+def nth2(i, j, xss):
+  nth(j, nth(i, xss))
+
+# Partial; requires k to be in the map.
+# Int -> List (Int, b) -> b
+def lookup(k, []):
+  error("Key not found in map")
+def lookup(k, (k_, v) :| kvs):
+  if k == k_: v
+  else: lookup(k, kvs)
+
+# Int -> Int -> Int
+def max(n, m):
+  if n > m: n
+  else: m
+
+# Int -> Int -> Int
+def min(n, m):
+  if n < m: n
+  else: m
+
+# List Int -> Int
+def maximum: foldr1(max)
+
+# List Int -> Int
+def minimum: foldr1(min)
+
+# List (a, b) -> (List a, List b)
+def unzip([]): ([], [])
+def unzip((x, y) :| zs):
+  def (xs, ys): unzip(zs)
+  (x :| xs, y :| ys)
+
+# (a -> b -> c) -> List a -> List b -> List c
+def zip_with(op, [], ys): []
+def zip_with(op, x :| xs, []): []
+def zip_with(op, x :| xs, y :| ys):
+  op(x, y) :| zip_with(op, xs, ys)
+
+# List a -> List b -> List (a, b)
+def zip: zip_with(curry(id))
+
+# Int -> Int -> List Int
+def range(n, m):
+  if n < m: n :| range(n + 1, m)
+  else: []
+
+# (Int, Int) -> (Int, Int) -> List (Int, Int)
+def range2d((m1, n1), (m2, n2)):
+  [(i1, i2) for i1 in range(m1, m2) for i2 in range(n1, n2)]
+
+# Int -> Int -> Int
+def abs(x, y):
+  if x - y < 0: negate(x - y)
+  else: x - y
+
+# Eq a => [a] -> [a]
+def nub(xs):
+  def nub_([], _): []
+  def nub_(x :| xs, ys):
+    if x |elem| ys:
+      nub_(xs, ys)
+    else:
+      x :| nub_(xs, x :| ys)
+
+  nub_(xs, [])
+
+# Int -> Int -> [a] -> [a]
+def slice(begin, end, xs):
+  take(end - begin, drop(begin, xs))
+
+# (a -> Boolean) -> List a -> (List a, List a)
+def split_on(p, data):
+  def go(fls, trs, []):
+    (reverse(fls), reverse(trs))
+  def go(fls, trs, x :| xs):
+    if p(x):
+      go(fls, x :| trs, xs)
+    else:
+      go(x :| fls, trs, xs)
+
+  go([], [], data)