picky-statistics 4.5.0 → 4.5.1

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

@@ -1,47 +0,0 @@
-require("../env");
-require("../../d3");
-
-var vows = require("vows"),
-    assert = require("assert");
-
-var suite = vows.describe("d3.descending");
-
-suite.addBatch({
-  "numbers": {
-    "returns a negative number if a > b": function() {
-      assert.isTrue(d3.descending(1, 0) < 0);
-    },
-    "returns a positive number if a < b": function() {
-      assert.isTrue(d3.descending(0, 1) > 0);
-    },
-    "returns zero if a == b": function() {
-      assert.equal(d3.descending(0, 0), 0);
-    },
-    "returns NaN if a or b is undefined": function() {
-      assert.isNaN(d3.descending(0, undefined));
-      assert.isNaN(d3.descending(undefined, 0));
-      assert.isNaN(d3.descending(undefined, undefined));
-    },
-    "returns NaN if a or b is NaN": function() {
-      assert.isNaN(d3.descending(0, NaN));
-      assert.isNaN(d3.descending(NaN, 0));
-      assert.isNaN(d3.descending(NaN, NaN));
-    }
-  }
-});
-
-suite.addBatch({
-  "strings": {
-    "returns a negative number if a > b": function() {
-      assert.isTrue(d3.descending("b", "a") < 0);
-    },
-    "returns a positive number if a < b": function() {
-      assert.isTrue(d3.descending("a", "b") > 0);
-    },
-    "returns zero if a == b": function() {
-      assert.equal(d3.descending("a", "a"), 0);
-    }
-  }
-});
-
-suite.export(module);

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

@@ -1,129 +0,0 @@
-require("../env");
-require("../../d3");
-
-var vows = require("vows"),
-    assert = require("assert");
-
-var suite = vows.describe("d3.dispatch");
-
-suite.addBatch({
-  "dispatch": {
-    topic: function() {
-      return d3.dispatch;
-    },
-    "returns a map of dispatchers for each event type": function(dispatch) {
-      assert.deepEqual(dispatch(), {});
-      var d = dispatch("foo");
-      assert.isTrue("foo" in d);
-      assert.isFalse("bar" in d);
-      var d = dispatch("foo", "bar");
-      assert.isTrue("foo" in d);
-      assert.isTrue("bar" in d);
-    },
-    "added listeners receive subsequent events": function(dispatch) {
-      var d = dispatch("foo"), events = 0;
-      d.on("foo", function() { ++events; });
-      d.foo();
-      assert.equal(events, 1);
-      d.foo();
-      d.foo();
-      assert.equal(events, 3);
-    },
-    "the listener is passed any arguments to dispatch": function(dispatch) {
-      var d = dispatch("foo"), a = {}, b = {}, aa, bb;
-      d.on("foo", function(a, b) { aa = a; bb = b; });
-      d.foo(a, b);
-      assert.equal(aa, a);
-      assert.equal(bb, b);
-      d.foo(1, "foo");
-      assert.equal(aa, 1);
-      assert.equal(bb, "foo");
-    },
-    "the listener's context is the same as dispatch's": function(dispatch) {
-      var d = dispatch("foo"), a = {}, b = {}, that;
-      d.on("foo", function() { that = this; });
-      d.foo.call(a);
-      assert.equal(that, a);
-      d.foo.call(b);
-      assert.equal(that, b);
-    },
-    "listeners are notified in the order they are added": function(dispatch) {
-      var d = dispatch("foo"), a = {}, b = {}, those = [];
-      function A() { those.push(a); }
-      function B() { those.push(b); }
-      d.on("foo.a", A).on("foo.b", B);
-      d.foo();
-      assert.deepEqual(those, [a, b]);
-      those = [];
-      d.on("foo.a", A); // move to the end
-      d.foo();
-      assert.deepEqual(those, [b, a]);
-    },
-    "removed listeners do not receive subsequent events": function(dispatch) {
-      var d = dispatch("foo"), a = {}, b = {}, those = [];
-      function A() { those.push(a); }
-      function B() { those.push(b); }
-      d.on("foo.a", A).on("foo.b", B);
-      d.foo();
-      those = [];
-      d.on("foo.a", null);
-      d.foo();
-      assert.deepEqual(those, [b]);
-    },
-    "removing a shared listener only affects the intended event": function(dispatch) {
-      var d = dispatch("foo", "bar"), a = 0;
-      function A() { ++a; }
-      d.on("foo", A).on("bar", A);
-      d.foo();
-      d.bar();
-      assert.equal(a, 2);
-      d.on("foo", null);
-      d.bar();
-      assert.equal(a, 3);
-    },
-    "adding an existing listener has no effect": function(dispatch) {
-      var d = dispatch("foo"), events = 0;
-      function A() { ++events; }
-      d.on("foo.a", A);
-      d.foo();
-      d.on("foo.a", A).on("foo.a", A);
-      d.foo();
-      assert.equal(events, 2);
-    },
-    "removing a missing listener has no effect": function(dispatch) {
-      var d = dispatch("foo"), events = 0;
-      function A() { ++events; }
-      d.on("foo.a", null).on("foo", A).on("foo", null).on("foo", null);
-      d.foo();
-      assert.equal(events, 0);
-    },
-    "adding a listener does not affect the current event": function(dispatch) {
-      var d = dispatch("foo"), a = {}, b = {}, those = [];
-      function A() { d.on("foo.b", B); those.push(a); }
-      function B() { those.push(b); }
-      d.on("foo.a", A);
-      d.foo();
-      assert.deepEqual(those, [a]);
-    },
-    "removing a listener does affect the current event": function(dispatch) {
-      var d = dispatch("foo"), a = {}, b = {}, those = [];
-      function A() { d.on("foo.b", null); those.push(a); }
-      function B() { those.push(b); }
-      d.on("foo.a", A).on("foo.b", B);
-      d.foo();
-      assert.deepEqual(those, [a]);
-    },
-    "getting a listener returns the correct listener": function(dispatch) {
-      var d = dispatch("foo");
-      function A() {}
-      function B() {}
-      function C() {}
-      d.on("foo.a", A).on("foo.b", B).on("foo", C);
-      assert.equal(d.on("foo.a"), A);
-      assert.equal(d.on("foo.b"), B);
-      assert.equal(d.on("foo"), C);
-    }
-  }
-});
-
-suite.export(module);

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

