added disk scheduling diagrams

disk-scheduling/algorithms.typ

@@ -0,0 +1,62 @@
+#let schedule-fcfs(places) = {
+  return places
+}
+
+#let schedule-sstf(places) = {
+  let places = places
+  let cur = places.remove(0)
+  let result = (cur,)
+
+  while places.len() != 0 {
+    let best-d = none
+    let best-i = none
+    for (i, val) in places.enumerate() {
+      let d = calc.abs(cur - val)
+      if best-i == none or d < best-d {
+        best-d = d
+        best-i = i
+      }
+    }
+    cur = places.remove(best-i)
+    result.push(cur)
+  }
+  return result
+}
+
+#let schedule-scan(places, initial-dir, min, max) = {
+  assert(initial-dir in (left, right))
+
+  let first = places.first()
+  let places = places.sorted()
+  let i = places.position(v => v == first)
+  let left-side = places.slice(0, i)
+  let right-side = places.slice(i+1)
+
+  let result = if initial-dir == left {
+    (first,) + left-side.rev() + (min,) + right-side
+  } else {
+    (first,) + right-side + (max,) + left-side.rev()
+  }
+
+  return result
+}
+
+#let schedule-cscan(places, min, max) = {
+  let first = places.first()
+  let places = places.sorted()
+  let i = places.position(v => v == first)
+  let left-side = places.slice(0, i)
+  let right-side = places.slice(i+1)
+
+  return (first,) + right-side + (max, min) + left-side
+}
+
+#let schedule-clook(places) = {
+  let first = places.first()
+  let places = places.sorted()
+  let i = places.position(v => v == first)
+  let left-side = places.slice(0, i)
+  let right-side = places.slice(i+1)
+
+  return (first,) + right-side + left-side
+}

disk-scheduling/main.typ

@@ -0,0 +1,39 @@
+#import "algorithms.typ": *
+#import "utils.typ": draw-algo, compute-total
+
+#set document(title: "Disk scheduling algorithms")
+#set page(width: auto, height: auto, margin: 1cm)
+#set text(font: "Source Sans 3")
+
+#let places = (53, 98, 193, 37, 14, 124, 65, 67)
+#let min = 0
+#let max = 199
+
+#let names = ("FCFS", "SSTF", "SCAN", "C-SCAN", "C-LOOK")
+#let places-lst = (
+  schedule-fcfs(places),
+  schedule-sstf(places),
+  schedule-scan(places, left, min, max),
+  schedule-cscan(places, min, max),
+  schedule-clook(places)
+)
+#let graphs = places-lst.map(
+  draw-algo.with(min: min, max: max ,width: 10)
+)
+
+#let wraps = (false,) * 3 + (true,) * 2
+#let compute-total = compute-total.with(min: min, max: max)
+
+#align(center, text(size: 1.2em)[*Disk scheduling algorithms*])
+
+#table(
+  columns: 2,
+  inset: 0.5em,
+  align: center + horizon,
+  ..names.zip(places-lst, wraps).map(((name, places, wrap)) => {
+    rotate(
+      -90deg,
+      reflow: true
+    )[*#name* (total: #compute-total(places, wrap: wrap))]
+  }).zip(graphs).flatten()
+)

disk-scheduling/utils.typ

@@ -0,0 +1,58 @@
+#import "@preview/cetz:0.3.1": canvas, draw
+
+#let draw-algo(places, min: 0, max: 199, width: 10) = canvas({
+  let m = min
+  let M = max
+  let s = M - m
+  let w = width / s
+
+  draw.line((0, 0), (width, 0))
+  let draw-tick(v) = {
+    draw.line((v*w, 0), (v*w, 0.2))
+    draw.content(
+      (v*w, 0.2),
+      str(v),
+      anchor: "south",
+      padding: 3pt
+    )
+  }
+
+  let drawn = (m, M)
+  draw-tick(m)
+  draw-tick(M)
+
+  let pos = ()
+  for (i, place) in places.enumerate() {
+    if place not in drawn {
+      draw-tick(place)
+      drawn.push(place)
+    }
+    
+    let p = (place * w, -i * 0.5)
+    if pos.len() != 0 {
+      draw.line(pos.last(), p, mark: (end: "straight"))
+    }
+    pos.push(p)
+  }
+
+  let bottom-y = -(places.len() - 1) * 0.5
+  draw.line((m*w, 0), (m*w, bottom-y))
+  draw.line((M*w, 0), (M*w, bottom-y))
+})
+
+#let compute-total(places, wrap: false, min: 0, max: 199) = {
+  let total = 0
+  for i in range(places.len() - 1) {
+    let p0 = places.at(i)
+    let p1 = places.at(i + 1)
+    let d = calc.abs(p0 - p1)
+    if wrap {
+      if p1 < p0 {
+        d = (max - p0) + (p1 - min)
+        // d = 0
+      }
+    }
+    total += d
+  }
+  return total
+}