RubyGems - d3_rails - Versions diffs - 2.8.0 → 2.8.1 - Mend

d3_rails 2.8.0 → 2.8.1

Files changed (63) hide show

data/vendor/assets/javascripts/tesseract/tesseract.min.js ADDED

@@ -0,0 +1 @@

data/vendor/assets/javascripts/tesseract/test/benchmark.js ADDED

@@ -0,0 +1,177 @@
+var tesseract = require("../"),
+    d3 = require("d3");
+var then,
+    then2;
+// Various generators for our synthetic dataset.
+var firstSize = 9e4,
+    secondSize = 1e4,
+    totalSize = firstSize + secondSize,
+    randomDayOfWeek = randomIndex([0, .6, .7, .75, .8, .76, 0]),
+    randomHourOfDay = randomIndex([0, 0, 0, 0, 0, 0, 0, .2, .5, .7, .85, .9, .8, .69, .72, .8, .78, .7, .3, 0, 0, 0, 0, 0]),
+    randomDate = randomRecentDate(randomDayOfWeek, randomHourOfDay, 13),
+    randomAmount = randomLogNormal(2.5, .5),
+    randomPayment = function() { return {date: randomDate(), amount: randomAmount()}; };
+// Various formatters to show our synthetic distributions.
+var x = d3.scale.linear().rangeRound([0, 20]),
+    dayNames = ["S", "M", "T", "W", "T", "F", "S"],
+    formatNumber = d3.format(",.02r"),
+    formatInteger = d3.format("8d"),
+    formatDate = d3.time.format("%x"),
+    formatDay = function(i) { return dayNames[i]; };
+// Create the synthetic records.
+then = Date.now();
+var paymentRecords = d3.range(totalSize).map(randomPayment);
+console.log("Synthesizing " + formatNumber(totalSize) + " records: " + formatNumber(Date.now() - then) + "ms.");
+// Slice the records into batches so we can measure incremental add.
+var firstBatch = paymentRecords.slice(0, firstSize),
+    secondBatch = paymentRecords.slice(firstSize);
+// Create the tesseract and relevant dimensions and groups.
+then = then2 = Date.now();
+var payments = tesseract(firstBatch),
+    all = payments.groupAll(),
+    amount = payments.dimension(function(d) { return d.amount; }),
+    amounts = amount.group(Math.floor),
+    date = payments.dimension(function(d) { return d.date; }),
+    dates = date.group(d3.time.day),
+    day = payments.dimension(function(d) { return d.date.getDay(); }),
+    days = day.group(),
+    hour = payments.dimension(function(d) { return d.date.getHours(); }),
+    hours = hour.group();
+console.log("Indexing " + formatNumber(firstSize) + " records: " + formatNumber(Date.now() - then) + "ms.");
+// Add the second batch incrementally.
+then = Date.now();
+payments.add(secondBatch);
+console.log("Indexing " + formatNumber(secondSize) + " records: " + formatNumber(Date.now() - then) + "ms.");
+console.log("Total indexing time: " + formatNumber(Date.now() - then2) + "ms.");
+console.log("");
+// Simulate filtering by dates.
+then = Date.now();
+var today = d3.time.day(new Date());
+for (var i = 0, n = 90, k = 0; i < n; ++i) {
+  var ti = d3.time.day.offset(today, -i);
+  for (var j = 0; j < i; ++j) {
+    var tj = d3.time.day.offset(today, -j);
+    date.filterRange([ti, tj]);
+    updateDisplay();
+  }
+}
+console.log("Filtering by date: " + formatNumber((Date.now() - then) / k) + "ms/op.");
+date.filterAll();
+// Simulate filtering by day.
+then = Date.now();
+for (var i = 0, n = 7, k = 0; i < n; ++i) {
+  for (var j = i; j < n; ++j) {
+    day.filterRange([i, j]);
+    updateDisplay();
+  }
+}
+console.log("Filtering by day: " + formatNumber((Date.now() - then) / k) + "ms/op.");
+day.filterAll();
+// Simulate filtering by hour.
+then = Date.now();
+for (var i = 0, n = 24, k = 0; i < n; ++i) {
+  for (var j = i; j < n; ++j) {
+    hour.filterRange([i, j]);
+    updateDisplay();
+  }
+}
+console.log("Filtering by hour: " + formatNumber((Date.now() - then) / k) + "ms/op.");
+hour.filterAll();
+// Simulate filtering by amount.
+then = Date.now();
+for (var i = 0, n = 35, k = 0; i < n; ++i) {
+  for (var j = i; j < n; ++j) {
+    amount.filterRange([i, j]);
+    updateDisplay();
+  }
+}
+console.log("Filtering by amount: " + formatNumber((Date.now() - then) / k) + "ms/op.");
+amount.filterAll();
+console.log("");
+console.log("Day of Week:");
+x.domain([0, days.top(1)[0].value]);
+days.all().forEach(function(g) {
+  console.log("       " + formatDay(g.key) + ": " + new Array(x(g.value) + 1).join("▇"));
+});
+console.log("");
+console.log("Hour of Day:");
+x.domain([0, hours.top(1)[0].value]);
+hours.all().forEach(function(g) {
+  console.log(formatInteger(g.key) + ": " + new Array(x(g.value) + 1).join("▇"));
+});
+console.log("");
+console.log("Date:");
+x.domain([0, dates.top(1)[0].value]);
+dates.all().forEach(function(g) {
+  console.log(formatDate(g.key) + ": " + new Array(x(g.value) + 1).join("▇"));
+});
+console.log("");
+console.log("Amount:");
+x.domain([0, amounts.top(1)[0].value]);
+amounts.all().filter(function(g) { return x(g.value); }).forEach(function(g) {
+  console.log(formatInteger(g.key) + ": " + new Array(x(g.value) + 1).join("▇"));
+});
+console.log("");
+// Simulates updating the display whenever the filters change.
+function updateDisplay() {
+  dates.all(); // update the date chart
+  days.all(); // update the day-of-week chart
+  hours.all(); // update the hour-of-day chart
+  amounts.all(); // update the amount histogram
+  all.value(); // update the summary totals
+  date.top(40); // update the payment list
+  ++k; // count frame rate
+}
+// Returns a function that returns random index in [0, distribution.length -
+// 1], based on the relative values in the specified distribution. Internally,
+// the distribution is converted to a normalized cumulative distribution in
+// [0, 1], and then a uniform random value is used with bisection.
+function randomIndex(distribution) {
+  var k = 1 / d3.sum(distribution), s = 0;
+  for (var i = 0, n = distribution.length; i < n; ++i) {
+    s = (distribution[i] = distribution[i] * k + s);
+  }
+  return function() {
+    return d3.bisectLeft(distribution, Math.random());
+  };
+}
+// Returns a function that returns random values with a log-normal
+// distribution, with the specified mean and deviation.
+function randomLogNormal(µ, σ) {
+  var random = d3.random.normal();
+  return function() {
+    return Math.exp(µ + σ * random());
+  };
+}
+// Returns a function that returns random dates, built on top of the specified
+// random day-of-week and hour-of-day generators. The minutes, seconds, and
+// milliseconds of the return dates are uniform random; as is the week of the
+// returned date, which is between now and some *weeks* ago.
+function randomRecentDate(randomDayOfWeek, randomHourOfDay, weeks) {
+  var now = Date.now();
+  return function() {
+    var d = d3.time.week.offset(new Date(), -Math.floor(Math.random() * weeks));
+    d.setDate(d.getDate() + randomDayOfWeek() - d.getDay());
+    d.setHours(randomHourOfDay(), Math.random() * 60, Math.random() * 60, Math.random() * 1000);
+    return d;
+  };
+}

