Raise an error when a reducer expects numeric input but is given non-numeric input

Add tests for the normalize transform
closes #473

Author: Fil

src/mark.js

@@ -340,3 +340,14 @@ export function isTemporal(values) {
     return value instanceof Date;
   }
 }
+
+function isNumeric(values) {
+  for (const value of values) {
+    if (value == null) continue;
+    return !isNaN(+value);
+  }
+}
+
+export function checkNumeric(S) {
+  if (!isNumeric(S)) throw new Error("the reducer expects numeric input");
+}

src/transforms/group.js

@@ -1,6 +1,6 @@
 import {group as grouper, sort, sum, deviation, min, max, mean, median, mode, variance, InternSet} from "d3";
 import {firstof} from "../defined.js";
-import {valueof, maybeColor, maybeInput, maybeTransform, maybeTuple, maybeLazyChannel, lazyChannel, first, identity, take, labelof, range} from "../mark.js";
+import {valueof, maybeColor, maybeInput, maybeTransform, maybeTuple, maybeLazyChannel, lazyChannel, first, identity, take, labelof, range, checkNumeric} from "../mark.js";
 
 // Group on {z, fill, stroke}.
 export function groupZ(outputs, options) {
@@ -143,12 +143,12 @@ export function maybeReduce(reduce, value) {
     case "sum": return value == null ? reduceCount : reduceSum;
     case "proportion": return reduceProportion(value, "data");
     case "proportion-facet": return reduceProportion(value, "facet");
-    case "deviation": return reduceAccessor(deviation);
+    case "deviation": return reduceAccessor(deviation, true);
     case "min": return reduceAccessor(min);
     case "max": return reduceAccessor(max);
-    case "mean": return reduceAccessor(mean);
-    case "median": return reduceAccessor(median);
-    case "variance": return reduceAccessor(variance);
+    case "mean": return reduceAccessor(mean, true);
+    case "median": return reduceAccessor(median, true);
+    case "variance": return reduceAccessor(variance, true);
     case "mode": return reduceAccessor(mode);
   }
   throw new Error("invalid reduce");
@@ -170,9 +170,10 @@ function reduceFunction(f) {
   };
 }
 
