+ Every test with two or more results, on one shared time axis. Each keeps
+ its own scale and reference range; colour shows whether each result was
+ in range, low or high.
+
+
+
+
+
+ {tracks.map((t, i) => (
+
+ ))}
+
+
+
+
+ {fmt(days[0])}
+ {fmt(days[days.length - 1])}
+
+
+
+
+ {pairs.length > 0 && (
+
+
Moved together
+
+ Rose and fell together across the draws they share. That is all it
+ says: not that one causes the other.
+
TestLatest
diff --git a/frontend/src/screens/river.js b/frontend/src/screens/river.js
new file mode 100644
index 0000000..11bc16c
--- /dev/null
+++ b/frontend/src/screens/river.js
@@ -0,0 +1,79 @@
+/**
+ * The arithmetic behind the river view, kept apart from the drawing so it
+ * can be tested. (Ported from vitaline, the standalone timeline app this
+ * view replaces.)
+ */
+
+/** Two tests "moved together" only past this |r|, and only over at least
+ * MIN_SHARED draws. With three shared points a correlation coefficient is
+ * close to noise, so it takes four. Not a significance test -- a personal
+ * lab history is far too small for one -- and never a claim of cause. */
+export const CORRELATION_THRESHOLD = 0.8;
+export const MIN_SHARED = 4;
+
+export function pearson(xs, ys) {
+ const n = xs.length;
+ if (n < 2) return 0;
+ const mx = xs.reduce((a, b) => a + b, 0) / n;
+ const my = ys.reduce((a, b) => a + b, 0) / n;
+ let num = 0;
+ let dx2 = 0;
+ let dy2 = 0;
+ for (let i = 0; i < n; i++) {
+ const dx = xs[i] - mx;
+ const dy = ys[i] - my;
+ num += dx * dy;
+ dx2 += dx * dx;
+ dy2 += dy * dy;
+ }
+ const den = Math.sqrt(dx2 * dy2);
+ return den === 0 ? 0 : num / den;
+}
+
+/** The calendar day a sample was drawn -- two tests from one blood draw share
+ * it even when the lab stamps them a few minutes apart. */
+const dayOf = (iso) => iso.slice(0, 10);
+
+/** Values of two tracks on the days both were measured. */
+export function sharedDraws(a, b) {
+ const byDay = new Map(b.points.filter((p) => p.collected_at).map((p) => [dayOf(p.collected_at), p]));
+ const pairs = [];
+ for (const p of a.points) {
+ if (!p.collected_at) continue;
+ const q = byDay.get(dayOf(p.collected_at));
+ if (q) pairs.push({ day: dayOf(p.collected_at), a: p, b: q });
+ }
+ return pairs;
+}
+
+/** Every pair of tracks that moved together (or opposite), strongest first. */
+export function movedTogether(tracks) {
+ const found = [];
+ for (let i = 0; i < tracks.length; i++) {
+ for (let j = i + 1; j < tracks.length; j++) {
+ const pairs = sharedDraws(tracks[i], tracks[j]);
+ if (pairs.length < MIN_SHARED) continue;
+ const r = pearson(pairs.map((p) => p.a.value), pairs.map((p) => p.b.value));
+ if (Math.abs(r) >= CORRELATION_THRESHOLD) found.push({ i, j, r, n: pairs.length, pairs });
+ }
+ }
+ return found.sort((x, y) => Math.abs(y.r) - Math.abs(x.r));
+}
+
+/** Gradient stops that hold each reading's flag colour until the next
+ * reading, then change sharply at that reading -- "this is what the result
+ * was at each draw", not a blend between two states. `frac` maps a point to
+ * 0..1 along the track. */
+export function stepStops(points, frac) {
+ const stops = [];
+ points.forEach((p, i) => {
+ const f = Math.min(Math.max(frac(p), 0), 1);
+ if (i === 0) {
+ stops.push({ offset: 0, flag: p.flag });
+ } else {
+ stops.push({ offset: Math.max(f - 0.0005, 0), flag: points[i - 1].flag });
+ stops.push({ offset: f, flag: p.flag });
+ }
+ });
+ return stops;
+}
diff --git a/frontend/src/screens/river.test.js b/frontend/src/screens/river.test.js
new file mode 100644
index 0000000..eada37b
--- /dev/null
+++ b/frontend/src/screens/river.test.js
@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+import { MIN_SHARED, movedTogether, pearson, sharedDraws, stepStops } from "./river.js";
+
+const track = (code, values, days = values.map((_, i) => `2026-0${i + 1}-15T08:0${i}:00`)) => ({
+ loinc_code: code,
+ points: values.map((v, i) => ({ value: v, collected_at: days[i], flag: "normal" })),
+});
+
+describe("pearson", () => {
+ it("is 1 and -1 for perfectly paired series, 0 for a flat one", () => {
+ expect(pearson([1, 2, 3], [2, 4, 6])).toBeCloseTo(1);
+ expect(pearson([1, 2, 3], [6, 4, 2])).toBeCloseTo(-1);
+ expect(pearson([1, 2, 3], [5, 5, 5])).toBe(0);
+ });
+});
+
+describe("sharedDraws", () => {
+ it("pairs results from the same day even when stamped minutes apart", () => {
+ const a = track("A", [1, 2], ["2026-01-15T08:00:00", "2026-02-15T08:00:00"]);
+ const b = track("B", [5, 6], ["2026-01-15T08:07:00", "2026-03-01T08:00:00"]);
+ expect(sharedDraws(a, b).map((p) => p.day)).toEqual(["2026-01-15"]);
+ });
+});
+
+describe("movedTogether", () => {
+ it("finds strongly paired tracks over enough shared draws", () => {
+ const found = movedTogether([track("LDL", [100, 120, 140, 160]), track("TC", [180, 200, 221, 240]),
+ track("K", [4.1, 3.9, 4.2, 4.0])]);
+ expect(found.map((f) => [f.i, f.j, f.n])).toEqual([[0, 1, 4]]);
+ expect(found[0].r).toBeGreaterThan(0.99);
+ });
+
+ it("needs at least MIN_SHARED draws -- three points is close to noise", () => {
+ const three = [100, 120, 140];
+ expect(MIN_SHARED).toBe(4);
+ expect(movedTogether([track("A", three), track("B", three)])).toEqual([]);
+ });
+
+ it("reports opposite movement too, with its sign", () => {
+ const found = movedTogether([track("A", [1, 2, 3, 4]), track("B", [8, 6, 4, 2])]);
+ expect(found[0].r).toBeCloseTo(-1);
+ });
+});
+
+describe("stepStops", () => {
+ it("holds each flag until the next reading, then switches sharply", () => {
+ const pts = [{ flag: "normal", x: 0 }, { flag: "high", x: 0.5 }, { flag: "normal", x: 1 }];
+ const stops = stepStops(pts, (p) => p.x);
+ expect(stops.map((s) => s.flag)).toEqual(["normal", "normal", "high", "high", "normal"]);
+ expect(stops[2].offset).toBe(0.5);
+ });
+});