stripmem 0.0.1

data/lib/stripmem/public/components/d3/test/scale/ordinal-test.js

@@ -0,0 +1,272 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.scale.ordinal");
+
+suite.addBatch({
+  "ordinal": {
+    topic: load("scale/ordinal").expression("d3.scale.ordinal"),
+
+    "domain": {
+      "defaults to the empty array": function(ordinal) {
+        assert.isEmpty(ordinal().domain());
+      },
+      "new input values are added to the domain": function(ordinal) {
+        var x = ordinal().range(["foo", "bar"]);
+        assert.equal(x(0), "foo");
+        assert.deepEqual(x.domain(), ["0"]);
+        assert.equal(x(1), "bar");
+        assert.deepEqual(x.domain(), ["0", "1"]);
+        assert.equal(x(0), "foo");
+        assert.deepEqual(x.domain(), ["0", "1"]);
+      },
+      "setting the domain forgets previous values": function(ordinal) {
+        var x = ordinal().range(["foo", "bar"]);
+        assert.equal(x(1), "foo");
+        assert.equal(x(0), "bar");
+        assert.deepEqual(x.domain(), [1, 0]);
+        x.domain(["0", "1"]);
+        assert.equal(x(0), "foo"); // it changed!
+        assert.equal(x(1), "bar");
+        assert.deepEqual(x.domain(), ["0", "1"]);
+      },
+      "uniqueness is based on string coercion": function(ordinal) {
+        var x = ordinal().domain(["foo"]).range([42, 43, 44]);
+        assert.equal(x(new String("foo")), 42);
+        assert.equal(x({toString: function() { return "foo"; }}), 42);
+        assert.equal(x({toString: function() { return "bar"; }}), 43);
+      },
+      "orders domain values by the order in which they are seen": function(ordinal) {
+        var x = ordinal();
+        x("foo");
+        x("bar");
+        x("baz");
+        assert.deepEqual(x.domain(), ["foo", "bar", "baz"]);
+        x.domain(["baz", "bar"]);
+        x("foo");
+        assert.deepEqual(x.domain(), ["baz", "bar", "foo"]);
+        x.domain(["baz", "foo"]);
+        assert.deepEqual(x.domain(), ["baz", "foo"]);
+        x.domain([]);
+        x("foo");
+        x("bar");
+        assert.deepEqual(x.domain(), ["foo", "bar"]);
+      },
+      "does not coerce domain values to strings": function(ordinal) {
+        var x = ordinal().domain([0, 1]);
+        assert.deepEqual(x.domain(), [0, 1]);
+        assert.typeOf(x.domain()[0], "number");
+        assert.typeOf(x.domain()[1], "number");
+      },
+      "does not barf on object built-ins": function(ordinal) {
+        var x = ordinal().domain(["__proto__", "hasOwnProperty"]).range([42, 43]);
+        assert.equal(x("__proto__"), 42);
+        assert.equal(x("hasOwnProperty"), 43);
+        assert.deepEqual(x.domain(), ["__proto__", "hasOwnProperty"]);
+      }
+    },
+
+    "range": {
+      "defaults to the empty array": function(ordinal) {
+        var x = ordinal();
+        assert.isEmpty(x.range());
+        assert.isUndefined(x(0));
+      },
+      "setting the range remembers previous values": function(ordinal) {
+        var x = ordinal();
+        assert.isUndefined(x(0));
+        assert.isUndefined(x(1));
+        x.range(["foo", "bar"]);
+        assert.equal(x(0), "foo");
+        assert.equal(x(1), "bar");
+      },
+      "recycles values when exhausted": function(ordinal) {
+        var x = ordinal().range(["a", "b", "c"]);
+        assert.equal(x(0), "a");
+        assert.equal(x(1), "b");
+        assert.equal(x(2), "c");
+        assert.equal(x(3), "a");
+        assert.equal(x(4), "b");
+        assert.equal(x(5), "c");
+        assert.equal(x(2), "c");
+        assert.equal(x(1), "b");
+        assert.equal(x(0), "a");
+      }
+    },
+
+    "maps distinct values to discrete values": function(ordinal) {
+      var x = ordinal().range(["a", "b", "c"]);
+      assert.equal(x(0), "a");
+      assert.equal(x("0"), "a");
+      assert.equal(x([0]), "a");
+      assert.equal(x(1), "b");
+      assert.equal(x(2.0), "c");
+      assert.equal(x(new Number(2)), "c");
+    },
+
+    "rangePoints": {
+      "computes discrete points in a continuous range": function(ordinal) {
+        var x = ordinal().domain(["a", "b", "c"]).rangePoints([0, 120]);
+        assert.deepEqual(x.range(), [0, 60, 120]);
+        var x = ordinal().domain(["a", "b", "c"]).rangePoints([0, 120], 1);
+        assert.deepEqual(x.range(), [20, 60, 100]);
+        var x = ordinal().domain(["a", "b", "c"]).rangePoints([0, 120], 2);
+        assert.deepEqual(x.range(), [30, 60, 90]);
+      },
+      "correctly handles singleton domains": function(ordinal) {
+        var x = ordinal().domain(["a"]).rangePoints([0, 120]);
+        assert.deepEqual(x.range(), [60]);
+      },
+      "can be set to a descending range": function(ordinal) {
+        var x = ordinal().domain(["a", "b", "c"]).rangePoints([120, 0]);
+        assert.deepEqual(x.range(), [120, 60,0]);
+        var x = ordinal().domain(["a", "b", "c"]).rangePoints([120, 0], 1);
+        assert.deepEqual(x.range(), [100, 60, 20]);
+        var x = ordinal().domain(["a", "b", "c"]).rangePoints([120, 0], 2);
+        assert.deepEqual(x.range(), [90, 60, 30]);
+      },
+      "has a rangeBand of zero": function(ordinal) {
+        var x = ordinal().domain(["a", "b", "c"]).rangePoints([0, 120]);
+        assert.equal(x.rangeBand(), 0);
+        var x = ordinal().domain(["a", "b", "c"]).rangePoints([0, 120], 1);
+        assert.equal(x.rangeBand(), 0);
+        var x = ordinal().domain(["a", "b", "c"]).rangePoints([0, 120], 2);
+        assert.equal(x.rangeBand(), 0);
+        var x = ordinal().domain(["a"]).rangePoints([0, 120]);
+        assert.equal(x.rangeBand(), 0);
+        var x = ordinal().domain(["a", "b", "c"]).rangePoints([120, 0]);
+        assert.equal(x.rangeBand(), 0);
+        var x = ordinal().domain(["a", "b", "c"]).rangePoints([120, 0], 1);
+        assert.equal(x.rangeBand(), 0);
+        var x = ordinal().domain(["a", "b", "c"]).rangePoints([120, 0], 2);
+        assert.equal(x.rangeBand(), 0);
+      }
+    },
+
+    "rangeBands": {
+      "computes discrete bands in a continuous range": function(ordinal) {
+        var x = ordinal().domain(["a", "b", "c"]).rangeBands([0, 120]);
+        assert.deepEqual(x.range(), [0, 40, 80]);
+        assert.equal(x.rangeBand(), 40);
+        var x = ordinal().domain(["a", "b", "c"]).rangeBands([0, 120], .2);
+        assert.deepEqual(x.range(), [7.5, 45, 82.5]);
+        assert.equal(x.rangeBand(), 30);
+      },
+      "setting domain recomputes range bands": function(ordinal) {
+        var x = ordinal().rangeRoundBands([0, 100]).domain(["a", "b", "c"]);
+        assert.deepEqual(x.range(), [1, 34, 67]);
+        assert.equal(x.rangeBand(), 33);
+        x.domain(["a", "b", "c", "d"]);
+        assert.deepEqual(x.range(), [0, 25, 50, 75]);
+        assert.equal(x.rangeBand(), 25);
+      },
+      "can be set to a descending range": function(ordinal) {
+        var x = ordinal().domain(["a", "b", "c"]).rangeBands([120, 0]);
+        assert.deepEqual(x.range(), [80, 40, 0]);
+        assert.equal(x.rangeBand(), 40);
+        var x = ordinal().domain(["a", "b", "c"]).rangeBands([120, 0], .2);
+        assert.deepEqual(x.range(), [82.5, 45, 7.5]);
+        assert.equal(x.rangeBand(), 30);
+      },
+      "can specify a different outer padding": function(ordinal) {
+        var x = ordinal().domain(["a", "b", "c"]).rangeBands([120, 0], .2, .1);
+        assert.deepEqual(x.range(), [84, 44, 4]);
+        assert.equal(x.rangeBand(), 32);
+        var x = ordinal().domain(["a", "b", "c"]).rangeBands([120, 0], .2, 1);
+        assert.deepEqual(x.range(), [75, 50, 25]);
+        assert.equal(x.rangeBand(), 20);
+      }
+    },
+
+    "rangeRoundBands": {
+      "computes discrete rounded bands in a continuous range": function(ordinal) {
+        var x = ordinal().domain(["a", "b", "c"]).rangeRoundBands([0, 100]);
+        assert.deepEqual(x.range(), [1, 34, 67]);
+        assert.equal(x.rangeBand(), 33);
+        var x = ordinal().domain(["a", "b", "c"]).rangeRoundBands([0, 100], .2);
+        assert.deepEqual(x.range(), [7, 38, 69]);
+        assert.equal(x.rangeBand(), 25);
+      },
+      "can be set to a descending range": function(ordinal) {
+        var x = ordinal().domain(["a", "b", "c"]).rangeRoundBands([100, 0]);
+        assert.deepEqual(x.range(), [67, 34, 1]);
+        assert.equal(x.rangeBand(), 33);
+        var x = ordinal().domain(["a", "b", "c"]).rangeRoundBands([100, 0], .2);
+        assert.deepEqual(x.range(), [69, 38, 7]);
+        assert.equal(x.rangeBand(), 25);
+      },
+      "can specify a different outer padding": function(ordinal) {
+        var x = ordinal().domain(["a", "b", "c"]).rangeRoundBands([120, 0], .2, .1);
+        assert.deepEqual(x.range(), [84, 44, 4]);
+        assert.equal(x.rangeBand(), 32);
+        var x = ordinal().domain(["a", "b", "c"]).rangeRoundBands([120, 0], .2, 1);
+        assert.deepEqual(x.range(), [75, 50, 25]);
+        assert.equal(x.rangeBand(), 20);
+      }
+    },
+
+    "rangeExtent": {
+      "returns the continuous range": function(ordinal) {
+        var x = ordinal().domain(["a", "b", "c"]).rangePoints([20, 120]);
+        assert.deepEqual(x.rangeExtent(), [20, 120]);
+        var x = ordinal().domain(["a", "b", "c"]).rangeBands([10, 110]);
+        assert.deepEqual(x.rangeExtent(), [10, 110]);
+        var x = ordinal().domain(["a", "b", "c"]).rangeRoundBands([0, 100]);
+        assert.deepEqual(x.rangeExtent(), [0, 100]);
+        var x = ordinal().domain(["a", "b", "c"]).range([0, 20, 100]);
+        assert.deepEqual(x.rangeExtent(), [0, 100]);
+      },
+      "can handle descending ranges": function(ordinal) {
+        var x = ordinal().domain(["a", "b", "c"]).rangeBands([100, 0]);
+        assert.deepEqual(x.rangeExtent(), [0, 100]);
+      }
+    },
+
+    "copy": {
+      "changes to the domain are isolated": function(ordinal) {
+        var x = ordinal().range(["foo", "bar"]), y = x.copy();
+        x.domain([1, 2]);
+        assert.deepEqual(y.domain(), []);
+        assert.equal(x(1), "foo");
+        assert.equal(y(1), "foo");
+        y.domain([2, 3]);
+        assert.equal(x(2), "bar");
+        assert.equal(y(2), "foo");
+        assert.deepEqual(x.domain(), ["1", "2"]);
+        assert.deepEqual(y.domain(), ["2", "3"]);
+      },
+      "changes to the range are isolated": function(ordinal) {
+        var x = ordinal().range(["foo", "bar"]), y = x.copy();
+        x.range(["bar", "foo"]);
+        assert.equal(x(1), "bar");
+        assert.equal(y(1), "foo");
+        assert.deepEqual(y.range(), ["foo", "bar"]);
+        y.range(["foo", "baz"]);
+        assert.equal(x(2), "foo");
+        assert.equal(y(2), "baz");
+        assert.deepEqual(x.range(), ["bar", "foo"]);
+        assert.deepEqual(y.range(), ["foo", "baz"]);
+      },
+      "changes to the range type are isolated": function(ordinal) {
+        var x = ordinal().domain([0, 1]).rangeBands([0, 1], .2), y = x.copy();
+        x.rangePoints([1, 2]);
+        assert.inDelta(x(0), 1, 1e-6);
+        assert.inDelta(x(1), 2, 1e-6);
+        assert.inDelta(x.rangeBand(), 0, 1e-6);
+        assert.inDelta(y(0), 1/11, 1e-6);
+        assert.inDelta(y(1), 6/11, 1e-6);
+        assert.inDelta(y.rangeBand(), 4/11, 1e-6);
+        y.rangeBands([0, 1]);
+        assert.inDelta(x(0), 1, 1e-6);
+        assert.inDelta(x(1), 2, 1e-6);
+        assert.inDelta(x.rangeBand(), 0, 1e-6);
+        assert.inDelta(y(0), 0, 1e-6);
+        assert.inDelta(y(1), 1/2, 1e-6);
+        assert.inDelta(y.rangeBand(), 1/2, 1e-6);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/scale/pow-test.js

@@ -0,0 +1,267 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.scale.pow");
+
+suite.addBatch({
+  "pow": {
+    topic: load("scale/pow", "interpolate/hsl"), // beware instance of d3_Colorr
+
+    "domain": {
+      "defaults to [0, 1]": function(d3) {
+        var x = d3.scale.pow();
+        assert.deepEqual(x.domain(), [0, 1]);
+        assert.inDelta(x(.5), .5, 1e-6);
+      },
+      "coerces domain to numbers": function(d3) {
+        var x = d3.scale.pow().domain([new Date(1990, 0, 1), new Date(1991, 0, 1)]);
+        assert.equal(typeof x.domain()[0], "number");
+        assert.equal(typeof x.domain()[1], "number");
+        assert.inDelta(x(new Date(1989, 09, 20)), -.2, 1e-2);
+        assert.inDelta(x(new Date(1990, 00, 01)), 0, 1e-2);
+        assert.inDelta(x(new Date(1990, 02, 15)), .2, 1e-2);
+        assert.inDelta(x(new Date(1990, 04, 27)), .4, 1e-2);
+        assert.inDelta(x(new Date(1991, 00, 01)), 1, 1e-2);
+        assert.inDelta(x(new Date(1991, 02, 15)), 1.2, 1e-2);
+        var x = d3.scale.pow().domain(["0", "1"]);
+        assert.equal(typeof x.domain()[0], "number");
+        assert.equal(typeof x.domain()[1], "number");
+        assert.inDelta(x(.5), .5, 1e-6);
+        var x = d3.scale.pow().domain([new Number(0), new Number(1)]);
+        assert.equal(typeof x.domain()[0], "number");
+        assert.equal(typeof x.domain()[1], "number");
+        assert.inDelta(x(.5), .5, 1e-6);
+      },
+      "can specify a polypower domain and range": function(d3) {
+        var x = d3.scale.pow().domain([-10, 0, 100]).range(["red", "white", "green"]);
+        assert.equal(x(-5), "#ff8080");
+        assert.equal(x(50), "#80c080");
+        assert.equal(x(75), "#40a040");
+      }
+    },
+
+    "range": {
+      "defaults to [0, 1]": function(d3) {
+        var x = d3.scale.pow();
+        assert.deepEqual(x.range(), [0, 1]);
+        assert.inDelta(x.invert(.5), .5, 1e-6);
+      },
+      "does not coerce range values to numbers": function(d3) {
+        var x = d3.scale.pow().range(["0", "2"]);
+        assert.equal(typeof x.range()[0], "string");
+        assert.equal(typeof x.range()[1], "string");
+      },
+      "coerces range values to number on invert": function(d3) {
+        var x = d3.scale.pow().range(["0", "2"]);
+        assert.inDelta(x.invert("1"), .5, 1e-6);
+        var x = d3.scale.pow().range([new Date(1990, 0, 1), new Date(1991, 0, 1)]);
+        assert.inDelta(x.invert(new Date(1990, 6, 2, 13)), .5, 1e-6);
+        var x = d3.scale.pow().range(["#000", "#fff"]);
+        assert.isNaN(x.invert("#999"));
+      },
+      "can specify range values as colors": function(d3) {
+        var x = d3.scale.pow().range(["red", "blue"]);
+        assert.equal(x(.5), "#800080");
+        var x = d3.scale.pow().range(["#ff0000", "#0000ff"]);
+        assert.equal(x(.5), "#800080");
+        var x = d3.scale.pow().range(["#f00", "#00f"]);
+        assert.equal(x(.5), "#800080");
+        var x = d3.scale.pow().range([d3.rgb(255,0,0), d3.hsl(240,1,.5)]);
+        assert.equal(x(.5), "#800080");
+        var x = d3.scale.pow().range(["hsl(0,100%,50%)", "hsl(240,100%,50%)"]);
+        assert.equal(x(.5), "#800080");
+      },
+      "can specify range values as arrays or objects": function(d3) {
+        var x = d3.scale.pow().range([{color: "red"}, {color: "blue"}]);
+        assert.deepEqual(x(.5), {color: d3.rgb(128, 0, 128)});
+        var x = d3.scale.pow().range([["red"], ["blue"]]);
+        assert.deepEqual(x(.5), [d3.rgb(128, 0, 128)]);
+      }
+    },
+
+    "exponent": {
+      "defaults to one": function(d3) {
+        var x = d3.scale.pow();
+        assert.equal(x.exponent(), 1);
+      },
+      "observes the specified exponent": function(d3) {
+        var x = d3.scale.pow().exponent(.5).domain([1, 2]);
+        assert.inDelta(x(1), 0, 1e-6);
+        assert.inDelta(x(1.5), 0.5425821, 1e-6);
+        assert.inDelta(x(2), 1, 1e-6);
+        assert.equal(x.exponent(), .5);
+        var x = d3.scale.pow().exponent(2).domain([1, 2]);
+        assert.inDelta(x(1), 0, 1e-6);
+        assert.inDelta(x(1.5), .41666667, 1e-6);
+        assert.inDelta(x(2), 1, 1e-6);
+        assert.equal(x.exponent(), 2);
+        var x = d3.scale.pow().exponent(-1).domain([1, 2]);
+        assert.inDelta(x(1), 0, 1e-6);
+        assert.inDelta(x(1.5), .6666667, 1e-6);
+        assert.inDelta(x(2), 1, 1e-6);
+        assert.equal(x.exponent(), -1);
+      },
+      "changing the exponent does not change the domain or range": function(d3) {
+        var x = d3.scale.pow().domain([1, 2]).range([3, 4]), f = d3.format(".6f");
+        x.exponent(.5);
+        assert.deepEqual(x.domain().map(f), [1, 2]);
+        assert.deepEqual(x.range(), [3, 4]);
+        x.exponent(2);
+        assert.deepEqual(x.domain().map(f), [1, 2]);
+        assert.deepEqual(x.range(), [3, 4]);
+        x.exponent(-1);
+        assert.deepEqual(x.domain().map(f), [1, 2]);
+        assert.deepEqual(x.range(), [3, 4]);
+      }
+    },
+
+    "interpolate": {
+      "defaults to d3.interpolate": function(d3) {
+        var x = d3.scale.pow().range(["red", "blue"]);
+        assert.equal(x.interpolate(), d3.interpolate);
+        assert.rgbEqual(x(.5), 128, 0, 128);
+      },
+      "can specify a custom interpolator": function(d3) {
+        var x = d3.scale.pow().range(["red", "blue"]).interpolate(d3.interpolateHsl);
+        assert.hslEqual(x(.5), -60, 1, .5);
+      }
+    },
+
+    "clamp": {
+      "does not clamp by default": function(d3) {
+        var x = d3.scale.pow();
+        assert.isFalse(x.clamp());
+        assert.inDelta(x(-.5), -.5, 1e-6);
+        assert.inDelta(x(1.5), 1.5, 1e-6);
+      },
+      "can clamp to the domain": function(d3) {
+        var x = d3.scale.pow().clamp(true);
+        assert.inDelta(x(-.5), 0, 1e-6);
+        assert.inDelta(x(.5), .5, 1e-6);
+        assert.inDelta(x(1.5), 1, 1e-6);
+        var x = d3.scale.pow().domain([1, 0]).clamp(true);
+        assert.inDelta(x(-.5), 1, 1e-6);
+        assert.inDelta(x(.5), .5, 1e-6);
+        assert.inDelta(x(1.5), 0, 1e-6);
+      }
+    },
+
+    "maps a number to a number": function(d3) {
+      var x = d3.scale.pow().domain([1, 2]);
+      assert.inDelta(x(.5), -.5, 1e-6);
+      assert.inDelta(x(1), 0, 1e-6);
+      assert.inDelta(x(1.5), .5, 1e-6);
+      assert.inDelta(x(2), 1, 1e-6);
+      assert.inDelta(x(2.5), 1.5, 1e-6);
+    },
+
+    "ticks": {
+      "can generate ticks of varying degree": function(d3) {
+        var x = d3.scale.pow();
+        assert.deepEqual(x.ticks(1).map(x.tickFormat(1)), [0, 1]);
+        assert.deepEqual(x.ticks(2).map(x.tickFormat(2)), [0, .5, 1]);
+        assert.deepEqual(x.ticks(5).map(x.tickFormat(5)), [0, .2, .4, .6, .8, 1]);
+        assert.deepEqual(x.ticks(10).map(x.tickFormat(10)), [0, .1, .2, .3, .4, .5, .6, .7, .8, .9, 1]);
+        var x = d3.scale.pow().domain([1, 0]);
+        assert.deepEqual(x.ticks(1).map(x.tickFormat(1)), [0, 1]);
+        assert.deepEqual(x.ticks(2).map(x.tickFormat(2)), [0, .5, 1]);
+        assert.deepEqual(x.ticks(5).map(x.tickFormat(5)), [0, .2, .4, .6, .8, 1]);
+        assert.deepEqual(x.ticks(10).map(x.tickFormat(10)), [0, .1, .2, .3, .4, .5, .6, .7, .8, .9, 1]);
+      }
+    },
+
+    "nice": {
+      "can nice the domain, extending it to round numbers": function(d3) {
+        var x = d3.scale.pow().domain([1.1, 10.9]).nice();
+        assert.deepEqual(x.domain(), [1, 11]);
+        var x = d3.scale.pow().domain([10.9, 1.1]).nice();
+        assert.deepEqual(x.domain(), [11, 1]);
+        var x = d3.scale.pow().domain([.7, 11.001]).nice();
+        assert.deepEqual(x.domain(), [0, 12]);
+        var x = d3.scale.pow().domain([123.1, 6.7]).nice();
+        assert.deepEqual(x.domain(), [130, 0]);
+        var x = d3.scale.pow().domain([0, .49]).nice();
+        assert.deepEqual(x.domain(), [0, .5]);
+        var x = d3.scale.pow().domain([0, 0]).nice();
+        assert.deepEqual(x.domain(), [0, 0]);
+        var x = d3.scale.pow().domain([.5, .5]).nice();
+        assert.deepEqual(x.domain(), [.5, .5]);
+      },
+      "nicing a polypower domain only affects the extent": function(d3) {
+        var x = d3.scale.pow().domain([1.1, 1, 2, 3, 10.9]).nice();
+        assert.deepEqual(x.domain(), [1, 1, 2, 3, 11]);
+        var x = d3.scale.pow().domain([123.1, 1, 2, 3, -.9]).nice();
+        assert.deepEqual(x.domain(), [130, 1, 2, 3, -10]);
+      },
+      "accepts a tick count to control nicing step": function(d3) {
+        var x = d3.scale.pow().domain([12, 87]).nice(5);
+        assert.deepEqual(x.domain(), [0, 100]);
+        var x = d3.scale.pow().domain([12, 87]).nice(10);
+        assert.deepEqual(x.domain(), [10, 90]);
+        var x = d3.scale.pow().domain([12, 87]).nice(100);
+        assert.deepEqual(x.domain(), [12, 87]);
+      }
+    },
+
+    "copy": {
+      "changes to the domain are isolated": function(d3) {
+        var x = d3.scale.pow(), y = x.copy();
+        x.domain([1, 2]);
+        assert.deepEqual(y.domain(), [0, 1]);
+        assert.equal(x(1), 0);
+        assert.equal(y(1), 1);
+        y.domain([2, 3]);
+        assert.equal(x(2), 1);
+        assert.equal(y(2), 0);
+        assert.deepEqual(x.domain(), [1, 2]);
+        assert.deepEqual(y.domain(), [2, 3]);
+      },
+      "changes to the range are isolated": function(d3) {
+        var x = d3.scale.pow(), y = x.copy();
+        x.range([1, 2]);
+        assert.equal(x.invert(1), 0);
+        assert.equal(y.invert(1), 1);
+        assert.deepEqual(y.range(), [0, 1]);
+        y.range([2, 3]);
+        assert.equal(x.invert(2), 1);
+        assert.equal(y.invert(2), 0);
+        assert.deepEqual(x.range(), [1, 2]);
+        assert.deepEqual(y.range(), [2, 3]);
+      },
+      "changes to the exponent are isolated": function(d3) {
+        var x = d3.scale.pow().exponent(2), y = x.copy();
+        x.exponent(.5);
+        assert.inDelta(x(.5), Math.SQRT1_2, 1e-6);
+        assert.inDelta(y(.5), 0.25, 1e-6);
+        assert.equal(x.exponent(), .5);
+        assert.equal(y.exponent(), 2);
+        y.exponent(3);
+        assert.inDelta(x(.5), Math.SQRT1_2, 1e-6);
+        assert.inDelta(y(.5), 0.125, 1e-6);
+        assert.equal(x.exponent(), .5);
+        assert.equal(y.exponent(), 3);
+      },
+      "changes to the interpolator are isolated": function(d3) {
+        var x = d3.scale.pow().range(["red", "blue"]), y = x.copy();
+        x.interpolate(d3.interpolateHsl);
+        assert.equal(x(0.5), "#ff00ff");
+        assert.equal(y(0.5), "#800080");
+        assert.equal(y.interpolate(), d3.interpolate);
+      },
+      "changes to clamping are isolated": function(d3) {
+        var x = d3.scale.pow().clamp(true), y = x.copy();
+        x.clamp(false);
+        assert.equal(x(2), 2);
+        assert.equal(y(2), 1);
+        assert.isTrue(y.clamp());
+        y.clamp(false);
+        assert.equal(x(2), 2);
+        assert.equal(y(2), 2);
+        assert.isFalse(x.clamp());
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/scale/quantile-test.js

@@ -0,0 +1,91 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.scale.quantile");
+
+suite.addBatch({
+  "quantile": {
+    topic: load("scale/quantile").expression("d3.scale.quantile"),
+    "has the empty domain by default": function(quantile) {
+      assert.isEmpty(quantile().domain());
+    },
+    "has the empty range by default": function(quantile) {
+      assert.isEmpty(quantile().range());
+    },
+    "uses the R-7 algorithm to compute quantiles": function(quantile) {
+      var x = quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]);
+      assert.deepEqual([3, 6, 6.9, 7, 7.1].map(x), [0, 0, 0, 0, 0]);
+      assert.deepEqual([8, 8.9].map(x), [1, 1]);
+      assert.deepEqual([9, 9.1, 10, 13].map(x), [2, 2, 2, 2]);
+      assert.deepEqual([14.9, 15, 15.1, 16, 20].map(x), [3, 3, 3, 3, 3]);
+      var x = quantile().domain([3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]);
+      assert.deepEqual([3, 6, 6.9, 7, 7.1].map(x), [0, 0, 0, 0, 0]);
+      assert.deepEqual([8, 8.9].map(x), [1, 1]);
+      assert.deepEqual([9, 9.1, 10, 13].map(x), [2, 2, 2, 2]);
+      assert.deepEqual([14.9, 15, 15.1, 16, 20].map(x), [3, 3, 3, 3, 3]);
+    },
+    "domain values are sorted in ascending order": function(quantile) {
+      var x = quantile().domain([6, 3, 7, 8, 8, 13, 20, 15, 16, 10]);
+      assert.deepEqual(x.domain(), [3, 6, 7, 8, 8, 10, 13, 15, 16, 20]);
+    },
+    "non-numeric domain values are ignored": function(quantile) {
+      var x = quantile().domain([6, 3, NaN, undefined, 7, 8, 8, 13, 20, 15, 16, 10, NaN]);
+      assert.deepEqual(x.domain(), [3, 6, 7, 8, 8, 10, 13, 15, 16, 20]);
+    },
+    "quantiles returns the inner thresholds": function(quantile) {
+      var x = quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]);
+      assert.deepEqual(x.quantiles(), [7.25, 9, 14.5]);
+      var x = quantile().domain([3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]);
+      assert.deepEqual(x.quantiles(), [7.5, 9, 14]);
+    },
+    "range cardinality determines the number of quantiles": function(quantile) {
+      var x = quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]);
+      assert.deepEqual(x.range([0, 1, 2, 3]).quantiles(), [7.25, 9, 14.5]);
+      assert.deepEqual(x.range([0, 1]).quantiles(), [9]);
+      assert.deepEqual(x.range([,,,,,]).quantiles(), [6.8, 8, 11.2, 15.2]);
+      assert.deepEqual(x.range([,,,,,,]).quantiles(), [6.5, 8, 9, 13, 15.5]);
+    },
+    "range values are arbitrary": function(quantile) {
+      var a = new Object(), b = new Object(), c = new Object();
+      var x = quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([a, b, c, a]);
+      assert.deepEqual([3, 6, 6.9, 7, 7.1].map(x), [a, a, a, a, a]);
+      assert.deepEqual([8, 8.9].map(x), [b, b]);
+      assert.deepEqual([9, 9.1, 10, 13].map(x), [c, c, c, c]);
+      assert.deepEqual([14.9, 15, 15.1, 16, 20].map(x), [a, a, a, a, a]);
+    },
+    "returns undefined if the input value is NaN": function(quantile) {
+      var x = quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]);
+      assert.isUndefined(x(NaN));
+    },
+    "invertExtent": {
+      "maps a value in the range to a domain extent": function(quantile) {
+        var x = quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]);
+        assert.deepEqual(x.invertExtent(0), [3, 7.25]);
+        assert.deepEqual(x.invertExtent(1), [7.25, 9]);
+        assert.deepEqual(x.invertExtent(2), [9, 14.5]);
+        assert.deepEqual(x.invertExtent(3), [14.5, 20]);
+      },
+      "allows arbitrary range values": function(quantile) {
+        var a = {}, b = {}, x = quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([a, b]);
+        assert.deepEqual(x.invertExtent(a), [3, 9]);
+        assert.deepEqual(x.invertExtent(b), [9, 20]);
+      },
+      "returns [NaN, NaN] when the given value is not in the range": function(quantile) {
+        var x = quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]);
+        assert.ok(x.invertExtent(-1).every(isNaN));
+        assert.ok(x.invertExtent(.5).every(isNaN));
+        assert.ok(x.invertExtent(2).every(isNaN));
+        assert.ok(x.invertExtent('a').every(isNaN));
+      },
+      "returns the first match if duplicate values exist in the range": function(quantile) {
+        var x = quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 0]);
+        assert.deepEqual(x.invertExtent(0), [3, 7.25]);
+        assert.deepEqual(x.invertExtent(1), [7.25, 9]);
+        assert.deepEqual(x.invertExtent(2), [9, 14.5]);
+      }
+    }
+  }
+});
+
+suite.export(module);