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

d3_rails 2.8.0 → 2.8.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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