Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Initial commit.

  • Loading branch information...
commit 39b63536bf559f8a0e88adcbc57b1c0c97b98441 0 parents
@mbostock mbostock authored
2  .gitignore
@@ -0,0 +1,2 @@
+.DS_Store
+node_modules
48 Makefile
@@ -0,0 +1,48 @@
+JS_TESTER = ./node_modules/vows/bin/vows
+JS_COMPILER = ./node_modules/uglify-js/bin/uglifyjs
+
+.PHONY: test benchmark
+
+all: tesseract.min.js package.json
+
+tesseract.js: \
+ src/version.js \
+ src/identity.js \
+ src/permute.js \
+ src/bisect.js \
+ src/heap.js \
+ src/heapselect.js \
+ src/insertionsort.js \
+ src/quicksort.js \
+ src/array.js \
+ src/filter.js \
+ src/null.js \
+ src/zero.js \
+ src/reduce.js \
+ src/tesseract.js \
+ Makefile
+
+%.min.js: %.js Makefile
+ @rm -f $@
+ $(JS_COMPILER) < $< > $@
+
+%.js:
+ @rm -f $@
+ @echo '(function(exports){' > $@
+ cat $(filter %.js,$^) >> $@
+ @echo '})(this);' >> $@
+ @chmod a-w $@
+
+package.json: tesseract.js src/package.js
+ @rm -f $@
+ node src/package.js > $@
+ @chmod a-w $@
+
+clean:
+ rm -f tesseract.js tesseract.min.js package.json
+
+test: all
+ @$(JS_TESTER)
+
+benchmark: all
+ @node test/benchmark.js
5 README.md
@@ -0,0 +1,5 @@
+# Tesseract
+
+Fast *n*-dimensional filtering and grouping of records in JavaScript, both on the server and the client.
+
+See <https://github.com/square/tesseract/wiki/API-Reference> for more details.
1  index.js
@@ -0,0 +1 @@
+module.exports = require("./tesseract").tesseract;
25 lib/dart/LICENSE
@@ -0,0 +1,25 @@
+Copyright 2012, the Dart project authors. All rights reserved. Redistribution
+and use in source and binary forms, with or without modification, are permitted
+provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ * Neither the name of Google Inc. nor the names of its contributors may be
+ used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
342 lib/dart/dual_pivot_quicksort.dart
@@ -0,0 +1,342 @@
+// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/**
+ * Dual-Pivot Quicksort algorithm.
+ *
+ * This class implements the dual-pivot quicksort algorithm as presented in
+ * Vladimir Yaroslavskiy's paper.
+ *
+ * Some improvements have been copied from Android's implementation.
+ */
+class DualPivotQuicksort {
+ // When a list has less then [:_INSERTION_SORT_THRESHOLD:] elements it will
+ // be sorted by an insertion sort.
+ static final int _INSERTION_SORT_THRESHOLD = 32;
+
+ /**
+ * Sorts all elements of the given list [:a:] according to the given
+ * [:compare:] function.
+ *
+ * The [:compare:] function takes two arguments [:x:] and [:y:] and returns
+ * -1 if [:x < y:],
+ * 0 if [:x == y:], and
+ * 1 if [:x > y:].
+ *
+ * The function's behavior must be consistent. It must not return different
+ * results for the same values.
+ */
+ static void sort(List a, int compare(a, b)) {
+ _doSort(a, 0, a.length - 1, compare);
+ }
+
+ /**
+ * Sorts all elements in the range [:from:] (inclusive) to [:to:] (exclusive)
+ * of the given list [:a:].
+ *
+ * If the given range is invalid an "OutOfRange" error is raised.
+ * TODO(floitsch): do we want an error?
+ *
+ * See [:sort:] for requirements of the [:compare:] function.
+ */
+ static void sortRange(List a, int from, int to, int compare(a, b)) {
+ if ((from < 0) || (to > a.length) || (to < from)) {
+ throw "OutOfRange";
+ }
+ _doSort(a, from, to - 1, compare);
+ }
+
+ /**
+ * Sorts the list in the interval [:left:] to [:right:] (both inclusive).
+ */
+ static void _doSort(List a, int left, int right, int compare(a, b)) {
+ if ((right - left) <= _INSERTION_SORT_THRESHOLD) {
+ insertionSort_(a, left, right, compare);
+ } else {
+ _dualPivotQuicksort(a, left, right, compare);
+ }
+ }
+
+ static void insertionSort_(List a, int left, int right, int compare(a, b)) {
+ for (int i = left + 1; i <= right; i++) {
+ var el = a[i];
+ int j = i;
+ while ((j > left) && (compare(a[j - 1], el) > 0)) {
+ a[j] = a[j - 1];
+ j--;
+ }
+ a[j] = el;
+ }
+ }
+
+ static void _dualPivotQuicksort(List a,
+ int left, int right,
+ int compare(a, b)) {
+ assert(right - left > _INSERTION_SORT_THRESHOLD);
+
+ // Compute the two pivots by looking at 5 elements.
+ int sixth = (right - left + 1) ~/ 6;
+ int index1 = left + sixth;
+ int index5 = right - sixth;
+ int index3 = (left + right) ~/ 2; // The midpoint.
+ int index2 = index3 - sixth;
+ int index4 = index3 + sixth;
+
+ var el1 = a[index1];
+ var el2 = a[index2];
+ var el3 = a[index3];
+ var el4 = a[index4];
+ var el5 = a[index5];
+
+ // Sort the selected 5 elements using a sorting network.
+ if (compare(el1, el2) > 0) { var t = el1; el1 = el2; el2 = t; }
+ if (compare(el4, el5) > 0) { var t = el4; el4 = el5; el5 = t; }
+ if (compare(el1, el3) > 0) { var t = el1; el1 = el3; el3 = t; }
+ if (compare(el2, el3) > 0) { var t = el2; el2 = el3; el3 = t; }
+ if (compare(el1, el4) > 0) { var t = el1; el1 = el4; el4 = t; }
+ if (compare(el3, el4) > 0) { var t = el3; el3 = el4; el4 = t; }
+ if (compare(el2, el5) > 0) { var t = el2; el2 = el5; el5 = t; }
+ if (compare(el2, el3) > 0) { var t = el2; el2 = el3; el3 = t; }
+ if (compare(el4, el5) > 0) { var t = el4; el4 = el5; el5 = t; }
+
+ var pivot1 = el2;
+ var pivot2 = el4;
+
+ // el2 and el4 have been saved in the pivot variables. They will be written
+ // back, once the partioning is finished.
+ a[index1] = el1;
+ a[index3] = el3;
+ a[index5] = el5;
+
+ a[index2] = a[left];
+ a[index4] = a[right];
+
+ int less = left + 1; // First element in the middle partition.
+ int great = right - 1; // Last element in the middle partition.
+
+ bool pivots_are_equal = (compare(pivot1, pivot2) == 0);
+ if (pivots_are_equal) {
+ var pivot = pivot1;
+ // Degenerated case where the partioning becomes a dutch national flag
+ // problem.
+ //
+ // [ | < pivot | == pivot | unpartitioned | > pivot | ]
+ // ^ ^ ^ ^ ^
+ // left less k great right
+ //
+ // a[left] and a[right] are undefined and are filled after the
+ // partitioning.
+ //
+ // Invariants:
+ // 1) for x in ]left, less[ : x < pivot.
+ // 2) for x in [less, k[ : x == pivot.
+ // 3) for x in ]great, right[ : x > pivot.
+ for (int k = less; k <= great; k++) {
+ var ak = a[k];
+ int comp = compare(ak, pivot);
+ if (comp == 0) continue;
+ if (comp < 0) {
+ if (k != less) {
+ a[k] = a[less];
+ a[less] = ak;
+ }
+ less++;
+ } else {
+ // comp > 0.
+ //
+ // Find the first element <= pivot in the range [k - 1, great] and
+ // put [:ak:] there. We know that such an element must exist:
+ // When k == less, then el3 (which is equal to pivot) lies in the
+ // interval. Otherwise a[k - 1] == pivot and the search stops at k-1.
+ // Note that in the latter case invariant 2 will be violated for a
+ // short amount of time. The invariant will be restored when the
+ // pivots are put into their final positions.
+ while (true) {
+ comp = compare(a[great], pivot);
+ if (comp > 0) {
+ great--;
+ // This is the only location in the while-loop where a new
+ // iteration is started.
+ continue;
+ } else if (comp < 0) {
+ // Triple exchange.
+ a[k] = a[less];
+ a[less++] = a[great];
+ a[great--] = ak;
+ break;
+ } else {
+ // comp == 0;
+ a[k] = a[great];
+ a[great--] = ak;
+ // Note: if great < k then we will exit the outer loop and fix
+ // invariant 2 (which we just violated).
+ break;
+ }
+ }
+ }
+ }
+ } else {
+ // We partition the list into three parts:
+ // 1. < pivot1
+ // 2. >= pivot1 && <= pivot2
+ // 3. > pivot2
+ //
+ // During the loop we have:
+ // [ | < pivot1 | >= pivot1 && <= pivot2 | unpartitioned | > pivot2 | ]
+ // ^ ^ ^ ^ ^
+ // left less k great right
+ //
+ // a[left] and a[right] are undefined and are filled after the
+ // partitioning.
+ //
+ // Invariants:
+ // 1. for x in ]left, less[ : x < pivot1
+ // 2. for x in [less, k[ : pivot1 <= x && x <= pivot2
+ // 3. for x in ]great, right[ : x > pivot2
+ for (int k = less; k <= great; k++) {
+ var ak = a[k];
+ int comp_pivot1 = compare(ak, pivot1);
+ if (comp_pivot1 < 0) {
+ if (k != less) {
+ a[k] = a[less];
+ a[less] = ak;
+ }
+ less++;
+ } else {
+ int comp_pivot2 = compare(ak, pivot2);
+ if (comp_pivot2 > 0) {
+ while (true) {
+ int comp = compare(a[great], pivot2);
+ if (comp > 0) {
+ great--;
+ if (great < k) break;
+ // This is the only location inside the loop where a new
+ // iteration is started.
+ continue;
+ } else {
+ // a[great] <= pivot2.
+ comp = compare(a[great], pivot1);
+ if (comp < 0) {
+ // Triple exchange.
+ a[k] = a[less];
+ a[less++] = a[great];
+ a[great--] = ak;
+ } else {
+ // a[great] >= pivot1.
+ a[k] = a[great];
+ a[great--] = ak;
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Move pivots into their final positions.
+ // We shrunk the list from both sides (a[left] and a[right] have
+ // meaningless values in them) and now we move elements from the first
+ // and third partition into these locations so that we can store the
+ // pivots.
+ a[left] = a[less - 1];
+ a[less - 1] = pivot1;
+ a[right] = a[great + 1];
+ a[great + 1] = pivot2;
+
+ // The list is now partitioned into three partitions:
+ // [ < pivot1 | >= pivot1 && <= pivot2 | > pivot2 ]
+ // ^ ^ ^ ^
+ // left less great right
+
+ // Recursive descent. (Don't include the pivot values.)
+ _doSort(a, left, less - 2, compare);
+ _doSort(a, great + 2, right, compare);
+
+ if (pivots_are_equal) {
+ // All elements in the second partition are equal to the pivot. No
+ // need to sort them.
+ return;
+ }
+
+ // In theory it should be enough to call _doSort recursively on the second
+ // partition.
+ // The Android source however removes the pivot elements from the recursive
+ // call if the second partition is too large (more than 2/3 of the list).
+ if (less < index1 && great > index5) {
+ while (compare(a[less], pivot1) == 0) { less++; }
+ while (compare(a[great], pivot2) == 0) { great--; }
+
+ // Copy paste of the previous 3-way partitioning with adaptions.
+ //
+ // We partition the list into three parts:
+ // 1. == pivot1
+ // 2. > pivot1 && < pivot2
+ // 3. == pivot2
+ //
+ // During the loop we have:
+ // [ == pivot1 | > pivot1 && < pivot2 | unpartitioned | == pivot2 ]
+ // ^ ^ ^
+ // less k great
+ //
+ // Invariants:
+ // 1. for x in [ *, less[ : x == pivot1
+ // 2. for x in [less, k[ : pivot1 < x && x < pivot2
+ // 3. for x in ]great, * ] : x == pivot2
+ for (int k = less; k <= great; k++) {
+ var ak = a[k];
+ int comp_pivot1 = compare(ak, pivot1);
+ if (comp_pivot1 == 0) {
+ if (k != less) {
+ a[k] = a[less];
+ a[less] = ak;
+ }
+ less++;
+ } else {
+ int comp_pivot2 = compare(ak, pivot2);
+ if (comp_pivot2 == 0) {
+ while (true) {
+ int comp = compare(a[great], pivot2);
+ if (comp == 0) {
+ great--;
+ if (great < k) break;
+ // This is the only location inside the loop where a new
+ // iteration is started.
+ continue;
+ } else {
+ // a[great] < pivot2.
+ comp = compare(a[great], pivot1);
+ if (comp < 0) {
+ // Triple exchange.
+ a[k] = a[less];
+ a[less++] = a[great];
+ a[great--] = ak;
+ } else {
+ // a[great] == pivot1.
+ a[k] = a[great];
+ a[great--] = ak;
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ // The second partition has now been cleared of pivot elements and looks
+ // as follows:
+ // [ * | > pivot1 && < pivot2 | * ]
+ // ^ ^
+ // less great
+ // Sort the second partition using recursive descent.
+ _doSort(a, less, great, compare);
+ } else {
+ // The second partition looks as follows:
+ // [ * | >= pivot1 && <= pivot2 | * ]
+ // ^ ^
+ // less great
+ // Simply sort it by recursive descent.
+ _doSort(a, less, great, compare);
+ }
+ }
+}
11 package.json
@@ -0,0 +1,11 @@
+{
+ "name": "tesseract",
+ "version": "0.0.2",
+ "private": true,
+ "main": "./index.js",
+ "devDependencies": {
+ "d3": "2.8.0",
+ "vows": "0.6.1",
+ "uglify-js": "1.2.5"
+ }
+}
32 src/array.js
@@ -0,0 +1,32 @@
+var tesseract_array8 = tesseract_arrayUntyped,
+ tesseract_array16 = tesseract_arrayUntyped,
+ tesseract_array32 = tesseract_arrayUntyped,
+ tesseract_arrayLengthen = tesseract_identity,
+ tesseract_arrayWiden = tesseract_identity;
+
+if (typeof "Uint8Array" !== "undefined") {
+ tesseract_array8 = function(n) { return new Uint8Array(n); };
+ tesseract_array16 = function(n) { return new Uint16Array(n); };
+ tesseract_array32 = function(n) { return new Uint32Array(n); };
+
+ tesseract_arrayLengthen = function(array, length) {
+ var copy = new array.constructor(length);
+ copy.set(array);
+ return copy;
+ };
+
+ tesseract_arrayWiden = function(array, width) {
+ var copy;
+ switch (width) {
+ case 16: copy = tesseract_array16(array.length); break;
+ case 32: copy = tesseract_array32(array.length); break;
+ default: throw new Error("invalid array width!");
+ }
+ copy.set(array);
+ return copy;
+ };
+}
+
+function tesseract_arrayUntyped(n) {
+ return new Array(n);
+}
44 src/bisect.js
@@ -0,0 +1,44 @@
+var bisect = tesseract.bisect = bisect_by(tesseract_identity);
+
+bisect.by = bisect_by;
+
+function bisect_by(f) {
+
+ // Locate the insertion point for x in a to maintain sorted order. The
+ // arguments lo and hi may be used to specify a subset of the array which
+ // should be considered; by default the entire array is used. If x is already
+ // present in a, the insertion point will be before (to the left of) any
+ // existing entries. The return value is suitable for use as the first
+ // argument to `array.splice` assuming that a is already sorted.
+ //
+ // The returned insertion point i partitions the array a into two halves so
+ // that all v < x for v in a[lo:i] for the left side and all v >= x for v in
+ // a[i:hi] for the right side.
+ function bisectLeft(a, x, lo, hi) {
+ while (lo < hi) {
+ var mid = lo + hi >> 1;
+ if (f(a[mid]) < x) lo = mid + 1;
+ else hi = mid;
+ }
+ return lo;
+ }
+
+ // Similar to bisectLeft, but returns an insertion point which comes after (to
+ // the right of) any existing entries of x in a.
+ //
+ // The returned insertion point i partitions the array into two halves so that
+ // all v <= x for v in a[lo:i] for the left side and all v > x for v in
+ // a[i:hi] for the right side.
+ function bisectRight(a, x, lo, hi) {
+ while (lo < hi) {
+ var mid = lo + hi >> 1;
+ if (x < f(a[mid])) hi = mid;
+ else lo = mid + 1;
+ }
+ return lo;
+ }
+
+ bisectRight.right = bisectRight;
+ bisectRight.left = bisectLeft;
+ return bisectRight;
+}
19 src/filter.js
@@ -0,0 +1,19 @@
+function tesseract_filterExact(bisect, value) {
+ return function(values) {
+ var n = values.length;
+ return [bisect.left(values, value, 0, n), bisect.right(values, value, 0, n)];
+ };
+}
+
+function tesseract_filterRange(bisect, range) {
+ var min = range[0],
+ max = range[1];
+ return function(values) {
+ var n = values.length;
+ return [bisect.left(values, min, 0, n), bisect.left(values, max, 0, n)];
+ };
+}
+
+function tesseract_filterAll(values) {
+ return [0, values.length];
+}
44 src/heap.js
@@ -0,0 +1,44 @@
+var heap = tesseract.heap = heap_by(tesseract_identity);
+
+heap.by = heap_by;
+
+function heap_by(f) {
+
+ // Builds a binary heap within the specified array a[lo:hi]. The heap has the
+ // property such that the parent a[lo+i] is always less than or equal to its
+ // two children: a[lo+2*i+1] and a[lo+2*i+2].
+ function heap(a, lo, hi) {
+ var n = hi - lo,
+ i = (n >>> 1) + 1;
+ while (--i > 0) sift(a, i, n, lo);
+ return a;
+ }
+
+ // Sorts the specified array a[lo:hi] in descending order, assuming it is
+ // already a heap.
+ function sort(a, lo, hi) {
+ var n = hi - lo,
+ t;
+ while (--n > 0) t = a[lo], a[lo] = a[lo + n], a[lo + n] = t, sift(a, 1, n, lo);
+ return a;
+ }
+
+ // Sifts the element a[lo+i-1] down the heap, where the heap is the contiguous
+ // slice of array a[lo:lo+n]. This method can also be used to update the heap
+ // incrementally, without incurring the full cost of reconstructing the heap.
+ function sift(a, i, n, lo) {
+ var d = a[--lo + i],
+ x = f(d),
+ child;
+ while ((child = i << 1) <= n) {
+ if (child < n && f(a[lo + child]) > f(a[lo + child + 1])) child++;
+ if (x <= f(a[lo + child])) break;
+ a[lo + i] = a[lo + child];
+ i = child;
+ }
+ a[lo + i] = d;
+ }
+
+ heap.sort = sort;
+ return heap;
+}
36 src/heapselect.js
@@ -0,0 +1,36 @@
+var heapselect = tesseract.heapselect = heapselect_by(tesseract_identity);
+
+heapselect.by = heapselect_by;
+
+function heapselect_by(f) {
+ var heap = heap_by(f);
+
+ // Returns a new array containing the top k elements in the array a[lo:hi].
+ // The returned array is not sorted, but maintains the heap property. If k is
+ // greater than hi - lo, then fewer than k elements will be returned. The
+ // order of elements in a is unchanged by this operation.
+ function heapselect(a, lo, hi, k) {
+ var queue = new Array(k = Math.min(hi - lo, k)),
+ min,
+ i,
+ x,
+ d;
+
+ for (i = 0; i < k; ++i) queue[i] = a[lo++];
+ heap(queue, 0, k);
+
+ if (lo < hi) {
+ min = f(queue[0]);
+ do {
+ if (x = f(d = a[lo]) > min) {
+ queue[0] = d;
+ min = f(heap(queue, 0, k)[0]);
+ }
+ } while (++lo < hi);
+ }
+
+ return queue;
+ }
+
+ return heapselect;
+}
3  src/identity.js
@@ -0,0 +1,3 @@
+function tesseract_identity(d) {
+ return d;
+}
18 src/insertionsort.js
@@ -0,0 +1,18 @@
+var insertionsort = tesseract.insertionsort = insertionsort_by(tesseract_identity);
+
+insertionsort.by = insertionsort_by;
+
+function insertionsort_by(f) {
+
+ function insertionsort(a, lo, hi) {
+ for (var i = lo + 1; i < hi; ++i) {
+ for (var j = i, t = a[i], x = f(t); j > lo && f(a[j - 1]) > x; --j) {
+ a[j] = a[j - 1];
+ }
+ a[j] = t;
+ }
+ return a;
+ }
+
+ return insertionsort;
+}
3  src/null.js
@@ -0,0 +1,3 @@
+function tesseract_null() {
+ return null;
+}
14 src/package.js
@@ -0,0 +1,14 @@
+var util = require("util"),
+ tesseract = require("../tesseract").tesseract;
+
+util.puts(JSON.stringify({
+ "name": "tesseract",
+ "version": tesseract.version,
+ "private": true,
+ "main": "./index.js",
+ "devDependencies": {
+ "d3": "2.8.0",
+ "vows": "0.6.1",
+ "uglify-js": "1.2.5"
+ }
+}, null, 2));
8 src/permute.js
@@ -0,0 +1,8 @@
+tesseract.permute = permute;
+
+function permute(array, index) {
+ for (var i = 0, n = index.length, copy = new Array(n); i < n; ++i) {
+ copy[i] = array[index[i]];
+ }
+ return copy;
+}
282 src/quicksort.js
@@ -0,0 +1,282 @@
+// Algorithm designed by Vladimir Yaroslavskiy.
+// Implementation based on the Dart project; see lib/dart/LICENSE for details.
+
+var quicksort = tesseract.quicksort = quicksort_by(tesseract_identity);
+
+quicksort.by = quicksort_by;
+
+function quicksort_by(f) {
+ var insertionsort = insertionsort_by(f);
+
+ function sort(a, lo, hi) {
+ return (hi - lo < quicksort_sizeThreshold
+ ? insertionsort
+ : quicksort)(a, lo, hi);
+ }
+
+ function quicksort(a, lo, hi) {
+
+ // Compute the two pivots by looking at 5 elements.
+ var sixth = (hi - lo) / 6 | 0,
+ i1 = lo + sixth,
+ i5 = hi - 1 - sixth,
+ i3 = lo + hi - 1 >> 1, // The midpoint.
+ i2 = i3 - sixth,
+ i4 = i3 + sixth;
+
+ var e1 = a[i1], x1 = f(e1),
+ e2 = a[i2], x2 = f(e2),
+ e3 = a[i3], x3 = f(e3),
+ e4 = a[i4], x4 = f(e4),
+ e5 = a[i5], x5 = f(e5);
+
+ // Sort the selected 5 elements using a sorting network.
+ if (x1 > x2) t = e1, e1 = e2, e2 = t, t = x1, x1 = x2, x2 = t;
+ if (x4 > x5) t = e4, e4 = e5, e5 = t, t = x4, x4 = x5, x5 = t;
+ if (x1 > x3) t = e1, e1 = e3, e3 = t, t = x1, x1 = x3, x3 = t;
+ if (x2 > x3) t = e2, e2 = e3, e3 = t, t = x2, x2 = x3, x3 = t;
+ if (x1 > x4) t = e1, e1 = e4, e4 = t, t = x1, x1 = x4, x4 = t;
+ if (x3 > x4) t = e3, e3 = e4, e4 = t, t = x3, x3 = x4, x4 = t;
+ if (x2 > x5) t = e2, e2 = e5, e5 = t, t = x2, x2 = x5, x5 = t;
+ if (x2 > x3) t = e2, e2 = e3, e3 = t, t = x2, x2 = x3, x3 = t;
+ if (x4 > x5) t = e4, e4 = e5, e5 = t, t = x4, x4 = x5, x5 = t;
+
+ var pivot1 = e2, pivotValue1 = x2,
+ pivot2 = e4, pivotValue2 = x4;
+
+ // e2 and e4 have been saved in the pivot variables. They will be written
+ // back, once the partioning is finished.
+ a[i1] = e1;
+ a[i2] = a[lo];
+ a[i3] = e3;
+ a[i4] = a[hi - 1];
+ a[i5] = e5;
+
+ var less = lo + 1, // First element in the middle partition.
+ great = hi - 2; // Last element in the middle partition.
+
+ // Note that for value comparison, <, <=, >= and > coerce to a primitive via
+ // Object.prototype.valueOf; == and === do not, so in order to be consistent
+ // with natural order (such as for Date objects), we must do two compares.
+ var pivotsEqual = pivotValue1 <= pivotValue2 && pivotValue1 >= pivotValue2;
+ if (pivotsEqual) {
+
+ // Degenerated case where the partioning becomes a dutch national flag
+ // problem.
+ //
+ // [ | < pivot | == pivot | unpartitioned | > pivot | ]
+ // ^ ^ ^ ^ ^
+ // left less k great right
+ //
+ // a[left] and a[right] are undefined and are filled after the
+ // partitioning.
+ //
+ // Invariants:
+ // 1) for x in ]left, less[ : x < pivot.
+ // 2) for x in [less, k[ : x == pivot.
+ // 3) for x in ]great, right[ : x > pivot.
+ for (var k = less; k <= great; ++k) {
+ var ek = a[k], xk = f(ek);
+ if (xk < pivotValue1) {
+ if (k !== less) {
+ a[k] = a[less];
+ a[less] = ek;
+ }
+ ++less;
+ } else if (xk > pivotValue1) {
+
+ // Find the first element <= pivot in the range [k - 1, great] and
+ // put [:ek:] there. We know that such an element must exist:
+ // When k == less, then el3 (which is equal to pivot) lies in the
+ // interval. Otherwise a[k - 1] == pivot and the search stops at k-1.
+ // Note that in the latter case invariant 2 will be violated for a
+ // short amount of time. The invariant will be restored when the
+ // pivots are put into their final positions.
+ while (true) {
+ var greatValue = f(a[great]);
+ if (greatValue > pivotValue1) {
+ great--;
+ // This is the only location in the while-loop where a new
+ // iteration is started.
+ continue;
+ } else if (greatValue < pivotValue1) {
+ // Triple exchange.
+ a[k] = a[less];
+ a[less++] = a[great];
+ a[great--] = ek;
+ break;
+ } else {
+ a[k] = a[great];
+ a[great--] = ek;
+ // Note: if great < k then we will exit the outer loop and fix
+ // invariant 2 (which we just violated).
+ break;
+ }
+ }
+ }
+ }
+ } else {
+
+ // We partition the list into three parts:
+ // 1. < pivot1
+ // 2. >= pivot1 && <= pivot2
+ // 3. > pivot2
+ //
+ // During the loop we have:
+ // [ | < pivot1 | >= pivot1 && <= pivot2 | unpartitioned | > pivot2 | ]
+ // ^ ^ ^ ^ ^
+ // left less k great right
+ //
+ // a[left] and a[right] are undefined and are filled after the
+ // partitioning.
+ //
+ // Invariants:
+ // 1. for x in ]left, less[ : x < pivot1
+ // 2. for x in [less, k[ : pivot1 <= x && x <= pivot2
+ // 3. for x in ]great, right[ : x > pivot2
+ for (var k = less; k <= great; k++) {
+ var ek = a[k], xk = f(ek);
+ if (xk < pivotValue1) {
+ if (k !== less) {
+ a[k] = a[less];
+ a[less] = ek;
+ }
+ ++less;
+ } else {
+ if (xk > pivotValue2) {
+ while (true) {
+ var greatValue = f(a[great]);
+ if (greatValue > pivotValue2) {
+ great--;
+ if (great < k) break;
+ // This is the only location inside the loop where a new
+ // iteration is started.
+ continue;
+ } else {
+ // a[great] <= pivot2.
+ if (greatValue < pivotValue1) {
+ // Triple exchange.
+ a[k] = a[less];
+ a[less++] = a[great];
+ a[great--] = ek;
+ } else {
+ // a[great] >= pivot1.
+ a[k] = a[great];
+ a[great--] = ek;
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Move pivots into their final positions.
+ // We shrunk the list from both sides (a[left] and a[right] have
+ // meaningless values in them) and now we move elements from the first
+ // and third partition into these locations so that we can store the
+ // pivots.
+ a[lo] = a[less - 1];
+ a[less - 1] = pivot1;
+ a[hi - 1] = a[great + 1];
+ a[great + 1] = pivot2;
+
+ // The list is now partitioned into three partitions:
+ // [ < pivot1 | >= pivot1 && <= pivot2 | > pivot2 ]
+ // ^ ^ ^ ^
+ // left less great right
+
+ // Recursive descent. (Don't include the pivot values.)
+ sort(a, lo, less - 1);
+ sort(a, great + 2, hi);
+
+ if (pivotsEqual) {
+ // All elements in the second partition are equal to the pivot. No
+ // need to sort them.
+ return a;
+ }
+
+ // In theory it should be enough to call _doSort recursively on the second
+ // partition.
+ // The Android source however removes the pivot elements from the recursive
+ // call if the second partition is too large (more than 2/3 of the list).
+ if (less < i1 && great > i5) {
+ var lessValue, greatValue;
+ while ((lessValue = f(a[less])) <= pivotValue1 && lessValue >= pivotValue1) ++less;
+ while ((greatValue = f(a[great])) <= pivotValue2 && greatValue >= pivotValue2) --great;
+
+ // Copy paste of the previous 3-way partitioning with adaptions.
+ //
+ // We partition the list into three parts:
+ // 1. == pivot1
+ // 2. > pivot1 && < pivot2
+ // 3. == pivot2
+ //
+ // During the loop we have:
+ // [ == pivot1 | > pivot1 && < pivot2 | unpartitioned | == pivot2 ]
+ // ^ ^ ^
+ // less k great
+ //
+ // Invariants:
+ // 1. for x in [ *, less[ : x == pivot1
+ // 2. for x in [less, k[ : pivot1 < x && x < pivot2
+ // 3. for x in ]great, * ] : x == pivot2
+ for (var k = less; k <= great; k++) {
+ var ek = a[k], xk = f(ek);
+ if (xk <= pivotValue1 && xk >= pivotValue1) {
+ if (k !== less) {
+ a[k] = a[less];
+ a[less] = ek;
+ }
+ less++;
+ } else {
+ if (xk <= pivotValue2 && xk >= pivotValue2) {
+ while (true) {
+ var greatValue = f(a[great]);
+ if (greatValue <= pivotValue2 && greatValue >= pivotValue2) {
+ great--;
+ if (great < k) break;
+ // This is the only location inside the loop where a new
+ // iteration is started.
+ continue;
+ } else {
+ // a[great] < pivot2.
+ if (greatValue < pivotValue1) {
+ // Triple exchange.
+ a[k] = a[less];
+ a[less++] = a[great];
+ a[great--] = ek;
+ } else {
+ // a[great] == pivot1.
+ a[k] = a[great];
+ a[great--] = ek;
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // The second partition has now been cleared of pivot elements and looks
+ // as follows:
+ // [ * | > pivot1 && < pivot2 | * ]
+ // ^ ^
+ // less great
+ // Sort the second partition using recursive descent.
+
+ // The second partition looks as follows:
+ // [ * | >= pivot1 && <= pivot2 | * ]
+ // ^ ^
+ // less great
+ // Simply sort it by recursive descent.
+
+ return sort(a, less, great + 1);
+ }
+
+ return sort;
+}
+
+var quicksort_sizeThreshold = 32;
19 src/reduce.js
@@ -0,0 +1,19 @@
+function tesseract_reduceIncrement(p) {
+ return p + 1;
+}
+
+function tesseract_reduceDecrement(p) {
+ return p - 1;
+}
+
+function tesseract_reduceAdd(f) {
+ return function(p, v) {
+ return p + +f(v);
+ };
+}
+
+function tesseract_reduceSubtract(f) {
+ return function(p, v) {
+ return p - f(v);
+ };
+}
663 src/tesseract.js
@@ -0,0 +1,663 @@
+exports.tesseract = tesseract;
+
+function tesseract() {
+ var tesseract = {
+ add: add,
+ dimension: dimension,
+ groupAll: groupAll,
+ size: size
+ };
+
+ var data = [], // the records
+ n = 0, // the number of records; data.length
+ m = 0, // number of dimensions in use
+ M = 8, // number of dimensions that can fit in `filters`
+ filters = tesseract_array8(0), // M bits per record; 1 is filtered out
+ filterListeners = [], // when the filters change
+ dataListeners = []; // when data is added
+
+ // Adds the specified new records to this tesseract.
+ function add(newData) {
+ var n0 = n,
+ n1 = newData.length;
+
+ // If there's actually new data to add…
+ // Merge the new data into the existing data.
+ // Lengthen the filter bitset to handle the new records.
+ // Notify listeners (dimensions and groups) that new data is available.
+ if (n1) {
+ data = data.concat(newData);
+ filters = tesseract_arrayLengthen(filters, n += n1);
+ dataListeners.forEach(function(l) { l(newData, n0, n1); });
+ }
+
+ return tesseract;
+ }
+
+ // Adds a new dimension with the specified value accessor function.
+ function dimension(value) {
+ var dimension = {
+ filter: filter,
+ filterExact: filterExact,
+ filterRange: filterRange,
+ filterAll: filterAll,
+ top: top,
+ group: group,
+ groupAll: groupAll
+ };
+
+ var one = 1 << m++, // bit mask, e.g., 00001000
+ zero = ~one, // inverted one, e.g., 11110111
+ values, // sorted, cached array
+ index, // value rank ↦ object id
+ newValues, // temporary array storing newly-added values
+ newIndex, // temporary array storing newly-added index
+ sort = quicksort_by(function(i) { return newValues[i]; }),
+ refilter = tesseract_filterAll, // for recomputing filter
+ indexListeners = [], // when data is added
+ lo0 = 0,
+ hi0 = 0;
+
+ // Updating a dimension is a two-stage process. First, we must update the
+ // associated filters for the newly-added records. Once all dimensions have
+ // updated their filters, the groups are notified to update.
+ dataListeners.unshift(preAdd);
+ dataListeners.push(postAdd);
+
+ // Incorporate any existing data into this dimension, and make sure that the
+ // filter bitset is wide enough to handle the new dimension.
+ if (m > M) filters = tesseract_arrayWiden(filters, M <<= 1);
+ preAdd(data, 0, n);
+ postAdd(data, 0, n);
+
+ // Incorporates the specified new records into this dimension.
+ // This function is responsible for updating filters, values, and index.
+ function preAdd(newData, n0, n1) {
+
+ // Permute new values into natural order using a sorted index.
+ newValues = newData.map(value);
+ newIndex = sort(tesseract_range(n1), 0, n1);
+ newValues = permute(newValues, newIndex);
+
+ // Bisect newValues to determine which new records are selected.
+ var bounds = refilter(newValues), lo1 = bounds[0], hi1 = bounds[1], i;
+ for (i = 0; i < lo1; ++i) filters[newIndex[i] + n0] |= one;
+ for (i = hi1; i < n1; ++i) filters[newIndex[i] + n0] |= one;
+
+ // If this dimension previously had no data, then we don't need to do the
+ // more expensive merge operation; use the new values and index as-is.
+ if (!n0) {
+ values = newValues;
+ index = newIndex;
+ lo0 = lo1;
+ hi0 = hi1;
+ return;
+ }
+
+ var oldValues = values,
+ oldIndex = index,
+ i0 = 0,
+ i1 = 0;
+
+ // Otherwise, create new arrays into which to merge new and old.
+ values = new Array(n);
+ index = tesseract_index(n, n);
+
+ // Merge the old and new sorted values, and old and new index.
+ for (i = 0; i0 < n0 && i1 < n1; ++i) {
+ if (oldValues[i0] < newValues[i1]) {
+ values[i] = oldValues[i0];
+ index[i] = oldIndex[i0++];
+ } else {
+ values[i] = newValues[i1];
+ index[i] = newIndex[i1++] + n0;
+ }
+ }
+
+ // Add any remaining old values.
+ for (; i0 < n0; ++i0, ++i) {
+ values[i] = oldValues[i0];
+ index[i] = oldIndex[i0];
+ }
+
+ // Add any remaining new values.
+ for (; i1 < n1; ++i1, ++i) {
+ values[i] = newValues[i1];
+ index[i] = newIndex[i1] + n0;
+ }
+
+ // Bisect again to recompute lo0 and hi0.
+ bounds = refilter(values), lo0 = bounds[0], hi0 = bounds[1];
+ }
+
+ // When all filters have updated, notify index listeners of the new values.
+ function postAdd(newData, n0, n1) {
+ indexListeners.forEach(function(l) { l(newValues, newIndex, n0, n1); });
+ newValues = newIndex = null;
+ }
+
+ // Updates the selected values based on the specified bounds [lo, hi].
+ // This implementation is used by all the public filter methods.
+ function filterIndex(bounds) {
+ var i,
+ j,
+ k,
+ lo1 = bounds[0],
+ hi1 = bounds[1],
+ added = [],
+ removed = [];
+
+ // Fast incremental update based on previous lo index.
+ if (lo1 < lo0) {
+ for (i = lo1, j = Math.min(lo0, hi1); i < j; ++i) {
+ filters[k = index[i]] ^= one;
+ added.push(k);
+ }
+ } else if (lo1 > lo0) {
+ for (i = lo0, j = Math.min(lo1, hi0); i < j; ++i) {
+ filters[k = index[i]] ^= one;
+ removed.push(k);
+ }
+ }
+
+ // Fast incremental update based on previous hi index.
+ if (hi1 > hi0) {
+ for (i = Math.max(lo1, hi0), j = hi1; i < j; ++i) {
+ filters[k = index[i]] ^= one;
+ added.push(k);
+ }
+ } else if (hi1 < hi0) {
+ for (i = Math.max(lo0, hi1), j = hi0; i < j; ++i) {
+ filters[k = index[i]] ^= one;
+ removed.push(k);
+ }
+ }
+
+ lo0 = lo1;
+ hi0 = hi1;
+ filterListeners.forEach(function(l) { l(one, added, removed); });
+ return dimension;
+ }
+
+ // Filters this dimension using the specified range, value, or null.
+ // If the range is null, this is equivalent to filterAll.
+ // If the range is an array, this is equivalent to filterRange.
+ // Otherwise, this is equivalent to filterExact.
+ function filter(range) {
+ return range == null
+ ? filterAll() : Array.isArray(range)
+ ? filterRange(range)
+ : filterExact(range);
+ }
+
+ // Filters this dimension to select the exact value.
+ function filterExact(value) {
+ return filterIndex((refilter = tesseract_filterExact(bisect, value))(values));
+ }
+
+ // Filters this dimension to select the specified range [lo, hi].
+ // The lower bound is inclusive, and the upper bound is exclusive.
+ function filterRange(range) {
+ return filterIndex((refilter = tesseract_filterRange(bisect, range))(values));
+ }
+
+ // Clears any filters on this dimension.
+ function filterAll() {
+ return filterIndex((refilter = tesseract_filterAll)(values));
+ }
+
+ // Returns the top K selected records, based on this dimension's order.
+ // Note: observes this dimension's filter, unlike group and groupAll.
+ function top(k) {
+ var array = [],
+ i = hi0,
+ j;
+
+ while (--i >= lo0 && k > 0) {
+ if (!filters[j = index[i]]) {
+ array.push(data[j]);
+ --k;
+ }
+ }
+
+ return array;
+ }
+
+ // Adds a new group to this dimension, using the specified key function.
+ function group(key) {
+ var group = {
+ top: top,
+ all: all,
+ reduce: reduce,
+ reduceCount: reduceCount,
+ reduceSum: reduceSum,
+ order: order,
+ orderNatural: orderNatural,
+ size: size
+ };
+
+ var groups, // array of {key, value}
+ groupIndex, // object id ↦ group id
+ groupWidth = 8,
+ groupCapacity = tesseract_capacity(groupWidth),
+ k = 0, // cardinality
+ select,
+ heap,
+ reduceAdd,
+ reduceRemove,
+ reduceInitial,
+ update = tesseract_null,
+ reset = tesseract_null,
+ resetNeeded = true;
+
+ if (arguments.length < 1) key = tesseract_identity;
+
+ // The group listens to the tesseract for when any dimension changes, so
+ // that it can update the associated reduce values. It must also listen to
+ // the parent dimension for when data is added, and compute new keys.
+ filterListeners.push(update);
+ indexListeners.push(add);
+
+ // Incorporate any existing data into the grouping.
+ add(values, index, 0, n);
+
+ // Incorporates the specified new values into this group.
+ // This function is responsible for updating groups and groupIndex.
+ function add(newValues, newIndex, n0, n1) {
+ var oldGroups = groups,
+ reIndex = tesseract_index(k, groupCapacity),
+ add = reduceAdd,
+ initial = reduceInitial,
+ k0 = k, // old cardinality
+ i0 = 0, // index of old group
+ i1 = 0, // index of new record
+ j, // object id
+ g0, // old group
+ x0, // old key
+ x1, // new key
+ g, // group to add
+ x; // key of group to add
+
+ // If a reset is needed, we don't need to update the reduce values.
+ if (resetNeeded) add = initial = tesseract_null;
+
+ // Reset the new groups (k is a lower bound).
+ // Also, make sure that groupIndex exists and is long enough.
+ groups = new Array(k), k = 0;
+ groupIndex = k0 > 1 ? tesseract_arrayLengthen(groupIndex, n) : tesseract_index(n, groupCapacity);
+
+ // Get the first old key (x0 of g0), if it exists.
+ if (k0) x0 = (g0 = oldGroups[0]).key;
+
+ // Find the first new key (x1), skipping NaN keys.
+ while (i1 < n1 && !((x1 = key(newValues[i1])) >= x1)) ++i1;
+
+ // While new keys remain…
+ while (i1 < n1) {
+
+ // Determine the lesser of the two current keys; new and old.
+ // If there are no old keys remaining, then always add the new key.
+ if (g0 && x0 <= x1) {
+ g = g0, x = x0;
+
+ // Record the new index of the old group.
+ reIndex[i0] = k;
+
+ // Retrieve the next old key.
+ if (g0 = oldGroups[++i0]) x0 = g0.key;
+ } else {
+ g = {key: x1, value: initial()}, x = x1;
+ }
+
+ // Add the lesser group.
+ groups[k] = g;
+
+ // Add any selected records belonging to the added group, while
+ // advancing the new key and populating the associated group index.
+ while (!(x1 > x)) {
+ groupIndex[j = newIndex[i1] + n0] = k;
+ if (!(filters[j] & zero)) g.value = add(g.value, data[j]);
+ if (++i1 >= n1) break;
+ x1 = key(newValues[i1]);
+ }
+
+ groupIncrement();
+ }
+
+ // Add any remaining old groups that were greater than all new keys.
+ // No incremental reduce is needed; these groups have no new records.
+ // Also record the new index of the old group.
+ while (i0 < k0) {
+ groups[reIndex[i0] = k] = oldGroups[i0++];
+ groupIncrement();
+ }
+
+ // If we added any new groups before any old groups,
+ // update the group index of all the old records.
+ if (k > i0) for (i0 = 0; i0 < n0; ++i0) {
+ groupIndex[i0] = reIndex[groupIndex[i0]];
+ }
+
+ // Modify the update and reset behavior based on the cardinality.
+ // If the cardinality is less than or equal to one, then the groupIndex
+ // is not needed. If the cardinality is zero, then there are no records
+ // and therefore no groups to update or reset. Note that we also must
+ // change the registered listener to point to the new method.
+ j = filterListeners.indexOf(update);
+ if (k > 1) {
+ update = updateMany;
+ reset = resetMany;
+ } else {
+ if (k === 1) {
+ update = updateOne;
+ reset = resetOne;
+ } else {
+ update = tesseract_null;
+ reset = tesseract_null;
+ }
+ groupIndex = null;
+ }
+ filterListeners[j] = update;
+
+ // Count the number of added groups,
+ // and widen the group index as needed.
+ function groupIncrement() {
+ if (++k === groupCapacity) {
+ reIndex = tesseract_arrayWiden(reIndex, groupWidth <<= 1);
+ groupIndex = tesseract_arrayWiden(groupIndex, groupWidth);
+ groupCapacity = tesseract_capacity(groupWidth);
+ }
+ }
+ }
+
+ // Reduces the specified selected or deselected records.
+ // This function is only used when the cardinality is greater than 1.
+ function updateMany(filterOne, added, removed) {
+ if (filterOne === one || resetNeeded) return;
+
+ var i,
+ k,
+ n;
+
+ // Add the added values.
+ for (i = 0, n = added.length; i < n; ++i) {
+ if (!(filters[k = added[i]] & zero)) {
+ g = groups[groupIndex[k]];
+ g.value = reduceAdd(g.value, data[k]);
+ }
+ }
+
+ // Remove the removed values.
+ for (i = 0, n = removed.length; i < n; ++i) {
+ if ((filters[k = removed[i]] & zero) === filterOne) {
+ g = groups[groupIndex[k]];
+ g.value = reduceRemove(g.value, data[k]);
+ }
+ }
+ }
+
+ // Reduces the specified selected or deselected records.
+ // This function is only used when the cardinality is 1.
+ function updateOne(filterOne, added, removed) {
+ if (filterOne === one || resetNeeded) return;
+
+ var i,
+ k,
+ n,
+ g = groups[0];
+
+ // Add the added values.
+ for (i = 0, n = added.length; i < n; ++i) {
+ if (!(filters[k = added[i]] & zero)) {
+ g.value = reduceAdd(g.value, data[k]);
+ }
+ }
+
+ // Remove the removed values.
+ for (i = 0, n = removed.length; i < n; ++i) {
+ if ((filters[k = removed[i]] & zero) === filterOne) {
+ g.value = reduceRemove(g.value, data[k]);
+ }
+ }
+ }
+
+ // Recomputes the group reduce values from scratch.
+ // This function is only used when the cardinality is greater than 1.
+ function resetMany() {
+ var i,
+ g;
+
+ // Reset all group values.
+ for (i = 0; i < k; ++i) {
+ groups[i].value = reduceInitial();
+ }
+
+ // Add any selected records.
+ for (i = 0; i < n; ++i) {
+ if (!(filters[i] & zero)) {
+ g = groups[groupIndex[i]];
+ g.value = reduceAdd(g.value, data[i]);
+ }
+ }
+ }
+
+ // Recomputes the group reduce values from scratch.
+ // This function is only used when the cardinality is 1.
+ function resetOne() {
+ var i,
+ g = groups[0];
+
+ // Reset the singleton group values.
+ g.value = reduceInitial();
+
+ // Add any selected records.
+ for (i = 0; i < n; ++i) {
+ if (!(filters[i] & zero)) {
+ g.value = reduceAdd(g.value, data[i]);
+ }
+ }
+ }
+
+ // Returns the array of group values, in the dimension's natural order.
+ function all() {
+ if (resetNeeded) reset(), resetNeeded = false;
+ return groups;
+ }
+
+ // Returns a new array containing the top K group values, in reduce order.
+ function top(k) {
+ var top = select(all(), 0, groups.length, k);
+ return heap.sort(top, 0, top.length);
+ }
+
+ // Sets the reduce behavior for this group to use the specified functions.
+ // This method lazily recomputes the reduce values, waiting until needed.
+ function reduce(add, remove, initial) {
+ reduceAdd = add;
+ reduceRemove = remove;
+ reduceInitial = initial;
+ resetNeeded = true;
+ return group;
+ }
+
+ // A convenience method for reducing by count.
+ function reduceCount() {
+ return reduce(tesseract_reduceIncrement, tesseract_reduceDecrement, tesseract_zero);
+ }
+
+ // A convenience method for reducing by sum(value).
+ function reduceSum(value) {
+ return reduce(tesseract_reduceAdd(value), tesseract_reduceSubtract(value), tesseract_zero);
+ }
+
+ // Sets the reduce order, using the specified accessor.
+ function order(value) {
+ select = heapselect_by(valueOf);
+ heap = heap_by(valueOf);
+ function valueOf(d) { return value(d.value); }
+ return group;
+ }
+
+ // A convenience method for natural ordering by reduce value.
+ function orderNatural() {
+ return order(tesseract_identity);
+ }
+
+ // Returns the cardinality of this group, irrespective of any filters.
+ function size() {
+ return k;
+ }
+
+ return reduceCount().orderNatural();
+ }
+
+ // A convenience function for generating a singleton group.
+ function groupAll() {
+ var g = group(tesseract_null), all = g.all;
+ delete g.all;
+ delete g.top;
+ delete g.order;
+ delete g.orderNatural;
+ delete g.size;
+ g.value = function() { return all()[0].value; };
+ return g;
+ }
+
+ return dimension;
+ }
+
+ // A convenience method for groupAll on a dummy dimension.
+ // This implementation can be optimized since it is always cardinality 1.
+ function groupAll() {
+ var group = {
+ reduce: reduce,
+ reduceCount: reduceCount,
+ reduceSum: reduceSum,
+ value: value
+ };
+
+ var reduceValue,
+ reduceAdd,
+ reduceRemove,
+ reduceInitial,
+ resetNeeded = true;
+
+ // The group listens to the tesseract for when any dimension changes, so
+ // that it can update the reduce value. It must also listen to the parent
+ // dimension for when data is added.
+ filterListeners.push(update);
+ dataListeners.push(add);
+
+ // For consistency; actually a no-op since resetNeeded is true.
+ add(data, 0, n);
+
+ // Incorporates the specified new values into this group.
+ function add(newData, n0, n1) {
+ var i;
+
+ if (resetNeeded) return;
+
+ // Add the added values.
+ for (i = n0; i < n; ++i) {
+ if (!filters[i]) {
+ reduceValue = reduceAdd(reduceValue, data[i]);
+ }
+ }
+ }
+
+ // Reduces the specified selected or deselected records.
+ function update(filterOne, added, removed) {
+ var i,
+ k,
+ n;
+
+ if (resetNeeded) return;
+
+ // Add the added values.
+ for (i = 0, n = added.length; i < n; ++i) {
+ if (!filters[k = added[i]]) {
+ reduceValue = reduceAdd(reduceValue, data[k]);
+ }
+ }
+
+ // Remove the removed values.
+ for (i = 0, n = removed.length; i < n; ++i) {
+ if (filters[k = removed[i]] === filterOne) {
+ reduceValue = reduceRemove(reduceValue, data[k]);
+ }
+ }
+ }
+
+ // Recomputes the group reduce value from scratch.
+ function reset() {
+ var i;
+
+ reduceValue = reduceInitial();
+
+ for (i = 0; i < n; ++i) {
+ if (!filters[i]) {
+ reduceValue = reduceAdd(reduceValue, data[i]);
+ }
+ }
+ }
+
+ // Sets the reduce behavior for this group to use the specified functions.
+ // This method lazily recomputes the reduce value, waiting until needed.
+ function reduce(add, remove, initial) {
+ reduceAdd = add;
+ reduceRemove = remove;
+ reduceInitial = initial;
+ resetNeeded = true;
+ return group;
+ }
+
+ // A convenience method for reducing by count.
+ function reduceCount() {
+ return reduce(tesseract_reduceIncrement, tesseract_reduceDecrement, tesseract_zero);
+ }
+
+ // A convenience method for reducing by sum(value).
+ function reduceSum(value) {
+ return reduce(tesseract_reduceAdd(value), tesseract_reduceSubtract(value), tesseract_zero);
+ }
+
+ // Returns the computed reduce value.
+ function value() {
+ if (resetNeeded) reset(), resetNeeded = false;
+ return reduceValue;
+ }
+
+ return reduceCount();
+ }
+
+ // Returns the number of records in this tesseract, irrespective of any filters.
+ function size() {
+ return n;
+ }
+
+ return arguments.length
+ ? add(arguments[0])
+ : tesseract;
+}
+
+// Returns an array of size n, big enough to store ids up to m.
+function tesseract_index(n, m) {
+ return (m < 0x101
+ ? tesseract_array8 : m < 0x10001
+ ? tesseract_array16
+ : tesseract_array32)(n);
+}
+
+// Constructs a new array of size n, with sequential values from 0 to n - 1.
+function tesseract_range(n) {
+ var range = tesseract_index(n, n);
+ for (var i = -1; ++i < n;) range[i] = i;
+ return range;
+}
+
+function tesseract_capacity(w) {
+ return w === 8
+ ? 0x100 : w === 16
+ ? 0x10000
+ : 0x100000000;
+}
1  src/version.js
@@ -0,0 +1 @@
+tesseract.version = "0.0.2";
3  src/zero.js
@@ -0,0 +1,3 @@
+function tesseract_zero() {
+ return 0;
+}
1,177 tesseract.js
@@ -0,0 +1,1177 @@
+(function(exports){
+tesseract.version = "0.0.2";
+function tesseract_identity(d) {
+ return d;
+}
+tesseract.permute = permute;
+
+function permute(array, index) {
+ for (var i = 0, n = index.length, copy = new Array(n); i < n; ++i) {
+ copy[i] = array[index[i]];
+ }
+ return copy;
+}
+var bisect = tesseract.bisect = bisect_by(tesseract_identity);
+
+bisect.by = bisect_by;
+
+function bisect_by(f) {
+
+ // Locate the insertion point for x in a to maintain sorted order. The
+ // arguments lo and hi may be used to specify a subset of the array which
+ // should be considered; by default the entire array is used. If x is already
+ // present in a, the insertion point will be before (to the left of) any
+ // existing entries. The return value is suitable for use as the first
+ // argument to `array.splice` assuming that a is already sorted.
+ //
+ // The returned insertion point i partitions the array a into two halves so
+ // that all v < x for v in a[lo:i] for the left side and all v >= x for v in
+ // a[i:hi] for the right side.
+ function bisectLeft(a, x, lo, hi) {
+ while (lo < hi) {
+ var mid = lo + hi >> 1;
+ if (f(a[mid]) < x) lo = mid + 1;
+ else hi = mid;
+ }
+ return lo;
+ }
+
+ // Similar to bisectLeft, but returns an insertion point which comes after (to
+ // the right of) any existing entries of x in a.
+ //
+ // The returned insertion point i partitions the array into two halves so that
+ // all v <= x for v in a[lo:i] for the left side and all v > x for v in
+ // a[i:hi] for the right side.
+ function bisectRight(a, x, lo, hi) {
+ while (lo < hi) {
+ var mid = lo + hi >> 1;
+ if (x < f(a[mid])) hi = mid;
+ else lo = mid + 1;
+ }
+ return lo;
+ }
+
+ bisectRight.right = bisectRight;
+ bisectRight.left = bisectLeft;
+ return bisectRight;
+}
+var heap = tesseract.heap = heap_by(tesseract_identity);
+
+heap.by = heap_by;
+
+function heap_by(f) {
+
+ // Builds a binary heap within the specified array a[lo:hi]. The heap has the
+ // property such that the parent a[lo+i] is always less than or equal to its
+ // two children: a[lo+2*i+1] and a[lo+2*i+2].
+ function heap(a, lo, hi) {
+ var n = hi - lo,
+ i = (n >>> 1) + 1;
+ while (--i > 0) sift(a, i, n, lo);
+ return a;
+ }
+
+ // Sorts the specified array a[lo:hi] in descending order, assuming it is
+ // already a heap.
+ function sort(a, lo, hi) {
+ var n = hi - lo,
+ t;
+ while (--n > 0) t = a[lo], a[lo] = a[lo + n], a[lo + n] = t, sift(a, 1, n, lo);
+ return a;
+ }
+
+ // Sifts the element a[lo+i-1] down the heap, where the heap is the contiguous
+ // slice of array a[lo:lo+n]. This method can also be used to update the heap
+ // incrementally, without incurring the full cost of reconstructing the heap.
+ function sift(a, i, n, lo) {
+ var d = a[--lo + i],
+ x = f(d),
+ child;
+ while ((child = i << 1) <= n) {
+ if (child < n && f(a[lo + child]) > f(a[lo + child + 1])) child++;
+ if (x <= f(a[lo + child])) break;
+ a[lo + i] = a[lo + child];
+ i = child;
+ }
+ a[lo + i] = d;
+ }
+
+ heap.sort = sort;
+ return heap;
+}
+var heapselect = tesseract.heapselect = heapselect_by(tesseract_identity);
+
+heapselect.by = heapselect_by;
+
+function heapselect_by(f) {
+ var heap = heap_by(f);
+
+ // Returns a new array containing the top k elements in the array a[lo:hi].
+ // The returned array is not sorted, but maintains the heap property. If k is
+ // greater than hi - lo, then fewer than k elements will be returned. The
+ // order of elements in a is unchanged by this operation.
+ function heapselect(a, lo, hi, k) {
+ var queue = new Array(k = Math.min(hi - lo, k)),
+ min,
+ i,
+ x,
+ d;
+
+ for (i = 0; i < k; ++i) queue[i] = a[lo++];
+ heap(queue, 0, k);
+
+ if (lo < hi) {
+ min = f(queue[0]);
+ do {
+ if (x = f(d = a[lo]) > min) {
+ queue[0] = d;
+ min = f(heap(queue, 0, k)[0]);
+ }
+ } while (++lo < hi);
+ }
+
+ return queue;
+ }
+
+ return heapselect;
+}
+var insertionsort = tesseract.insertionsort = insertionsort_by(tesseract_identity);
+
+insertionsort.by = insertionsort_by;
+
+function insertionsort_by(f) {
+
+ function insertionsort(a, lo, hi) {
+ for (var i = lo + 1; i < hi; ++i) {
+ for (var j = i, t = a[i], x = f(t); j > lo && f(a[j - 1]) > x; --j) {
+ a[j] = a[j - 1];
+ }
+ a[j] = t;
+ }
+ return a;
+ }
+
+ return insertionsort;
+}
+// Algorithm designed by Vladimir Yaroslavskiy.
+// Implementation based on the Dart project; see lib/dart/LICENSE for details.
+
+var quicksort = tesseract.quicksort = quicksort_by(tesseract_identity);
+
+quicksort.by = quicksort_by;
+
+function quicksort_by(f) {
+ var insertionsort = insertionsort_by(f);
+
+ function sort(a, lo, hi) {
+ return (hi - lo < quicksort_sizeThreshold
+ ? insertionsort
+ : quicksort)(a, lo, hi);
+ }
+
+ function quicksort(a, lo, hi) {
+
+ // Compute the two pivots by looking at 5 elements.
+ var sixth = (hi - lo) / 6 | 0,
+ i1 = lo + sixth,
+ i5 = hi - 1 - sixth,
+ i3 = lo + hi - 1 >> 1, // The midpoint.
+ i2 = i3 - sixth,
+ i4 = i3 + sixth;
+
+ var e1 = a[i1], x1 = f(e1),
+ e2 = a[i2], x2 = f(e2),
+ e3 = a[i3], x3 = f(e3),
+ e4 = a[i4], x4 = f(e4),
+ e5 = a[i5], x5 = f(e5);
+
+ // Sort the selected 5 elements using a sorting network.
+ if (x1 > x2) t = e1, e1 = e2, e2 = t, t = x1, x1 = x2, x2 = t;
+ if (x4 > x5) t = e4, e4 = e5, e5 = t, t = x4, x4 = x5, x5 = t;
+ if (x1 > x3) t = e1, e1 = e3, e3 = t, t = x1, x1 = x3, x3 = t;
+ if (x2 > x3) t = e2, e2 = e3, e3 = t, t = x2, x2 = x3, x3 = t;
+ if (x1 > x4) t = e1, e1 = e4, e4 = t, t = x1, x1 = x4, x4 = t;
+ if (x3 > x4) t = e3, e3 = e4, e4 = t, t = x3, x3 = x4, x4 = t;
+ if (x2 > x5) t = e2, e2 = e5, e5 = t, t = x2, x2 = x5, x5 = t;
+ if (x2 > x3) t = e2, e2 = e3, e3 = t, t = x2, x2 = x3, x3 = t;
+ if (x4 > x5) t = e4, e4 = e5, e5 = t, t = x4, x4 = x5, x5 = t;
+
+ var pivot1 = e2, pivotValue1 = x2,
+ pivot2 = e4, pivotValue2 = x4;
+
+ // e2 and e4 have been saved in the pivot variables. They will be written
+ // back, once the partioning is finished.
+ a[i1] = e1;
+ a[i2] = a[lo];
+ a[i3] = e3;
+ a[i4] = a[hi - 1];
+ a[i5] = e5;
+
+ var less = lo + 1, // First element in the middle partition.
+ great = hi - 2; // Last element in the middle partition.
+
+ // Note that for value comparison, <, <=, >= and > coerce to a primitive via
+ // Object.prototype.valueOf; == and === do not, so in order to be consistent
+ // with natural order (such as for Date objects), we must do two compares.
+ var pivotsEqual = pivotValue1 <= pivotValue2 && pivotValue1 >= pivotValue2;
+ if (pivotsEqual) {
+
+ // Degenerated case where the partioning becomes a dutch national flag
+ // problem.
+ //
+ // [ | < pivot | == pivot | unpartitioned | > pivot | ]
+ // ^ ^ ^ ^ ^
+ // left less k great right
+ //
+ // a[left] and a[right] are undefined and are filled after the
+ // partitioning.
+ //
+ // Invariants:
+ // 1) for x in ]left, less[ : x < pivot.
+ // 2) for x in [less, k[ : x == pivot.
+ // 3) for x in ]great, right[ : x > pivot.
+ for (var k = less; k <= great; ++k) {
+ var ek = a[k], xk = f(ek);
+ if (xk < pivotValue1) {
+ if (k !== less) {
+ a[k] = a[less];
+ a[less] = ek;
+ }
+ ++less;
+ } else if (xk > pivotValue1) {
+
+ // Find the first element <= pivot in the range [k - 1, great] and
+ // put [:ek:] there. We know that such an element must exist:
+ // When k == less, then el3 (which is equal to pivot) lies in the
+ // interval. Otherwise a[k - 1] == pivot and the search stops at k-1.
+ // Note that in the latter case invariant 2 will be violated for a
+ // short amount of time. The invariant will be restored when the
+ // pivots are put into their final positions.
+ while (true) {
+ var greatValue = f(a[great]);
+ if (greatValue > pivotValue1) {
+ great--;
+ // This is the only location in the while-loop where a new
+ // iteration is started.
+ continue;
+ } else if (greatValue < pivotValue1) {
+ // Triple exchange.
+ a[k] = a[less];
+ a[less++] = a[great];
+ a[great--] = ek;
+ break;
+ } else {
+ a[k] = a[great];
+ a[great--] = ek;
+ // Note: if great < k then we will exit the outer loop and fix
+ // invariant 2 (which we just violated).
+ break;
+ }
+ }
+ }
+ }
+ } else {
+
+ // We partition the list into three parts:
+ // 1. < pivot1
+ // 2. >= pivot1 && <= pivot2
+ // 3. > pivot2
+ //
+ // During the loop we have:
+ // [ | < pivot1 | >= pivot1 && <= pivot2 | unpartitioned | > pivot2 | ]
+ // ^ ^ ^ ^ ^
+ // left less k great right
+ //
+ // a[left] and a[right] are undefined and are filled after the
+ // partitioning.
+ //
+ // Invariants:
+ // 1. for x in ]left, less[ : x < pivot1
+ // 2. for x in [less, k[ : pivot1 <= x && x <= pivot2
+ // 3. for x in ]great, right[ : x > pivot2
+ for (var k = less; k <= great; k++) {
+ var ek = a[k], xk = f(ek);
+ if (xk < pivotValue1) {
+ if (k !== less) {
+ a[k] = a[less];
+ a[less] = ek;
+ }
+ ++less;
+ } else {
+ if (xk > pivotValue2) {
+ while (true) {
+ var greatValue = f(a[great]);
+ if (greatValue > pivotValue2) {
+ great--;
+ if (great < k) break;
+ // This is the only location inside the loop where a new
+ // iteration is started.
+ continue;
+ } else {
+ // a[great] <= pivot2.
+ if (greatValue < pivotValue1) {
+ // Triple exchange.
+ a[k] = a[less];
+ a[less++] = a[great];
+ a[great--] = ek;
+ } else {
+ // a[great] >= pivot1.
+ a[k] = a[great];
+ a[great--] = ek;
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Move pivots into their final positions.
+ // We shrunk the list from both sides (a[left] and a[right] have
+ // meaningless values in them) and now we move elements from the first
+ // and third partition into these locations so that we can store the
+ // pivots.
+ a[lo] = a[less - 1];
+ a[less - 1] = pivot1;
+ a[hi - 1] = a[great + 1];
+ a[great + 1] = pivot2;
+
+ // The list is now partitioned into three partitions:
+ // [ < pivot1 | >= pivot1 && <= pivot2 | > pivot2 ]
+ // ^ ^ ^ ^
+ // left less great right
+
+ // Recursive descent. (Don't include the pivot values.)
+ sort(a, lo, less - 1);
+ sort(a, great + 2, hi);
+
+ if (pivotsEqual) {
+ // All elements in the second partition are equal to the pivot. No
+ // need to sort them.
+ return a;
+ }
+
+ // In theory it should be enough to call _doSort recursively on the second
+ // partition.
+ // The Android source however removes the pivot elements from the recursive
+ // call if the second partition is too large (more than 2/3 of the list).
+ if (less < i1 && great > i5) {
+ var lessValue, greatValue;
+ while ((lessValue = f(a[less])) <= pivotValue1 && lessValue >= pivotValue1) ++less;
+ while ((greatValue = f(a[great])) <= pivotValue2 && greatValue >= pivotValue2) --great;
+
+ // Copy paste of the previous 3-way partitioning with adaptions.
+ //
+ // We partition the list into three parts:
+ // 1. == pivot1
+ // 2. > pivot1 && < pivot2
+ // 3. == pivot2
+ //
+ // During the loop we have:
+ // [ == pivot1 | > pivot1 && < pivot2 | unpartitioned | == pivot2 ]
+ // ^ ^ ^
+ // less k great
+ //
+ // Invariants:
+ // 1. for x in [ *, less[ : x == pivot1
+ // 2. for x in [less, k[ : pivot1 < x && x < pivot2
+ // 3. for x in ]great, * ] : x == pivot2
+ for (var k = less; k <= great; k++) {
+ var ek = a[k], xk = f(ek);
+ if (xk <= pivotValue1 && xk >= pivotValue1) {
+ if (k !== less) {
+ a[k] = a[less];
+ a[less] = ek;
+ }
+ less++;
+ } else {
+ if (xk <= pivotValue2 && xk >= pivotValue2) {
+ while (true) {
+ var greatValue = f(a[great]);
+ if (greatValue <= pivotValue2 && greatValue >= pivotValue2) {
+ great--;
+ if (great < k) break;
+ // This is the only location inside the loop where a new
+ // iteration is started.
+ continue;
+ } else {
+ // a[great] < pivot2.
+ if (greatValue < pivotValue1) {
+ // Triple exchange.
+ a[k] = a[less];
+ a[less++] = a[great];
+ a[great--] = ek;
+ } else {
+ // a[great] == pivot1.
+ a[k] = a[great];
+ a[great--] = ek;
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // The second partition has now been cleared of pivot elements and looks
+ // as follows:
+ // [ * | > pivot1 && < pivot2 | * ]
+ // ^ ^
+ // less great
+ // Sort the second partition using recursive descent.
+
+ // The second partition looks as follows:
+ // [ * | >= pivot1 && <= pivot2 | * ]
+ // ^ ^
+ // less great
+ // Simply sort it by recursive descent.
+
+ return sort(a, less, great + 1);
+ }
+
+ return sort;
+}
+
+var quicksort_sizeThreshold = 32;
+var tesseract_array8 = tesseract_arrayUntyped,
+ tesseract_array16 = tesseract_arrayUntyped,
+ tesseract_array32 = tesseract_arrayUntyped,
+ tesseract_arrayLengthen = tesseract_identity,
+ tesseract_arrayWiden = tesseract_identity;
+
+if (typeof "Uint8Array" !== "undefined") {
+ tesseract_array8 = function(n) { return new Uint8Array(n); };
+ tesseract_array16 = function(n) { return new Uint16Array(n); };
+ tesseract_array32 = function(n) { return new Uint32Array(n); };
+
+ tesseract_arrayLengthen = function(array, length) {
+ var copy = new array.constructor(length);
+ copy.set(array);
+ return copy;
+ };
+
+ tesseract_arrayWiden = function(array, width) {
+ var copy;
+ switch (width) {
+ case 16: copy = tesseract_array16(array.length); break;
+ case 32: copy = tesseract_array32(array.length); break;
+ default: throw new Error("invalid array width!");
+ }
+ copy.set(array);
+ return copy;
+ };
+}
+
+function tesseract_arrayUntyped(n) {
+ return new Array(n);
+}
+function tesseract_filterExact(bisect, value) {
+ return function(values) {
+ var n = values.length;
+ return [bisect.left(values, value, 0, n), bisect.right(values, value, 0, n)];
+ };
+}
+
+function tesseract_filterRange(bisect, range) {
+ var min = range[0],
+ max = range[1];
+ return function(values) {
+ var n = values.length;
+ return [bisect.left(values, min, 0, n), bisect.left(values, max, 0, n)];
+ };
+}
+
+function tesseract_filterAll(values) {
+ return [0, values.length];
+}
+function tesseract_null() {
+ return null;
+}
+function tesseract_zero() {
+ return 0;
+}
+function tesseract_reduceIncrement(p) {
+ return p + 1;
+}
+
+function tesseract_reduceDecrement(p) {
+ return p - 1;
+}
+
+function tesseract_reduceAdd(f) {
+ return function(p, v) {
+ return p + +f(v);
+ };
+}
+
+function tesseract_reduceSubtract(f) {
+ return function(p, v) {
+ return p - f(v);
+ };
+}
+exports.tesseract = tesseract;
+
+function tesseract() {
+ var tesseract = {
+ add: add,
+ dimension: dimension,
+ groupAll: groupAll,
+ size: size
+ };
+
+ var data = [], // the records
+ n = 0, // the number of records; data.length
+ m = 0, // number of dimensions in use
+ M = 8, // number of dimensions that can fit in `filters`
+ filters = tesseract_array8(0), // M bits per record; 1 is filtered out
+ filterListeners = [], // when the filters change
+ dataListeners = []; // when data is added
+
+ // Adds the specified new records to this tesseract.
+ function add(newData) {
+ var n0 = n,
+ n1 = newData.length;
+
+ // If there's actually new data to add…
+ // Merge the new data into the existing data.
+ // Lengthen the filter bitset to handle the new records.
+ // Notify listeners (dimensions and groups) that new data is available.
+ if (n1) {
+ data = data.concat(newData);
+ filters = tesseract_arrayLengthen(filters, n += n1);
+ dataListeners.forEach(function(l) { l(newData, n0, n1); });
+ }
+
+ return tesseract;
+ }
+
+ // Adds a new dimension with the specified value accessor function.
+ function dimension(value) {
+ var dimension = {
+ filter: filter,
+ filterExact: filterExact,
+ filterRange: filterRange,
+ filterAll: filterAll,
+ top: top,
+ group: group,
+ groupAll: groupAll
+ };
+
+ var one = 1 << m++, // bit mask, e.g., 00001000
+ zero = ~one, // inverted one, e.g., 11110111
+ values, // sorted, cached array
+ index, // value rank ↦ object id
+ newValues, // temporary array storing newly-added values
+ newIndex, // temporary array storing newly-added index
+ sort = quicksort_by(function(i) { return newValues[i]; }),
+ refilter = tesseract_filterAll, // for recomputing filter
+ indexListeners = [], // when data is added
+ lo0 = 0,
+ hi0 = 0;
+
+ // Updating a dimension is a two-stage process. First, we must update the
+ // associated filters for the newly-added records. Once all dimensions have
+ // updated their filters, the groups are notified to update.
+ dataListeners.unshift(preAdd);
+ dataListeners.push(postAdd);
+
+ // Incorporate any existing data into this dimension, and make sure that the
+ // filter bitset is wide enough to handle the new dimension.
+ if (m > M) filters = tesseract_arrayWiden(filters, M <<= 1);
+ preAdd(data, 0, n);
+ postAdd(data, 0, n);
+
+ // Incorporates the specified new records into this dimension.
+ // This function is responsible for updating filters, values, and index.
+ function preAdd(newData, n0, n1) {
+
+ // Permute new values into natural order using a sorted index.
+ newValues = newData.map(value);
+ newIndex = sort(tesseract_range(n1), 0, n1);
+ newValues = permute(newValues, newIndex);
+
+ // Bisect newValues to determine which new records are selected.
+ var bounds = refilter(newValues), lo1 = bounds[0], hi1 = bounds[1], i;
+ for (i = 0; i < lo1; ++i) filters[newIndex[i] + n0] |= one;
+ for (i = hi1; i < n1; ++i) filters[newIndex[i] + n0] |= one;
+
+ // If this dimension previously had no data, then we don't need to do the
+ // more expensive merge operation; use the new values and index as-is.
+ if (!n0) {
+ values = newValues;
+ index = newIndex;
+ lo0 = lo1;
+ hi0 = hi1;
+ return;
+ }
+
+ var oldValues = values,
+ oldIndex = index,
+ i0 = 0,
+ i1 = 0;
+
+ // Otherwise, create new arrays into which to merge new and old.
+ values = new Array(n);
+ index = tesseract_index(n, n);
+
+ // Merge the old and new sorted values, and old and new index.
+ for (i = 0; i0 < n0 && i1 < n1; ++i) {
+ if (oldValues[i0] < newValues[i1]) {
+ values[i] = oldValues[i0];
+ index[i] = oldIndex[i0++];
+ } else {
+ values[i] = newValues[i1];
+ index[i] = newIndex[i1++] + n0;
+ }
+ }
+
+ // Add any remaining old values.
+ for (; i0 < n0; ++i0, ++i) {
+ values[i] = oldValues[i0];
+ index[i] = oldIndex[i0];
+ }
+
+ // Add any remaining new values.
+ for (; i1 < n1; ++i1, ++i) {
+ values[i] = newValues[i1];
+ index[i] = newIndex[i1] + n0;
+ }
+
+ // Bisect again to recompute lo0 and hi0.
+ bounds = refilter(values), lo0 = bounds[0], hi0 = bounds[1];
+ }
+
+ // When all filters have updated, notify index listeners of the new values.
+ function postAdd(newData, n0, n1) {
+ indexListeners.forEach(function(l) { l(newValues, newIndex, n0, n1); });
+ newValues = newIndex = null;
+ }
+
+ // Updates the selected values based on the specified bounds [lo, hi].
+ // This implementation is used by all the public filter methods.
+ function filterIndex(bounds) {
+ var i,
+ j,
+ k,
+ lo1 = bounds[0],
+ hi1 = bounds[1],
+ added = [],
+ removed = [];
+
+ // Fast incremental update based on previous lo index.
+ if (lo1 < lo0) {
+ for (i = lo1, j = Math.min(lo0, hi1); i < j; ++i) {
+ filters[k = index[i]] ^= one;
+ added.push(k);
+ }
+ } else if (lo1 > lo0) {
+ for (i = lo0, j = Math.min(lo1, hi0); i < j; ++i) {
+ filters[k = index[i]] ^= one;
+ removed.push(k);
+ }
+ }
+
+ // Fast incremental update based on previous hi index.
+ if (hi1 > hi0) {
+ for (i = Math.max(lo1, hi0), j = hi1; i < j; ++i) {
+ filters[k = index[i]] ^= one;
+ added.push(k);
+ }
+ } else if (hi1 < hi0) {
+ for (i = Math.max(lo0, hi1), j = hi0; i < j; ++i) {
+ filters[k = index[i]] ^= one;
+ removed.push(k);
+ }
+ }
+
+ lo0 = lo1;
+ hi0 = hi1;
+ filterListeners.forEach(function(l) { l(one, added, removed); });
+ return dimension;
+ }
+
+ // Filters this dimension using the specified range, value, or null.
+ // If the range is null, this is equivalent to filterAll.
+ // If the range is an array, this is equivalent to filterRange.
+ // Otherwise, this is equivalent to filterExact.
+ function filter(range) {
+ return range == null
+ ? filterAll() : Array.isArray(range)
+ ? filterRange(range)
+ : filterExact(range);
+ }
+
+ // Filters this dimension to select the exact value.
+ function filterExact(value) {
+ return filterIndex((refilter = tesseract_filterExact(bisect, value))(values));
+ }
+
+ // Filters this dimension to select the specified range [lo, hi].
+ // The lower bound is inclusive, and the upper bound is exclusive.
+ function filterRange(range) {
+ return filterIndex((refilter = tesseract_filterRange(bisect, range))(values));
+ }
+
+ // Clears any filters on this dimension.
+ function filterAll() {
+ return filterIndex((refilter = tesseract_filterAll)(values));
+ }
+
+ // Returns the top K selected records, based on this dimension's order.
+ // Note: observes this dimension's filter, unlike group and groupAll.
+ function top(k) {
+ var array = [],
+ i = hi0,
+ j;
+
+ while (--i >= lo0 && k > 0) {
+ if (!filters[j = index[i]]) {
+ array.push(data[j]);
+ --k;
+ }
+ }
+
+ return array;
+ }
+
+ // Adds a new group to this dimension, using the specified key function.
+ function group(key) {
+ var group = {
+ top: top,
+ all: all,
+ reduce: reduce,
+ reduceCount: reduceCount,
+ reduceSum: reduceSum,
+ order: order,
+ orderNatural: orderNatural,
+ size: size
+ };
+
+ var groups, // array of {key, value}
+ groupIndex, // object id ↦ group id
+ groupWidth = 8,
+ groupCapacity = tesseract_capacity(groupWidth),
+ k = 0, // cardinality
+ select,
+ heap,
+ reduceAdd,
+ reduceRemove,
+ reduceInitial,
+ update = tesseract_null,
+ reset = tesseract_null,
+ resetNeeded = true;
+
+ if (arguments.length < 1) key = tesseract_identity;
+
+ // The group listens to the tesseract for when any dimension changes, so
+ // that it can update the associated reduce values. It must also listen to
+ // the parent dimension for when data is added, and compute new keys.
+ filterListeners.push(update);
+ indexListeners.push(add);
+
+ // Incorporate any existing data into the grouping.
+ add(values, index, 0, n);
+
+ // Incorporates the specified new values into this group.
+ // This function is responsible for updating groups and groupIndex.
+ function add(newValues, newIndex, n0, n1) {
+ var oldGroups = groups,
+ reIndex = tesseract_index(k, groupCapacity),
+ add = reduceAdd,
+ initial = reduceInitial,
+ k0 = k, // old cardinality
+ i0 = 0, // index of old group
+ i1 = 0, // index of new record
+ j, // object id
+ g0, // old group
+ x0, // old key
+ x1, // new key
+ g, // group to add
+ x; // key of group to add
+
+ // If a reset is needed, we don't need to update the reduce values.
+ if (resetNeeded) add = initial = tesseract_null;
+
+ // Reset the new groups (k is a lower bound).
+ // Also, make sure that groupIndex exists and is long enough.
+ groups = new Array(k), k = 0;
+ groupIndex = k0 > 1 ? tesseract_arrayLengthen(groupIndex, n) : tesseract_index(n, groupCapacity);
+
+ // Get the first old key (x0 of g0), if it exists.
+ if (k0) x0 = (g0 = oldGroups[0]).key;
+
+ // Find the first new key (x1), skipping NaN keys.
+ while (i1 < n1 && !((x1 = key(newValues[i1])) >= x1)) ++i1;
+
+ // While new keys remain…
+ while (i1 < n1) {
+
+ // Determine the lesser of the two current keys; new and old.
+ // If there are no old keys remaining, then always add the new key.
+ if (g0 && x0 <= x1) {
+ g = g0, x = x0;
+
+ // Record the new index of the old group.
+ reIndex[i0] = k;
+
+ // Retrieve the next old key.
+ if (g0 = oldGroups[++i0]) x0 = g0.key;
+ } else {
+ g = {key: x1, value: initial()}, x = x1;
+ }
+
+ // Add the lesser group.
+ groups[k] = g;
+
+ // Add any selected records belonging to the added group, while
+ // advancing the new key and populating the associated group index.
+ while (!(x1 > x)) {
+ groupIndex[j = newIndex[i1] + n0] = k;
+ if (!(filters[j] & zero)) g.value = add(g.value, data[j]);
+ if (++i1 >= n1) break;
+ x1 = key(newValues[i1]);
+ }
+
+ groupIncrement();
+ }
+
+ // Add any remaining old groups that were greater than all new keys.
+ // No incremental reduce is needed; these groups have no new records.
+ // Also record the new index of the old group.
+ while (i0 < k0) {
+ groups[reIndex[i0] = k] = oldGroups[i0++];
+ groupIncrement();
+ }
+
+ // If we added any new groups before any old groups,
+ // update the group index of all the old records.
+ if (k > i0) for (i0 = 0; i0 < n0; ++i0) {
+ groupIndex[i0] = reIndex[groupIndex[i0]];
+ }
+
+ // Modify the update and reset behavior based on the cardinality.
+ // If the cardinality is less than or equal to one, then the groupIndex
+ // is not needed. If the cardinality is zero, then there are no records
+ // and therefore no groups to update or reset. Note that we also must
+ // change the registered listener to point to the new method.
+ j = filterListeners.indexOf(update);
+ if (k > 1) {
+ update = updateMany;
+ reset = resetMany;
+ } else {
+ if (k === 1) {
+ update = updateOne;
+ reset = resetOne;
+ } else {
+ update = tesseract_null;
+ reset = tesseract_null;
+ }
+ groupIndex = null;
+ }
+ filterListeners[j] = update;
+
+ // Count the number of added groups,
+ // and widen the group index as needed.
+ function groupIncrement() {
+ if (++k === groupCapacity) {
+ reIndex = tesseract_arrayWiden(reIndex, groupWidth <<= 1);
+ groupIndex = tesseract_arrayWiden(groupIndex, groupWidth);
+ groupCapacity = tesseract_capacity(groupWidth);
+ }
+ }
+ }
+
+ // Reduces the specified selected or deselected records.
+ // This function is only used when the cardinality is greater than 1.
+ function updateMany(filterOne, added, removed) {
+ if (filterOne === one || resetNeeded) return;
+
+ var i,
+ k,
+ n;
+
+ // Add the added values.
+ for (i = 0, n = added.length; i < n; ++i) {
+ if (!(filters[k = added[i]] & zero)) {
+ g = groups[groupIndex[k]];
+ g.value = reduceAdd(g.value, data[k]);
+ }
+ }
+
+ // Remove the removed values.
+ for (i = 0, n = removed.length; i < n; ++i) {
+ if ((filters[k = removed[i]] & zero) === filterOne) {
+ g = groups[groupIndex[k]];
+ g.value = reduceRemove(g.value, data[k]);
+ }
+ }
+ }
+
+ // Reduces the specified selected or deselected records.
+ // This function is only used when the cardinality is 1.
+ function updateOne(filterOne, added, removed) {
+ if (filterOne === one || resetNeeded) return;
+
+ var i,
+ k,
+ n,
+ g = groups[0];
+
+ // Add the added values.
+ for (i = 0, n = added.length; i < n; ++i) {
+ if (!(filters[k = added[i]] & zero)) {
+ g.value = reduceAdd(g.value, data[k]);
+ }
+ }
+
+ // Remove the removed values.
+ for (i = 0, n = removed.length; i < n; ++i) {
+ if ((filters[k = removed[i]] & zero) === filterOne) {
+ g.value = reduceRemove(g.value, data[k]);
+ }
+ }
+ }
+
+ // Recomputes the group reduce values from scratch.
+ // This function is only used when the cardinality is greater than 1.
+ function resetMany() {
+ var i,
+ g;
+
+ // Reset all group values.
+ for (i = 0; i < k; ++i) {
+ groups[i].value = reduceInitial();
+ }
+
+ // Add any selected records.
+ for (i = 0; i < n; ++i) {
+ if (!(filters[i] & zero)) {
+ g = groups[groupIndex[i]];
+ g.value = reduceAdd(g.value, data[i]);
+ }
+ }
+ }
+
+ // Recomputes the group reduce values from scratch.
+ // This function is only used when the cardinality is 1.
+ function resetOne() {
+ var i,
+ g = groups[0];
+
+ // Reset the singleton group values.
+ g.value = reduceInitial();
+
+ // Add any selected records.
+ for (i = 0; i < n; ++i) {
+ if (!(filters[i] & zero)) {
+ g.value = reduceAdd(g.value, data[i]);
+ }
+ }
+ }
+
+ // Returns the array of group values, in the dimension's natural order.
+ function all() {
+ if (resetNeeded) reset(), resetNeeded = false;
+ return groups;