@@ -1,129 +0,0 @@
-require("../env");
-require("../../d3");
-
-var vows = require("vows"),
-    assert = require("assert");
-
-var suite = vows.describe("d3.ease");
-
-suite.addBatch({
-  "ease": {
-    topic: function() {
-      return d3.ease;
-    },
-    "supports linear easing": function(ease) {
-      var e = ease("linear");
-      assert.inDelta(e(.5), .5, 1e-6);
-    },
-    "supports polynomial easing": function(ease) {
-      var e = ease("poly", 2);
-      assert.inDelta(e(.5), .25, 1e-6);
-    },
-    "supports quadratic easing": function(ease) {
-      var e = ease("quad");
-      assert.inDelta(e(.5), .25, 1e-6);
-    },
-    "supports cubic easing": function(ease) {
-      var e = ease("cubic");
-      assert.inDelta(e(.5), .125, 1e-6);
-    },
-    "supports sinusoidal easing": function(ease) {
-      var e = ease("sin");
-      assert.inDelta(e(.5), 1 - Math.cos(Math.PI / 4), 1e-6);
-    },
-    "supports exponential easing": function(ease) {
-      var e = ease("exp");
-      assert.inDelta(e(.5), 0.03125, 1e-6);
-    },
-    "supports circular easing": function(ease) {
-      var e = ease("circle");
-      assert.inDelta(e(.5), 0.133975, 1e-6);
-    },
-    "supports elastic easing": function(ease) {
-      var e = ease("elastic");
-      assert.inDelta(e(.5), 0.976061, 1e-6);
-    },
-    "supports back easing": function(ease) {
-      var e = ease("back");
-      assert.inDelta(e(.5), -0.0876975, 1e-6);
-    },
-    "supports bounce easing": function(ease) {
-      var e = ease("bounce");
-      assert.inDelta(e(.5), 0.765625, 1e-6);
-    },
-    "all easing functions return exactly 0 for t = 0": function(ease) {
-      assert.equal(ease("linear")(0), 0);
-      assert.equal(ease("poly", 2)(0), 0);
-      assert.equal(ease("quad")(0), 0);
-      assert.equal(ease("cubic")(0), 0);
-      assert.equal(ease("sin")(0), 0);
-      assert.equal(ease("exp")(0), 0);
-      assert.equal(ease("circle")(0), 0);
-      assert.equal(ease("elastic")(0), 0);
-      assert.equal(ease("back")(0), 0);
-      assert.equal(ease("bounce")(0), 0);
-    },
-    "all easing functions return exactly 1 for t = 1": function(ease) {
-      assert.equal(ease("linear")(1), 1);
-      assert.equal(ease("poly", 2)(1), 1);
-      assert.equal(ease("quad")(1), 1);
-      assert.equal(ease("cubic")(1), 1);
-      assert.equal(ease("sin")(1), 1);
-      assert.equal(ease("exp")(1), 1);
-      assert.equal(ease("circle")(1), 1);
-      assert.equal(ease("elastic")(1), 1);
-      assert.equal(ease("back")(1), 1);
-      assert.equal(ease("bounce")(1), 1);
-    },
-    "the -in suffix returns the identity": function(ease) {
-      assert.inDelta(ease("linear-in")(.25), ease("linear")(.25), 1e-6);
-      assert.inDelta(ease("quad-in")(.75), ease("quad")(.75), 1e-6);
-    },
-    "the -out suffix returns the reverse": function(ease) {
-      assert.inDelta(ease("sin-out")(.25), 1 - ease("sin-in")(.75), 1e-6);
-      assert.inDelta(ease("bounce-out")(.25), 1 - ease("bounce-in")(.75), 1e-6);
-      assert.inDelta(ease("elastic-out")(.25), 1 - ease("elastic-in")(.75), 1e-6);
-    },
-    "the -in-out suffix returns the reflection": function(ease) {
-      assert.inDelta(ease("sin-in-out")(.25), .5 * ease("sin-in")(.5), 1e-6);
-      assert.inDelta(ease("bounce-in-out")(.25), .5 * ease("bounce-in")(.5), 1e-6);
-      assert.inDelta(ease("elastic-in-out")(.25), .5 * ease("elastic-in")(.5), 1e-6);
-    },
-    "the -out-in suffix returns the reverse reflection": function(ease) {
-      assert.inDelta(ease("sin-out-in")(.25), .5 * ease("sin-out")(.5), 1e-6);
-      assert.inDelta(ease("bounce-out-in")(.25), .5 * ease("bounce-out")(.5), 1e-6);
-      assert.inDelta(ease("elastic-out-in")(.25), .5 * ease("elastic-out")(.5), 1e-6);
-    },
-    "clamps input time": function(ease) {
-      var e = ease("linear");
-      assert.inDelta(e(-1), 0, 1e-6);
-      assert.inDelta(e(2), 1, 1e-6);
-    },
-    "poly": {
-      "supports an optional polynomial": function(ease) {
-        var e = ease("poly", 1);
-        assert.inDelta(e(.5), .5, 1e-6);
-        var e = ease("poly", .5);
-        assert.inDelta(e(.5), Math.SQRT1_2, 1e-6);
-      }
-    },
-    "elastic": {
-      "supports an optional amplifier (>1)": function(ease) {
-        var e = ease("elastic", 1.5);
-        assert.inDelta(e(.5), 0.998519, 1e-6);
-      },
-      "supports an optional amplifier (>1) and period (>0)": function(ease) {
-        var e = ease("elastic", 1.5, .5);
-        assert.inDelta(e(.5), 0.96875, 1e-6);
-      }
-    },
-    "back": {
-      "supports an optional speed": function(ease) {
-        var e = ease("back", 2);
-        assert.inDelta(e(.5), -0.125, 1e-6);
-      }
-    }
-  }
-});
-
-suite.export(module);

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

