Add normalize reducers min, max, deviation (#603)

* Add normalize reducers min, ax, deviation, variance

* Remove variance option, fix deviation calculation

* Preserve trailing newline, update readme

* Remove extra new line

* for the normalization basis=deviation, if there is only one point, or all the points are equal, normalize to 0 instead of NaN.

* Plot.normalize unit tests

Co-authored-by: Philippe Rivière <[email protected]>

Author: mkfreeman

README.md

@@ -1431,10 +1431,13 @@ The Plot.normalizeX and Plot.normalizeY transforms normalize series values relat
 
 * *first* - the first value, as in an index chart; the default
 * *last* - the last value
+* *max* - the maximum value
 * *mean* - the mean value (average)
 * *median* - the median value
+* *min* - the minimum value
 * *sum* - the sum of values
 * *extent* - the minimum is mapped to zero, and the maximum to one
+* *deviation* - each value is transformed by subtracting the mean and then dividing by the standard deviation
 * a function to be passed an array of values, returning the desired basis
 
 The Plot.windowX and Plot.windowY transforms compute a moving window around each data point and then derive a summary statistic from values in the current window, say to compute rolling averages, rolling minimums, or rolling maximums. These transforms also take additional options:

src/transforms/normalize.js

@@ -1,4 +1,4 @@
-import {extent, mean, median, sum} from "d3";
+import {extent, deviation, max, mean, median, min, sum} from "d3";
 import {defined} from "../defined.js";
 import {take} from "../mark.js";
 import {mapX, mapY} from "./map.js";
@@ -17,10 +17,13 @@ export function normalize(basis) {
   if (basis === undefined) return normalizeFirst;
   if (typeof basis === "function") return normalizeBasis((I, S) => basis(take(S, I)));
   switch (`${basis}`.toLowerCase()) {
+    case "deviation": return normalizeDeviation;
     case "first": return normalizeFirst;
     case "last": return normalizeLast;
+    case "max": return normalizeMax;
     case "mean": return normalizeMean;
     case "median": return normalizeMedian;
+    case "min": return normalizeMin;
     case "sum": return normalizeSum;
     case "extent": return normalizeExtent;
   }
@@ -61,6 +64,18 @@ const normalizeLast = normalizeBasis((I, S) => {
   }
 });
 
+const normalizeDeviation = {
+  map(I, S, T) {
+    const m = mean(I, i => S[i]);
+    const d = deviation(I, i => S[i]);
+    for (const i of I) {
+      T[i] = S[i] === null ? NaN : d ? (S[i] - m) / d : 0;
+    }
+  }
+};
+
+const normalizeMax = normalizeBasis((I, S) => max(I, i => S[i]));
 const normalizeMean = normalizeBasis((I, S) => mean(I, i => S[i]));
 const normalizeMedian = normalizeBasis((I, S) => median(I, i => S[i]));
+const normalizeMin = normalizeBasis((I, S) => min(I, i => S[i]));
 const normalizeSum = normalizeBasis((I, S) => sum(I, i => S[i]));

test/transforms/normalize-test.js

@@ -0,0 +1,48 @@
+import * as Plot from "@observablehq/plot";
+import assert from "assert";
+
+it("Plot.normalize first", () => {
+  testNormalize([1, 2, 4, 5], "first", [1, 2, 4, 5]);
+});
+
+it("Plot.normalize last", () => {
+  testNormalize([1, 2, 4, 5], "last", [0.2, 0.4, 0.8, 1]);
+});
+
+it("Plot.normalize mean", () => {
+  testNormalize([0, 4, 8, 4], "mean", [0, 1, 2, 1]);
+});
+
+it("Plot.normalize median", () => {
+  testNormalize([1, 2, 6, 6], "median", [0.25, 0.5, 1.5, 1.5]);
+});
+
+it("Plot.normalize min", () => {
+  testNormalize([10, 6, 2], "min", [5, 3, 1]);
+});
+
+it("Plot.normalize max", () => {
+  testNormalize([10, 6, 2], "max", [1, 0.6, 0.2]);
+});
+
+it("Plot.normalize sum", () => {
+  testNormalize([1, 1, 6, 2], "sum", [0.1, 0.1, 0.6, 0.2]);
+});
+
+it("Plot.normalize extent", () => {
+  testNormalize([1, 2, 3], "extent", [0, .5, 1]);
+});
+
+it("Plot.normalize deviation", () => {
+  testNormalize([1, 2, 3], "deviation", [-1, 0, 1]);
+});
+
+it("Plot.normalize deviation doesn’t crash on equal values", () => {
+  testNormalize([1, 1], "deviation", [0, 0]);
+});
+
+function testNormalize(data, basis, r) {
+  const mark = Plot.dot(data, Plot.normalizeY(basis, {y: data}));
+  const c = new Map(mark.initialize().channels);
+  assert.deepStrictEqual(c.get("y").value, r);
+}