Add bisector.center.

Fixes #138.

Author: Fil

README.md

@@ -258,6 +258,10 @@ Equivalent to [bisectLeft](#bisectLeft), but uses this bisector’s associated c
 
 Equivalent to [bisectRight](#bisectRight), but uses this bisector’s associated comparator.
 
+<a name="bisector_center" href="#bisector_center">#</a> <i>bisector</i>.<b>center</b>(<i>array</i>, <i>x</i>[, <i>lo</i>[, <i>hi</i>]]) · [Source](https://github.com/d3/d3-array/blob/master/src/bisector.js)
+
+Returns the index of the closest value to *x* in the given sorted *array*. This expects that the bisector’s associated accessor returns a quantitative value, or that the bisector’s associated comparator returns a signed distance; otherwise, this method is equivalent to *bisector*.left.
+
 <a name="quickselect" href="#quickselect">#</a> d3.<b>quickselect</b>(<i>array</i>, <i>k</i>, <i>left</i> = 0, <i>right</i> = <i>array</i>.length - 1, <i>compare</i> = ascending) · [Source](https://github.com/d3/d3-array/blob/master/src/quickselect.js), [Examples](https://observablehq.com/@d3/d3-quickselect)
 
 See [mourner/quickselect](https://github.com/mourner/quickselect/blob/master/README.md).

src/bisector.js

@@ -1,33 +1,46 @@
 import ascending from "./ascending.js";
 
-export default function(compare) {
-  if (compare.length === 1) compare = ascendingComparator(compare);
-  return {
-    left: function(a, x, lo, hi) {
-      if (lo == null) lo = 0;
-      if (hi == null) hi = a.length;
-      while (lo < hi) {
-        var mid = lo + hi >>> 1;
-        if (compare(a[mid], x) < 0) lo = mid + 1;
-        else hi = mid;
-      }
-      return lo;
-    },
-    right: function(a, x, lo, hi) {
-      if (lo == null) lo = 0;
-      if (hi == null) hi = a.length;
-      while (lo < hi) {
-        var mid = lo + hi >>> 1;
-        if (compare(a[mid], x) > 0) hi = mid;
-        else lo = mid + 1;
-      }
-      return lo;
+export default function(f) {
+  let delta = f;
+  let compare = f;
+
+  if (f.length === 1) {
+    delta = (d, x) => f(d) - x;
+    compare = ascendingComparator(f);
+  }
+
+  function left(a, x, lo, hi) {
+    if (lo == null) lo = 0;
+    if (hi == null) hi = a.length;
+    while (lo < hi) {
+      const mid = (lo + hi) >>> 1;
+      if (compare(a[mid], x) < 0) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo;
+  }
+
+  function right(a, x, lo, hi) {
+    if (lo == null) lo = 0;
+    if (hi == null) hi = a.length;
+    while (lo < hi) {
+      const mid = (lo + hi) >>> 1;
+      if (compare(a[mid], x) > 0) hi = mid;
+      else lo = mid + 1;
     }
-  };
+    return lo;
+  }
+
+  function center(a, x, lo, hi) {
+    if (lo == null) lo = 0;
+    if (hi == null) hi = a.length;
+    const i = left(a, x, lo, hi);
+    return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;
+  }
+
+  return {left, center, right};
 }
 
 function ascendingComparator(f) {
-  return function(d, x) {
-    return ascending(f(d), x);
-  };
+  return (d, x) => ascending(f(d), x);
 }

test/bisect-test.js

@@ -19,6 +19,10 @@ tape("bisectLeft(array, value) returns the index of the first match", (test) =>
   test.equal(d3.bisectLeft(numbers, 3), 3);
 });
 
+tape("bisectLeft(empty, value) returns zero", (test) => {
+  test.equal(d3.bisectLeft([], 1), 0);
+});
+
 tape("bisectLeft(array, value) returns the insertion point of a non-exact match", (test) => {
   const numbers = [1, 2, 3];
   test.equal(d3.bisectLeft(numbers, 0.5), 0);
@@ -87,6 +91,10 @@ tape("bisectRight(array, value) returns the index after the last match", (test)
   test.equal(d3.bisectRight(numbers, 3), 4);
 });
 
+tape("bisectRight(empty, value) returns zero", (test) => {
+  test.equal(d3.bisectRight([], 1), 0);
+});
+
 tape("bisectRight(array, value) returns the insertion point of a non-exact match", (test) => {
   const numbers = [1, 2, 3];
   test.equal(d3.bisectRight(numbers, 0.5), 0);

test/bisector-test.js

@@ -17,6 +17,10 @@ tape("bisector(comparator).left(array, value) returns the index of the first mat
   test.equal(bisectLeft(boxes, box(3)), 3);
 });
 
+tape("bisector(comparator).left(empty, value) returns zero", (test) => {
+  test.equal(d3.bisector(() => { throw new Error(); }).left([], 1), 0);
+});
+
 tape("bisector(comparator).left(array, value) returns the insertion point of a non-exact match", (test) => {
   const boxes = [1, 2, 3].map(box);
   const bisectLeft = d3.bisector(ascendingBox).left;
@@ -92,6 +96,10 @@ tape("bisector(comparator).right(array, value) returns the index after the last
   test.equal(bisectRight(boxes, box(3)), 4);
 });
 
+tape("bisector(comparator).right(empty, value) returns zero", (test) => {
+  test.equal(d3.bisector(() => { throw new Error(); }).right([], 1), 0);
+});
+
 tape("bisector(comparator).right(array, value) returns the insertion point of a non-exact match", (test) => {
   const boxes = [1, 2, 3].map(box);
   const bisectRight = d3.bisector(ascendingBox).right;
@@ -285,6 +293,46 @@ tape("bisector(accessor).right(array, value) handles large sparse d3", (test) =>
   test.equal(bisectRight(boxes, 6, i - 5, i), i - 0);
 });
 
+tape("bisector(accessor).center(array, value) returns the closest index", (test) => {
+  const data = [0, 1, 2, 3, 4];
+  const bisectCenter = d3.bisector(d => +d).center;
+  test.equal(bisectCenter(data, 2), 2);
+  test.equal(bisectCenter(data, 2.2), 2);
+  test.equal(bisectCenter(data, 2.6), 3);
+  test.equal(bisectCenter(data, 3), 3);
+});
+
+tape("bisector(comparator).center(array, value) returns the closest index", (test) => {
+  const data = [0, 1, 2, 3, 4];
+  const bisectCenter = d3.bisector((d, x) => +d - x).center;
+  test.equal(bisectCenter(data, 2), 2);
+  test.equal(bisectCenter(data, 2.2), 2);
+  test.equal(bisectCenter(data, 2.6), 3);
+  test.equal(bisectCenter(data, 3), 3);
+});
+
+tape("bisector(comparator).center(empty, value) returns zero", (test) => {
+  test.equal(d3.bisector(() => { throw new Error(); }).center([], 1), 0);
+});
+
+tape("bisector(ascending).center(array, value) returns the left value", (test) => {
+  const data = [0, 1, 2, 3, 4];
+  const bisectCenter = d3.bisector(d3.ascending).center;
+  test.equal(bisectCenter(data, 2.0), 2);
+  test.equal(bisectCenter(data, 2.2), 3);
+  test.equal(bisectCenter(data, 2.6), 3);
+  test.equal(bisectCenter(data, 3.0), 3);
+});
+
+tape("bisector(ordinalAccessor).center(array, value) returns the left value", (test) => {
+  const data = ["aa", "bb", "cc", "dd", "ee"];
+  const bisectCenter = d3.bisector(d => d).center;
+  test.equal(bisectCenter(data, "cc"), 2);
+  test.equal(bisectCenter(data, "ce"), 3);
+  test.equal(bisectCenter(data, "cf"), 3);
+  test.equal(bisectCenter(data, "dd"), 3);
+});
+
 function box(value) {
   return {value: value};
 }