picky-statistics 4.0.0pre3 → 4.0.0pre5

data/lib/picky-statistics/application/javascripts/d3/test/core/median-test.js

@@ -0,0 +1,43 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.median");
+
+suite.addBatch({
+  "median": {
+    topic: function() {
+      return d3.median;
+    },
+    "returns the median value for numbers": function(median) {
+      assert.equal(median([1]), 1);
+      assert.equal(median([5, 1, 2, 3, 4]), 3);
+      assert.equal(median([20, 3]), 11.5);
+      assert.equal(median([3, 20]), 11.5);
+    },
+    "ignores null, undefined and NaN": function(median) {
+      assert.equal(median([NaN, 1, 2, 3, 4, 5]), 3);
+      assert.equal(median([1, 2, 3, 4, 5, NaN]), 3);
+      assert.equal(median([10, null, 3, undefined, 5, NaN]), 5);
+    },
+    "can handle large numbers without overflowing": function(median) {
+      assert.equal(median([Number.MAX_VALUE, Number.MAX_VALUE]), Number.MAX_VALUE);
+      assert.equal(median([-Number.MAX_VALUE, -Number.MAX_VALUE]), -Number.MAX_VALUE);
+    },
+    "returns undefined for empty array": function(median) {
+      assert.isUndefined(median([]));
+      assert.isUndefined(median([null]));
+      assert.isUndefined(median([undefined]));
+      assert.isUndefined(median([NaN]));
+      assert.isUndefined(median([NaN, NaN]));
+    },
+    "applies the optional accessor function": function(median) {
+      assert.equal(d3.median([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.median(d); }), 4.5);
+      assert.equal(d3.median([1, 2, 3, 4, 5], function(d, i) { return i; }), 2);
+    }
+  }
+});
+
+suite.export(module);

data/lib/picky-statistics/application/javascripts/d3/test/core/merge-test.js

@@ -0,0 +1,27 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.merge");
+
+suite.addBatch({
+  "merge": {
+    "merges an array of arrays": function() {
+      var a = {}, b = {}, c = {}, d = {}, e = {}, f = {};
+      assert.deepEqual(d3.merge([[a], [b, c], [d, e, f]]), [a, b, c, d, e, f]);
+    },
+    "returns a new array": function() {
+      var input = [[1, 2, 3], [4, 5], [6]];
+      assert.isFalse(d3.merge(input) === input);
+    },
+    "does not modify the input arrays": function() {
+      var input = [[1, 2, 3], [4, 5], [6]];
+      d3.merge(input);
+      assert.deepEqual(input, [[1, 2, 3], [4, 5], [6]]);
+    }
+  }
+});
+
+suite.export(module);

data/lib/picky-statistics/application/javascripts/d3/test/core/min-test.js

@@ -0,0 +1,50 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.min");
+
+suite.addBatch({
+  "min": {
+    topic: function() {
+      return d3.min;
+    },
+    "returns the least numeric value for numbers": function(min) {
+      assert.equal(min([1]), 1);
+      assert.equal(min([5, 1, 2, 3, 4]), 1);
+      assert.equal(min([20, 3]), 3);
+      assert.equal(min([3, 20]), 3);
+    },
+    "returns the least lexicographic value for strings": function(min) {
+      assert.equal(min(["c", "a", "b"]), "a");
+      assert.equal(min(["20", "3"]), "20");
+      assert.equal(min(["3", "20"]), "20");
+    },
+    "ignores null, undefined and NaN": function(min) {
+      assert.equal(min([NaN, 1, 2, 3, 4, 5]), 1);
+      assert.equal(min([1, 2, 3, 4, 5, NaN]), 1);
+      assert.equal(min([10, null, 3, undefined, 5, NaN]), 3);
+    },
+    "compares heterogenous types as numbers": function(min) {
+      assert.strictEqual(min([20, "3"]), "3");
+      assert.strictEqual(min(["20", 3]), 3);
+      assert.strictEqual(min([3, "20"]), 3);
+      assert.strictEqual(min(["3", 20]), "3");
+    },
+    "returns undefined for empty array": function(min) {
+      assert.isUndefined(min([]));
+      assert.isUndefined(min([null]));
+      assert.isUndefined(min([undefined]));
+      assert.isUndefined(min([NaN]));
+      assert.isUndefined(min([NaN, NaN]));
+    },
+    "applies the optional accessor function": function(min) {
+      assert.equal(d3.min([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.max(d); }), 5);
+      assert.equal(d3.min([1, 2, 3, 4, 5], function(d, i) { return i; }), 0);
+    }
+  }
+});
+
+suite.export(module);

data/lib/picky-statistics/application/javascripts/d3/test/core/nest-test.js

