Add d3.interpolateDiscrete.

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")

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";

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)))];
+  };
+}

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();
+});