data/vendor/assets/javascripts/tesseract/test/bisect-test.js ADDED

@@ -0,0 +1,206 @@
+var vows = require("vows"),
+    assert = require("assert"),
+    tesseract = require("../");
+var suite = vows.describe("bisect");
+suite.addBatch({
+  "bisect": {
+    topic: function() {
+      return tesseract.bisect;
+    },
+    "is the same as bisect.right": function(bisect) {
+      assert.strictEqual(bisect, bisect.right);
+    }
+  }
+});
+suite.addBatch({
+  "bisect.left": {
+    topic: function() {
+      return tesseract.bisect.left;
+    },
+    "finds the index of an exact match": function(bisect) {
+      var array = [1, 2, 3];
+      assert.equal(bisect(array, 1, 0, 3), 0);
+      assert.equal(bisect(array, 2, 0, 3), 1);
+      assert.equal(bisect(array, 3, 0, 3), 2);
+    },
+    "finds the index of the first match": function(bisect) {
+      var array = [1, 2, 2, 3];
+      assert.equal(bisect(array, 1, 0, 4), 0);
+      assert.equal(bisect(array, 2, 0, 4), 1);
+      assert.equal(bisect(array, 3, 0, 4), 3);
+    },
+    "finds the insertion point of a non-exact match": function(bisect) {
+      var array = [1, 2, 3];
+      assert.equal(bisect(array, 0.5, 0, 3), 0);
+      assert.equal(bisect(array, 1.5, 0, 3), 1);
+      assert.equal(bisect(array, 2.5, 0, 3), 2);
+      assert.equal(bisect(array, 3.5, 0, 3), 3);
+    },
+    "observes the lower bound": function(bisect) {
+      var array = [1, 2, 3, 4, 5];
+      assert.equal(bisect(array, 0, 2, 5), 2);
+      assert.equal(bisect(array, 1, 2, 5), 2);
+      assert.equal(bisect(array, 2, 2, 5), 2);
+      assert.equal(bisect(array, 3, 2, 5), 2);
+      assert.equal(bisect(array, 4, 2, 5), 3);
+      assert.equal(bisect(array, 5, 2, 5), 4);
+      assert.equal(bisect(array, 6, 2, 5), 5);
+    },
+    "observes the lower and upper bounds": function(bisect) {
+      var array = [1, 2, 3, 4, 5];
+      assert.equal(bisect(array, 0, 2, 3), 2);
+      assert.equal(bisect(array, 1, 2, 3), 2);
+      assert.equal(bisect(array, 2, 2, 3), 2);
+      assert.equal(bisect(array, 3, 2, 3), 2);
+      assert.equal(bisect(array, 4, 2, 3), 3);
+      assert.equal(bisect(array, 5, 2, 3), 3);
+      assert.equal(bisect(array, 6, 2, 3), 3);
+    }
+  }
+});
+suite.addBatch({
+  "bisect.by(value).left": {
+    topic: function() {
+      return tesseract.bisect.by(function(d) { return d.value; }).left;
+    },
+    "finds the index of an exact match": function(bisect) {
+      var array = [{value: 1}, {value: 2}, {value: 3}];
+      assert.equal(bisect(array, 1, 0, 3), 0);
+      assert.equal(bisect(array, 2, 0, 3), 1);
+      assert.equal(bisect(array, 3, 0, 3), 2);
+    },
+    "finds the index of the first match": function(bisect) {
+      var array = [{value: 1}, {value: 2}, {value: 2}, {value: 3}];
+      assert.equal(bisect(array, 1, 0, 4), 0);
+      assert.equal(bisect(array, 2, 0, 4), 1);
+      assert.equal(bisect(array, 3, 0, 4), 3);
+    },
+    "finds the insertion point of a non-exact match": function(bisect) {
+      var array = [{value: 1}, {value: 2}, {value: 3}];
+      assert.equal(bisect(array, 0.5, 0, 3), 0);
+      assert.equal(bisect(array, 1.5, 0, 3), 1);
+      assert.equal(bisect(array, 2.5, 0, 3), 2);
+      assert.equal(bisect(array, 3.5, 0, 3), 3);
+    },
+    "observes the lower bound": function(bisect) {
+      var array = [{value: 1}, {value: 2}, {value: 3}, {value: 4}, {value: 5}];
+      assert.equal(bisect(array, 0, 2, 5), 2);
+      assert.equal(bisect(array, 1, 2, 5), 2);
+      assert.equal(bisect(array, 2, 2, 5), 2);
+      assert.equal(bisect(array, 3, 2, 5), 2);
+      assert.equal(bisect(array, 4, 2, 5), 3);
+      assert.equal(bisect(array, 5, 2, 5), 4);
+      assert.equal(bisect(array, 6, 2, 5), 5);
+    },
+    "observes the lower and upper bounds": function(bisect) {
+      var array = [{value: 1}, {value: 2}, {value: 3}, {value: 4}, {value: 5}];
+      assert.equal(bisect(array, 0, 2, 3), 2);
+      assert.equal(bisect(array, 1, 2, 3), 2);
+      assert.equal(bisect(array, 2, 2, 3), 2);
+      assert.equal(bisect(array, 3, 2, 3), 2);
+      assert.equal(bisect(array, 4, 2, 3), 3);
+      assert.equal(bisect(array, 5, 2, 3), 3);
+      assert.equal(bisect(array, 6, 2, 3), 3);
+    }
+  }
+});
+suite.addBatch({
+  "bisect.right": {
+    topic: function() {
+      return tesseract.bisect.right;
+    },
+    "finds the index after an exact match": function(bisect) {
+      var array = [1, 2, 3];
+      assert.equal(bisect(array, 1, 0, 3), 1);
+      assert.equal(bisect(array, 2, 0, 3), 2);
+      assert.equal(bisect(array, 3, 0, 3), 3);
+    },
+    "finds the index after the last match": function(bisect) {
+      var array = [1, 2, 2, 3];
+      assert.equal(bisect(array, 1, 0, 4), 1);
+      assert.equal(bisect(array, 2, 0, 4), 3);
+      assert.equal(bisect(array, 3, 0, 4), 4);
+    },
+    "finds the insertion point of a non-exact match": function(bisect) {
+      var array = [1, 2, 3];
+      assert.equal(bisect(array, 0.5, 0, 3), 0);
+      assert.equal(bisect(array, 1.5, 0, 3), 1);
+      assert.equal(bisect(array, 2.5, 0, 3), 2);
+      assert.equal(bisect(array, 3.5, 0, 3), 3);
+    },
+    "observes the lower bound": function(bisect) {
+      var array = [1, 2, 3, 4, 5];
+      assert.equal(bisect(array, 0, 2, 5), 2);
+      assert.equal(bisect(array, 1, 2, 5), 2);
+      assert.equal(bisect(array, 2, 2, 5), 2);
+      assert.equal(bisect(array, 3, 2, 5), 3);
+      assert.equal(bisect(array, 4, 2, 5), 4);
+      assert.equal(bisect(array, 5, 2, 5), 5);
+      assert.equal(bisect(array, 6, 2, 5), 5);
+    },
+    "observes the lower and upper bounds": function(bisect) {
+      var array = [1, 2, 3, 4, 5];
+      assert.equal(bisect(array, 0, 2, 3), 2);
+      assert.equal(bisect(array, 1, 2, 3), 2);
+      assert.equal(bisect(array, 2, 2, 3), 2);
+      assert.equal(bisect(array, 3, 2, 3), 3);
+      assert.equal(bisect(array, 4, 2, 3), 3);
+      assert.equal(bisect(array, 5, 2, 3), 3);
+      assert.equal(bisect(array, 6, 2, 3), 3);
+    }
+  }
+});
+suite.addBatch({
+  "bisect.by(value).right": {
+    topic: function() {
+      return tesseract.bisect.by(function(d) { return d.value; }).right;
+    },
+    "finds the index after an exact match": function(bisect) {
+      var array = [{value: 1}, {value: 2}, {value: 3}];
+      assert.equal(bisect(array, 1, 0, 3), 1);
+      assert.equal(bisect(array, 2, 0, 3), 2);
+      assert.equal(bisect(array, 3, 0, 3), 3);
+    },
+    "finds the index after the last match": function(bisect) {
+      var array = [{value: 1}, {value: 2}, {value: 2}, {value: 3}];
+      assert.equal(bisect(array, 1, 0, 4), 1);
+      assert.equal(bisect(array, 2, 0, 4), 3);
+      assert.equal(bisect(array, 3, 0, 4), 4);
+    },
+    "finds the insertion point of a non-exact match": function(bisect) {
+      var array = [{value: 1}, {value: 2}, {value: 3}];
+      assert.equal(bisect(array, 0.5, 0, 3), 0);
+      assert.equal(bisect(array, 1.5, 0, 3), 1);
+      assert.equal(bisect(array, 2.5, 0, 3), 2);
+      assert.equal(bisect(array, 3.5, 0, 3), 3);
+    },
+    "observes the lower bound": function(bisect) {
+      var array = [{value: 1}, {value: 2}, {value: 3}, {value: 4}, {value: 5}];
+      assert.equal(bisect(array, 0, 2, 5), 2);
+      assert.equal(bisect(array, 1, 2, 5), 2);
+      assert.equal(bisect(array, 2, 2, 5), 2);
+      assert.equal(bisect(array, 3, 2, 5), 3);
+      assert.equal(bisect(array, 4, 2, 5), 4);
+      assert.equal(bisect(array, 5, 2, 5), 5);
+      assert.equal(bisect(array, 6, 2, 5), 5);
+    },
+    "observes the lower and upper bounds": function(bisect) {
+      var array = [{value: 1}, {value: 2}, {value: 3}, {value: 4}, {value: 5}];
+      assert.equal(bisect(array, 0, 2, 3), 2);
+      assert.equal(bisect(array, 1, 2, 3), 2);
+      assert.equal(bisect(array, 2, 2, 3), 2);
+      assert.equal(bisect(array, 3, 2, 3), 3);
+      assert.equal(bisect(array, 4, 2, 3), 3);
+      assert.equal(bisect(array, 5, 2, 3), 3);
+      assert.equal(bisect(array, 6, 2, 3), 3);
+    }
+  }
+});
+suite.export(module);

