sketch of faster binning (1d)

Author: mbostock

src/transforms/bin.js

@@ -1,7 +1,6 @@
-import {bin as binner, extent, thresholdFreedmanDiaconis, thresholdScott, thresholdSturges, utcTickInterval} from "d3";
+import {bisect, extent, thresholdFreedmanDiaconis, thresholdScott, thresholdSturges, ticks, utcTickInterval} from "d3";
 import {
   valueof,
-  range,
   identity,
   maybeColumn,
   maybeInterval,
@@ -11,7 +10,8 @@ import {
   mid,
   labelof,
   isTemporal,
-  isIterable
+  isIterable,
+  map
 } from "../options.js";
 import {coerceDate, coerceNumber} from "../scales.js";
 import {basic} from "./basic.js";
@@ -147,8 +147,8 @@ function binn(
       const GZ = Z && setGZ([]);
       const GF = F && setGF([]);
       const GS = S && setGS([]);
-      const BX = bx ? bx(data) : [[, , (I) => I]];
-      const BY = by ? by(data) : [[, , (I) => I]];
+      const BX = bx?.(data);
+      const BY = by?.(data);
       const BX1 = bx && setBX1([]);
       const BX2 = bx && setBX2([]);
       const BY1 = by && setBY1([]);
@@ -164,24 +164,34 @@ function binn(
         if (filter) filter.scope("facet", facet);
         for (const [f, I] of maybeGroup(facet, G)) {
           for (const [k, g] of maybeGroup(I, K)) {
-            for (const [x1, x2, fx] of BX) {
-              const bb = fx(g);
-              for (const [y1, y2, fy] of BY) {
-                const extent = {x1, x2, y1, y2};
-                const b = fy(bb);
-                if (filter && !filter.reduce(b, extent)) continue;
-                groupFacet.push(i++);
-                groupData.push(reduceData.reduce(b, data, extent));
-                if (K) GK.push(k);
-                if (Z) GZ.push(G === Z ? f : Z[b[0]]);
-                if (F) GF.push(G === F ? f : F[b[0]]);
-                if (S) GS.push(G === S ? f : S[b[0]]);
-                if (BX1) BX1.push(x1), BX2.push(x2);
-                if (BY1) BY1.push(y1), BY2.push(y2);
-                for (const o of outputs) o.reduce(b, extent);
-                if (sort) sort.reduce(b);
-              }
+            const B = new Array(BX.length);
+            for (const i of g) {
+              const xi = BX.bin(i);
+              if (B[xi]) B[xi].push(i);
+              else B[xi] = [i];
             }
+            for (const [xi, [x1, x2]] of BX.entries()) {
+              const extent = {x1, x2, y1, y2};
+              const b = B[xi]; //fy(bb);
+              if (!b) continue;
+              // if (filter && !filter.reduce(b, extent)) continue;
+              groupFacet.push(i++);
+              // groupData.push(reduceData.reduce(b, data, extent));
+              groupData.push(undefined);
+              if (K) GK.push(k);
+              if (Z) GZ.push(G === Z ? f : Z[b[0]]);
+              if (F) GF.push(G === F ? f : F[b[0]]);
+              if (S) GS.push(G === S ? f : S[b[0]]);
+              if (BX1) BX1.push(x1), BX2.push(x2);
+              if (BY1) BY1.push(y1), BY2.push(y2);
+              for (const o of outputs) o.reduce(b, extent);
+              if (sort) sort.reduce(b);
+            }
+            // for (const [x1, x2, fx] of BX) {
+            //   const bb = fx(g);
+            //   for (const [y1, y2, fy] of BY) {
+            //   }
+            // }
           }
         }
         groupFacets.push(groupFacet);
@@ -224,10 +234,12 @@ function maybeBin(options) {
   if (options == null) return;
   const {value, cumulative, domain = extent, thresholds} = options;
   const bin = (data) => {
-    let V = valueof(data, value, Array); // d3.bin prefers Array input
-    const bin = binner().value((i) => V[i]);
+    let V = valueof(data, value);
+    let T;
+    // const bin = binner().value((i) => V[i]);
     if (isTemporal(V) || isTimeThresholds(thresholds)) {
-      V = V.map(coerceDate);
+      // V = V.map(coerceDate);
+      V = map(V, coerceDate, Float64Array);
       let [min, max] = typeof domain === "function" ? domain(V) : domain;
       let t = typeof thresholds === "function" && !isInterval(thresholds) ? thresholds(V, min, max) : thresholds;
       if (typeof t === "number") t = utcTickInterval(min, max, t);
@@ -238,25 +250,39 @@ function maybeBin(options) {
         }
         t = t.range(min, max);
       }
-      bin.thresholds(t).domain([min, max]);
+      T = t;
     } else {
-      V = V.map(coerceNumber);
-      let d = domain;
-      let t = thresholds;
-      if (isInterval(t)) {
-        let [min, max] = typeof d === "function" ? d(V) : d;
-        if (d === extent) {
+      // V = V.map(coerceNumber);
+      V = map(V, coerceNumber, Float64Array);
+      let [min, max] = typeof domain === "function" ? domain(V) : domain;
+      let t = typeof thresholds === "function" && !isInterval(thresholds) ? thresholds(V, min, max) : thresholds;
+      if (typeof t === "number") t = ticks(min, max, t);
+      else if (isInterval(t)) {
+        if (domain === extent) {
           min = t.floor(min);
           max = t.offset(t.floor(max));
-          d = [min, max];
         }
         t = t.range(min, max);
       }
-      bin.thresholds(t).domain(d);
+      T = t;
+      // bin.thresholds(t).domain(d);
+    }
+    // let bins = bin(range(data)).map(binset);
+    // if (cumulative) bins = (cumulative < 0 ? bins.reverse() : bins).map(bincumset);
+    // return bins.map(binfilter);
+    const bins = [];
+    for (let i = 0; i <= T.length; ++i) {
+      bins.push([T[i - 1], T[i]]);
     }
-    let bins = bin(range(data)).map(binset);
-    if (cumulative) bins = (cumulative < 0 ? bins.reverse() : bins).map(bincumset);
-    return bins.map(binfilter);
+    // bin.thresholds(t).domain([min, max]);
+    T = T.map(coerceNumber);
+    // V = V.map(coerceNumber);
+    bins.bin = (i) => {
+      let x = V[i];
+      if (x == null) return -1; // TODO non-comparable?
+      return bisect(T, x, 0, T.length);
+    };
+    return bins;
   };
   bin.label = labelof(value);
   return bin;