-function reduceAccessor(f) {
+function reduceAccessor(f, check) {
   return {
     reduce(I, X) {
+      if (check) checkNumeric(X);
       return f(I, i => X[i]);
     }
   };
@@ -212,7 +213,7 @@ const reduceDistinct = {
   }
 };
 
-const reduceSum = reduceAccessor(sum);
+const reduceSum = reduceAccessor(sum, true);
 
 function reduceProportion(value, scope) {
   return value == null

src/transforms/normalize.js

@@ -1,6 +1,6 @@
 import {extent, mean, median, sum} from "d3";
 import {defined} from "../defined.js";
-import {take} from "../mark.js";
+import {checkNumeric, take} from "../mark.js";
 import {mapX, mapY} from "./map.js";
 
 export function normalizeX({basis, ...options} = {}) {
@@ -28,6 +28,7 @@ function normalize(basis) {
 function normalizeBasis(basis) {
   return {
     map(I, S, T) {
+      checkNumeric(S);
       const b = +basis(I, S);
       for (const i of I) {
         T[i] = S[i] === null ? NaN : S[i] / b;
@@ -38,6 +39,7 @@ function normalizeBasis(basis) {
 
 const normalizeExtent = {
   map(I, S, T) {
+    checkNumeric(S);
     const [s1, s2] = extent(I, i => S[i]), d = s2 - s1;
     for (const i of I) {
       T[i] = S[i] === null ? NaN : (S[i] - s1) / d;

src/transforms/window.js

@@ -1,5 +1,6 @@
 import {mapX, mapY} from "./map.js";
 import {deviation, max, min, median, variance} from "d3";
+import {checkNumeric} from "../mark.js";
 
 export function windowX({k, reduce, shift, ...options} = {}) {
   return mapX(window(k, reduce, shift), options);
@@ -45,6 +46,7 @@ function maybeReduce(reduce = "mean") {
 function reduceSubarray(f) {
   return (k, s) => ({
     map(I, S, T) {
+      checkNumeric(S);
       const C = Float64Array.from(I, i => S[i] === null ? NaN : S[i]);
       let nans = 0;
       for (let i = 0; i < k - 1; ++i) if (isNaN(C[i])) ++nans;
@@ -60,6 +62,7 @@ function reduceSubarray(f) {
 function reduceSum(k, s) {
   return {
     map(I, S, T) {
+      checkNumeric(S);
       let nans = 0;
       let sum = 0;
       for (let i = 0; i < k - 1; ++i) {
@@ -95,6 +98,7 @@ function reduceMean(k, s) {
 function reduceDifference(k, s) {
   return {
     map(I, S, T) {
+      checkNumeric(S);
       for (let i = 0, n = I.length - k; i < n; ++i) {
         const a = S[I[i]];
         const b = S[I[i + k - 1]];
@@ -107,6 +111,7 @@ function reduceDifference(k, s) {
 function reduceRatio(k, s) {
   return {
     map(I, S, T) {
+      checkNumeric(S);
       for (let i = 0, n = I.length - k; i < n; ++i) {
         const a = S[I[i]];
         const b = S[I[i + k - 1]];

test/transforms/normalize-test.js

@@ -0,0 +1,31 @@
+import * as Plot from "@observablehq/plot";
+import assert from "assert";
+
+it("normalizeX normalizes as expected", () => {
+  const data = [2, 10, 8];
+  testNormalize(data, undefined, [1, 5, 4]);
+  testNormalize(data, "first", [1, 5, 4]);
+  testNormalize(data, "last", [0.25, 1.25, 1]);
+  testNormalize(data, "mean", [0.3, 1.5, 1.2]);
+  testNormalize(data, "sum", [0.1, 0.5, 0.4]);
+});
+
+it("normalizeX throws on non-numeric values", () => {
+  const data = ["A", 10, 8];
+  testNormalizeThrows(data);
+  testNormalizeThrows(data, "first");
+  testNormalizeThrows(data, "last");
+  testNormalizeThrows(data, "mean");
+  testNormalizeThrows(data, "sum");
+});
+
+function testNormalize(data, basis, r) {
+  const mark = Plot.dot(data, Plot.normalizeX({x: data, basis}));
+  const c = new Map(mark.initialize().channels);
+  assert.deepStrictEqual(c.get("x").value, r);
+}
+
+function testNormalizeThrows(data, basis) {
+  const mark = Plot.dot(data, Plot.normalizeX({x: data, basis}));
+  assert.throws(() => mark.initialize());
+}

test/transforms/reduce-test.js

@@ -10,6 +10,14 @@ it("baked-in reducers reduce as expected", () => {
   testReducer(data, "min", 0);
   testReducer(data, "sum", 21);
   testReducer(data, "variance", 10.7);
+  testReducer(data, "mode", 0);
+});
+
+it("baked-in non-numeric reducers throw on non-numeric data", () => {
+  const data = ["A", "B", "C", "B"];
+  testReducer(data, "min", "A");
+  testReducer(data, "max", "C");
+  testReducer(data, "mode", "B");
 });
 
 it("function reducers reduce as expected", () => {
@@ -18,8 +26,22 @@ it("function reducers reduce as expected", () => {
   testReducer(data, v => v.join(", "), "0, 1, 2, 4, 5, 9");
 });
 
+it("baked-in numeric reducers throw on non-numeric data", () => {
+  const data = ["A", "B", "C", "A"];
+  testReducerThrows(data, "deviation");
+  testReducerThrows(data, "mean");
+  testReducerThrows(data, "median");
+  testReducerThrows(data, "sum");
+  testReducerThrows(data, "variance");
+});
+
 function testReducer(data, x, r) {
   const mark = Plot.dot(data, Plot.groupZ({x}, {x: d => d}));
   const c = new Map(mark.initialize().channels);
   assert.deepStrictEqual(c.get("x").value, [r]);
 }
+
+function testReducerThrows(data, x) {
+  const mark = Plot.dot(data, Plot.groupZ({x}, {x: d => d}));
+  assert.throws(() => mark.initialize());
+}

test/transforms/windowMean-test.js

@@ -47,3 +47,10 @@ it("movingAverage respects shift", () => {
   assert.deepStrictEqual(mt.x.transform(), [,, 1, 2, 3, 4]);
 });
 
+it("movingAverage throws on non-numeric data", () => {
+  const data = ["A", 1, 2, 3, 4, 5];
+  const mc = Plot.windowX({k: 3, x: d => d});
+  assert.throws(() => {
+    mc.transform(data, [d3.range(data.length)]);
+  });
+});