data/vendor/assets/javascripts/tesseract/test/heap-test.js ADDED

@@ -0,0 +1,44 @@
+var vows = require("vows"),
+    assert = require("assert"),
+    tesseract = require("../");
+var suite = vows.describe("heap");
+suite.addBatch({
+  "heap": {
+    topic: function() {
+      return tesseract.heap;
+    },
+    "children are greater than or equal to parents": function(heap) {
+      var array = [6, 5, 3, 1, 8, 7, 2, 4]
+          n = array.length;
+      assert.strictEqual(heap(array, 0, n), array);
+      assert.equal(array[0], 1);
+      for (var i = 1; i < n; ++i) assert(array[i] >= array[i - 1 >> 1]);
+    },
+    "creates a heap from a subset of the array": function(heap) {
+      var array = [6, 5, 3, 1, 8, 7, 2, 4]
+          n = 6;
+      assert.strictEqual(heap(array, 0, n), array);
+      assert.equal(array[0], 1);
+      for (var i = 1; i < n; ++i) assert(array[i] >= array[i - 1 >> 1]);
+    },
+    "sort": {
+      "sorts an existing heap in descending order": function(heap) {
+        var array = [1, 4, 2, 5, 8, 7, 3, 6],
+            n = array.length;
+        heap.sort(array, 0, n);
+        assert.deepEqual(array, [8, 7, 6, 5, 4, 3, 2, 1]);
+      },
+      "sorts a two-element heap in descending order": function(heap) {
+        var array = [1, 4],
+            n = array.length;
+        heap.sort(array, 0, n);
+        assert.deepEqual(array, [4, 1]);
+      }
+    }
+  }
+});
+suite.export(module);