@@ -1,43 +0,0 @@
-require("../env");
-require("../../d3");
-
-var vows = require("vows"),
-    assert = require("assert");
-
-var suite = vows.describe("d3.entries");
-
-suite.addBatch({
-  "entries": {
-    topic: function() {
-      return d3.entries;
-    },
-    "enumerates every entry": function(entries) {
-      assert.deepEqual(entries({a: 1, b: 2}), [
-        {key: "a", value: 1},
-        {key: "b", value: 2}
-      ]);
-    },
-    "includes entries defined on prototypes": function(entries) {
-      function abc() {
-        this.a = 1;
-        this.b = 2;
-      }
-      abc.prototype.c = 3;
-      assert.deepEqual(entries(new abc()), [
-        {key: "a", value: 1},
-        {key: "b", value: 2},
-        {key: "c", value: 3}
-      ]);
-    },
-    "includes null or undefined values": function(entries) {
-      var v = entries({a: undefined, b: null, c: NaN});
-      assert.equal(v.length, 3);
-      assert.deepEqual(v[0], {key: "a", value: undefined});
-      assert.deepEqual(v[1], {key: "b", value: null});
-      assert.equal(v[2].key, "c");
-      assert.isNaN(v[2].value);
-    }
-  }
-});
-
-suite.export(module);

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