@@ -0,0 +1,236 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.nest");
+
+suite.addBatch({
+  "entries": {
+    topic: function() {
+      return d3.nest;
+    },
+    "returns an array of each distinct key in arbitrary order": function(nest) {
+      var keys = nest()
+          .key(function(d) { return d.foo; })
+          .entries([{foo: 1}, {foo: 1}, {foo: 2}])
+          .map(function(d) { return d.key; })
+          .sort(d3.ascending);
+      assert.deepEqual(keys, ["1", "2"]);
+    },
+    "each entry is a key-values object, with values in input order": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d.foo; })
+          .entries([{foo: 1, bar: 0}, {foo: 2}, {foo: 1, bar: 1}]);
+      assert.deepEqual(entries, [
+        {key: "1", values: [{foo: 1, bar: 0}, {foo: 1, bar: 1}]},
+        {key: "2", values: [{foo: 2}]}
+      ]);
+    },
+    "keys can be sorted using an optional comparator": function(nest) {
+      var keys = nest()
+          .key(function(d) { return d.foo; }).sortKeys(d3.descending)
+          .entries([{foo: 1}, {foo: 1}, {foo: 2}])
+          .map(function(d) { return d.key; });
+      assert.deepEqual(keys, ["2", "1"]);
+    },
+    "values can be sorted using an optional comparator": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d.foo; })
+          .sortValues(function(a, b) { return a.bar - b.bar; })
+          .entries([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
+      assert.deepEqual(entries, [
+        {key: "1", values: [{foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 1, bar: 2}]},
+        {key: "2", values: [{foo: 2}]}
+      ]);
+    },
+    "values can be aggregated using an optional rollup": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d.foo; })
+          .rollup(function(values) { return d3.sum(values, function(d) { return d.bar; }); })
+          .entries([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
+      assert.deepEqual(entries, [
+        {key: "1", values: 3},
+        {key: "2", values: 0}
+      ]);
+    },
+    "multiple key functions can be specified": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d[0]; }).sortKeys(d3.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(d3.ascending)
+          .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(entries, [
+        {key: "0", values: [
+          {key: "1", values: [[0, 1]]},
+          {key: "2", values: [[0, 2], [0, 2]]}
+        ]},
+        {key: "1", values: [
+          {key: "1", values: [[1, 1]]},
+          {key: "2", values: [[1, 2]]}
+        ]}
+      ]);
+    },
+    "the rollup function only applies to leaf values": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d[0]; }).sortKeys(d3.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(d3.ascending)
+          .rollup(function(values) { return values.length; })
+          .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(entries, [
+        {key: "0", values: [
+          {key: "1", values: 1},
+          {key: "2", values: 2}
+        ]},
+        {key: "1", values: [
+          {key: "1", values: 1},
+          {key: "2", values: 1}
+        ]}
+      ]);
+    },
+    "the value comparator only applies to leaf values": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d[0]; }).sortKeys(d3.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(d3.ascending)
+          .sortValues(function(a, b) { return a[2] - b[2]; })
+          .entries([[0, 1], [0, 2, 1], [1, 1], [1, 2], [0, 2, 0]]);
+      assert.deepEqual(entries, [
+        {key: "0", values: [
+          {key: "1", values: [[0, 1]]},
+          {key: "2", values: [[0, 2, 0], [0, 2, 1]]}
+        ]},
+        {key: "1", values: [
+          {key: "1", values: [[1, 1]]},
+          {key: "2", values: [[1, 2]]}
+        ]}
+      ]);
+    },
+    "the key comparator only applies to the last-specified key": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d[0]; }).sortKeys(d3.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(d3.descending)
+          .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(entries, [
+        {key: "0", values: [
+          {key: "2", values: [[0, 2], [0, 2]]},
+          {key: "1", values: [[0, 1]]}
+        ]},
+        {key: "1", values: [
+          {key: "2", values: [[1, 2]]},
+          {key: "1", values: [[1, 1]]}
+        ]}
+      ]);
+      var entries = nest()
+          .key(function(d) { return d[0]; }).sortKeys(d3.descending)
+          .key(function(d) { return d[1]; }).sortKeys(d3.ascending)
+          .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(entries, [
+        {key: "1", values: [
+          {key: "1", values: [[1, 1]]},
+          {key: "2", values: [[1, 2]]}
+        ]},
+        {key: "0", values: [
+          {key: "1", values: [[0, 1]]},
+          {key: "2", values: [[0, 2], [0, 2]]}
+        ]}
+      ]);
+    },
+    "if no keys are specified, the input array is returned": function(nest) {
+      var array = [new Object()];
+      assert.strictEqual(nest().entries(array), array);
+    }
+  }
+});
+
+suite.addBatch({
+  "map": {
+    topic: function() {
+      return d3.nest;
+    },
+    "returns a map of each distinct key": function(nest) {
+      var map = nest()
+          .key(function(d) { return d.foo; })
+          .map([{foo: 1, bar: 0}, {foo: 2}, {foo: 1, bar: 1}]);
+      assert.deepEqual(map, {
+        "1": [{foo: 1, bar: 0}, {foo: 1, bar: 1}],
+        "2": [{foo: 2}]
+      });
+    },
+    "values can be sorted using an optional comparator": function(nest) {
+      var map = nest()
+          .key(function(d) { return d.foo; })
+          .sortValues(function(a, b) { return a.bar - b.bar; })
+          .map([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
+      assert.deepEqual(map, {
+        "1": [{foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 1, bar: 2}],
+        "2": [{foo: 2}]
+      });
+    },
+    "values can be aggregated using an optional rollup": function(nest) {
+      var map = nest()
+          .key(function(d) { return d.foo; })
+          .rollup(function(values) { return d3.sum(values, function(d) { return d.bar; }); })
+          .map([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
+      assert.deepEqual(map, {
+        "1": 3,
+        "2": 0
+      });
+    },
+    "multiple key functions can be specified": function(nest) {
+      var map = nest()
+          .key(function(d) { return d[0]; }).sortKeys(d3.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(d3.ascending)
+          .map([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(map, {
+        "0": {
+          "1": [[0, 1]],
+          "2": [[0, 2], [0, 2]]
+        },
+        "1": {
+          "1": [[1, 1]],
+          "2": [[1, 2]]
+        }
+      });
+    },
+    "the rollup function only applies to leaf values": function(nest) {
+      var map = nest()
+          .key(function(d) { return d[0]; }).sortKeys(d3.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(d3.ascending)
+          .rollup(function(values) { return values.length; })
+          .map([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(map, {
+        "0": {
+          "1": 1,
+          "2": 2
+        },
+        "1": {
+          "1": 1,
+          "2": 1
+        }
+      });
+    },
+    "the value comparator only applies to leaf values": function(nest) {
+      var map = nest()
+          .key(function(d) { return d[0]; }).sortKeys(d3.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(d3.ascending)
+          .sortValues(function(a, b) { return a[2] - b[2]; })
+          .map([[0, 1], [0, 2, 1], [1, 1], [1, 2], [0, 2, 0]]);
+      assert.deepEqual(map, {
+        "0": {
+          "1": [[0, 1]],
+          "2": [[0, 2, 0], [0, 2, 1]]
+        },
+        "1": {
+          "1": [[1, 1]],
+          "2": [[1, 2]]
+        }
+      });
+    },
+    "if no keys are specified, the input array is returned": function(nest) {
+      var array = [new Object()];
+      assert.strictEqual(nest().map(array), array);
+    }
+  }
+});
+
+suite.export(module);

data/lib/picky-statistics/application/javascripts/d3/test/core/ns-test.js

@@ -0,0 +1,58 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("ns");
+
+suite.addBatch({
+  "prefix": {
+    topic: function() {
+      return d3.ns.prefix;
+    },
+    "svg is http://www.w3.org/2000/svg": function(prefix) {
+      assert.equal(prefix.svg, "http://www.w3.org/2000/svg");
+    },
+    "xhtml is http://www.w3.org/1999/xhtml": function(prefix) {
+      assert.equal(prefix.xhtml, "http://www.w3.org/1999/xhtml");
+    },
+    "xlink is http://www.w3.org/1999/xlink": function(prefix) {
+      assert.equal(prefix.xlink, "http://www.w3.org/1999/xlink");
+    },
+    "xml is http://www.w3.org/XML/1998/namespace": function(prefix) {
+      assert.equal(prefix.xml, "http://www.w3.org/XML/1998/namespace");
+    },
+    "xmlns is http://www.w3.org/2000/xmlns/": function(prefix) {
+      assert.equal(prefix.xmlns, "http://www.w3.org/2000/xmlns/");
+    }
+  }
+});
+
+suite.addBatch({
+  "qualify": {
+    topic: function() {
+      return d3.ns.qualify;
+    },
+    "local name returns name": function() {
+      assert.equal(d3.ns.qualify("local"), "local");
+    },
+    "known qualified name returns space and local": function() {
+      var name = d3.ns.qualify("svg:path");
+      assert.equal(name.space, "http://www.w3.org/2000/svg");
+      assert.equal(name.local, "path");
+    },
+    "unknown qualified name returns undefined and local": function() {
+      var name = d3.ns.qualify("foo:bar");
+      assert.isUndefined(name.space);
+      assert.equal(name.local, "bar");
+    },
+    "known local name returns space and local": function() {
+      var name = d3.ns.qualify("svg");
+      assert.equal(name.space, "http://www.w3.org/2000/svg");
+      assert.equal(name.local, "svg");
+    }
+  }
+});
+
+suite.export(module);

data/lib/picky-statistics/application/javascripts/d3/test/core/permute-test.js

@@ -0,0 +1,53 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.permute");
+
+suite.addBatch({
+  "permute": {
+    topic: function() {
+      return d3.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);