data/vendor/assets/javascripts/tesseract/test/permute-test.js ADDED

@@ -0,0 +1,51 @@
+var vows = require("vows"),
+    assert = require("assert"),
+    tesseract = require("../");
+var suite = vows.describe("permute");
+suite.addBatch({
+  "permute": {
+    topic: function() {
+      return tesseract.permute;
+    },
+    "permutes according to the specified index": function(permute) {
+      assert.deepEqual(permute([3, 4, 5], [2, 1, 0]), [5, 4, 3]);
+      assert.deepEqual(permute([3, 4, 5], [2, 0, 1]), [5, 3, 4]);
+      assert.deepEqual(permute([3, 4, 5], [0, 1, 2]), [3, 4, 5]);
+    },
+    "does not modify the input array": function(permute) {
+      var input = [3, 4, 5];
+      permute(input, [2, 1, 0]);
+      assert.deepEqual(input, [3, 4, 5]);
+    },
+    "can duplicate input values": function(permute) {
+      assert.deepEqual(permute([3, 4, 5], [0, 1, 0]), [3, 4, 3]);
+      assert.deepEqual(permute([3, 4, 5], [2, 2, 2]), [5, 5, 5]);
+      assert.deepEqual(permute([3, 4, 5], [0, 1, 1]), [3, 4, 4]);
+    },
+    "can return more elements": function(permute) {
+      assert.deepEqual(permute([3, 4, 5], [0, 0, 1, 2]), [3, 3, 4, 5]);
+      assert.deepEqual(permute([3, 4, 5], [0, 1, 1, 1]), [3, 4, 4, 4]);
+    },
+    "can return fewer elements": function(permute) {
+      assert.deepEqual(permute([3, 4, 5], [0]), [3]);
+      assert.deepEqual(permute([3, 4, 5], [1, 2]), [4, 5]);
+      assert.deepEqual(permute([3, 4, 5], []), []);
+    },
+    "can return undefined elements": function(permute) {
+      var v1 = permute([3, 4, 5], [10]);
+      assert.equal(v1.length, 1);
+      assert.isUndefined(v1[0]);
+      var v2 = permute([3, 4, 5], [-1]);
+      assert.equal(v2.length, 1);
+      assert.isUndefined(v2[0]);
+      var v3 = permute([3, 4, 5], [0, -1]);
+      assert.equal(v3.length, 2);
+      assert.equal(v3[0], 3);
+      assert.isUndefined(v3[1]);
+    }
+  }
+});
+suite.export(module);