@@ -1,51 +0,0 @@
-require("../env");
-require("../../d3");
-
-var vows = require("vows"),
-    assert = require("assert");
-
-var suite = vows.describe("d3.extent");
-
-suite.addBatch({
-  "extent": {
-    topic: function() {
-      return d3.extent;
-    },
-    "returns the numeric extent for numbers": function(extent) {
-      assert.deepEqual(extent([1]), [1, 1]);
-      assert.deepEqual(extent([5, 1, 2, 3, 4]), [1, 5]);
-      assert.deepEqual(extent([20, 3]), [3, 20]);
-      assert.deepEqual(extent([3, 20]), [3, 20]);
-    },
-    "returns the lexicographic extent for strings": function(extent) {
-      assert.deepEqual(extent(["c", "a", "b"]), ["a", "c"]);
-      assert.deepEqual(extent(["20", "3"]), ["20", "3"]);
-      assert.deepEqual(extent(["3", "20"]), ["20", "3"]);
-    },
-    "ignores null, undefined and NaN": function(extent) {
-      assert.deepEqual(extent([NaN, 1, 2, 3, 4, 5]), [1, 5]);
-      assert.deepEqual(extent([1, 2, 3, 4, 5, NaN]), [1, 5]);
-      assert.deepEqual(extent([10, null, 3, undefined, 5, NaN]), [3, 10]);
-      assert.deepEqual(extent([-1, null, -3, undefined, -5, NaN]), [-5, -1]);
-    },
-    "compares heterogenous types as numbers": function(extent) {
-      assert.deepEqual(extent([20, "3"]), ["3", 20]);
-      assert.deepEqual(extent(["20", 3]), [3, "20"]);
-      assert.deepEqual(extent([3, "20"]), [3, "20"]);
-      assert.deepEqual(extent(["3", 20]), ["3", 20]);
-    },
-    "returns undefined for empty array": function(extent) {
-      assert.deepEqual(extent([]), [undefined, undefined]);
-      assert.deepEqual(extent([null]), [undefined, undefined]);
-      assert.deepEqual(extent([undefined]), [undefined, undefined]);
-      assert.deepEqual(extent([NaN]), [undefined, undefined]);
-      assert.deepEqual(extent([NaN, NaN]), [undefined, undefined]);
-    },
-    "applies the optional accessor function exactly once": function(extent) {
-      var i = 10;
-      assert.deepEqual(d3.extent([0,1,2,3], function() { return ++i; }), [11, 14]);
-    }
-  }
-});
-
-suite.export(module);

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

@@ -1,42 +0,0 @@
-require("../env");
-require("../../d3");
-
-var vows = require("vows"),
-    assert = require("assert");
-
-var suite = vows.describe("d3.first");
-
-suite.addBatch({
-  "first": {
-    topic: function() {
-      return d3.first;
-    },
-    "compares using natural order by default": function(first) {
-      assert.strictEqual(first([1, 0]), 0);
-      assert.strictEqual(first(["1", 0]), 0);
-      assert.strictEqual(first(["2", "10"]), "10");
-      assert.strictEqual(first(["2", NaN, "10"]), "10");
-      assert.strictEqual(first([2, NaN, 10]), 2);
-    },
-    "compares using optional comparator": function(first) {
-      var i = 0, aa, bb, o = new Object();
-      assert.strictEqual(first([1, o], function(a, b) { aa = a; bb = b; return ++i; }), o);
-      assert.strictEqual(aa, 1);
-      assert.strictEqual(bb, o);
-      assert.strictEqual(first([1, 0], d3.descending), 1);
-      assert.strictEqual(first(["1", 0], d3.descending), "1");
-      assert.strictEqual(first(["2", "10"], d3.descending), "2");
-      assert.strictEqual(first(["2", NaN, "10"], d3.descending), "2");
-      assert.strictEqual(first([2, NaN, 10], d3.descending), 10);
-    },
-    "returns the first of equal values": function(last) {
-      var a = new Object(), b = new Object(), c = new Object();
-      assert.strictEqual(last([a, b, c], function() { return 0; }), a);
-    },
-    "returns undefined for an empty array": function(first) {
-      assert.isUndefined(first([]));
-    }
-  }
-});
-
-suite.export(module);