From 98c31d8fb502ba94d818c03e8ee6f0ae7461a915 Mon Sep 17 00:00:00 2001
From: Mike Bostock <mbostock@gmail.com>
Date: Tue, 29 May 2018 12:55:33 -0700
Subject: [PATCH] Add d3.interpolateDiscrete.

---
 README.md             |  4 ++++
 index.js              |  1 +
 src/discrete.js       |  6 ++++++
 test/discrete-test.js | 29 +++++++++++++++++++++++++++++
 4 files changed, 40 insertions(+)
 create mode 100644 src/discrete.js
 create mode 100644 test/discrete-test.js

diff --git a/README.md b/README.md
index 434cfa2..fb22105 100644
--- a/README.md
+++ b/README.md
@@ -124,6 +124,10 @@ Returns an interpolator between the two views *a* and *b* of a two-dimensional p
 
 The returned interpolator exposes a *duration* property which encodes the recommended transition duration in milliseconds. This duration is based on the path length of the curved trajectory through *x,y* space. If you want to a slower or faster transition, multiply this by an arbitrary scale factor (<i>V</i> as described in the original paper).
 
+<a name="interpolateDiscrete" href="#interpolateDiscrete">#</a> d3.<b>interpolateDiscrete</b>(<i>values</i>) [<>](https://github.com/d3/d3-interpolate/blob/master/src/discrete.js "Source")
+
+Returns a discrete interpolator for the given array of *values*. The returned interpolator maps *t* in [0, 1 / *n*) to *values*[0], *t* in [1 / *n*, 2 / *n*) to *values*[1], and so on, where *n* = *values*.length. In effect, this is a lightweight [quantize scale](https://github.com/d3/d3-scale/blob/master/README.md#quantize-scales) with a fixed domain of [0, 1].
+
 ### Sampling
 
 <a name="quantize" href="#quantize">#</a> d3.<b>quantize</b>(<i>interpolator</i>, <i>n</i>) [<>](https://github.com/d3/d3-interpolate/blob/master/src/quantize.js "Source")
diff --git a/index.js b/index.js
index d08cb77..6e05c67 100644
--- a/index.js
+++ b/index.js
@@ -3,6 +3,7 @@ export {default as interpolateArray} from "./src/array";
 export {default as interpolateBasis} from "./src/basis";
 export {default as interpolateBasisClosed} from "./src/basisClosed";
 export {default as interpolateDate} from "./src/date";
+export {default as interpolateDiscrete} from "./src/discrete";
 export {default as interpolateNumber} from "./src/number";
 export {default as interpolateObject} from "./src/object";
 export {default as interpolateRound} from "./src/round";
diff --git a/src/discrete.js b/src/discrete.js
new file mode 100644
index 0000000..b3d1e3b
--- /dev/null
+++ b/src/discrete.js
@@ -0,0 +1,6 @@
+export default function(range) {
+  var n = range.length;
+  return function(t) {
+    return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))];
+  };
+}
diff --git a/test/discrete-test.js b/test/discrete-test.js
new file mode 100644
index 0000000..03786cd
--- /dev/null
+++ b/test/discrete-test.js
@@ -0,0 +1,29 @@
+var tape = require("tape"),
+    interpolate = require("../");
+
+tape("interpolateDiscrete(values)(t) returns the expected values", function(test) {
+  var i = interpolate.interpolateDiscrete("abcde".split(""));
+  test.strictEqual(i(-1), "a");
+  test.strictEqual(i(0), "a");
+  test.strictEqual(i(0.19), "a");
+  test.strictEqual(i(0.21), "b");
+  test.strictEqual(i(1), "e");
+  test.end();
+});
+
+tape("interpolateDiscrete([0, 1]) is equivalent to similar to Math.round", function(test) {
+  var i = interpolate.interpolateDiscrete([0, 1]);
+  test.strictEqual(i(-1), 0);
+  test.strictEqual(i(0), 0);
+  test.strictEqual(i(0.49), 0);
+  test.strictEqual(i(0.51), 1);
+  test.strictEqual(i(1), 1);
+  test.strictEqual(i(2), 1);
+  test.end();
+});
+
+tape("interpolateDiscrete(…)(NaN) returned undefined", function(test) {
+  var i = interpolate.interpolateDiscrete([0, 1]);
+  test.strictEqual(i(NaN), undefined);
+  test.end();
+});