picky-statistics 4.5.0 → 4.5.1

data/lib/picky-statistics/application/javascripts/d3/test/layout/partition-test.js

@@ -1,50 +0,0 @@
-require("../env");
-require("../../d3");
-require("../../d3.layout");
-
-var vows = require("vows"),
-    assert = require("assert");
-
-var suite = vows.describe("d3.layout.partition");
-
-suite.addBatch({
-  "partition": {
-    topic: function() {
-      return d3.layout.partition;
-    },
-    "ignores zero values": function(partition) {
-      var p = partition().size([3, 3]);
-      assert.deepEqual(p.nodes({children: [{value: 1}, {value: 0}, {value: 2}, {children: [{value: 0}, {value: 0}]}]}).map(metadata), [
-        {x: 0, y: 0, dx: 3, dy: 1},
-        {x: 2, y: 1, dx: 1, dy: 1},
-        {x: 3, y: 1, dx: 0, dy: 1},
-        {x: 0, y: 1, dx: 2, dy: 1},
-        {x: 3, y: 1, dx: 0, dy: 1},
-        {x: 3, y: 2, dx: 0, dy: 1},
-        {x: 3, y: 2, dx: 0, dy: 1}
-      ]);
-    },
-    "can handle an empty children array": function(partition) {
-      var p = partition();
-      assert.deepEqual(p.nodes({children: []}).map(metadata), [
-        {x: 0, y: 0, dx: 1, dy: 1}
-      ]);
-      assert.deepEqual(p.nodes({children: [{children: []}, {value: 1}]}).map(metadata), [
-        {x: 0, y: 0,   dx: 1, dy: 0.5},
-        {x: 1, y: 0.5, dx: 0, dy: 0.5},
-        {x: 0, y: 0.5, dx: 1, dy: 0.5}
-      ]);
-    }
-  }
-});
-
-function metadata(node) {
-  var metadata = {};
-  if ("x" in node) metadata.x = node.x;
-  if ("y" in node) metadata.y = node.y;
-  if ("dx" in node) metadata.dx = node.dx;
-  if ("dy" in node) metadata.dy = node.dy;
-  return metadata;
-}
-
-suite.export(module);

data/lib/picky-statistics/application/javascripts/d3/test/layout/tree-test.js

@@ -1,41 +0,0 @@
-require("../env");
-require("../../d3");
-require("../../d3.layout");
-
-var vows = require("vows"),
-    assert = require("assert");
-
-var suite = vows.describe("d3.layout.tree");
-
-suite.addBatch({
-  "tree": {
-    topic: d3.layout.tree,
-    "can handle an empty children array": function(tree) {
-      assert.deepEqual(tree.nodes({children: []}).map(layout), [
-        {depth: 0, x: 0.5, y: 0}
-      ]);
-      assert.deepEqual(tree.nodes({children: [
-        {children: []},
-        {children: [{}]},
-        {children: [{}]}
-      ]}).map(layout), [
-        {depth: 0, x: .5,   y: 0},
-        {depth: 1, x: .125, y: 0.5},
-        {depth: 1, x: .375, y: 0.5},
-        {depth: 2, x: .375, y: 1},
-        {depth: 1, x: .875, y: 0.5},
-        {depth: 2, x: .875, y: 1}
-      ]);
-    }
-  }
-});
-
-function layout(node) {
-  return {
-    depth: node.depth,
-    x: node.x,
-    y: node.y
-  };
-}
-
-suite.export(module);

data/lib/picky-statistics/application/javascripts/d3/test/layout/treemap-test.js

@@ -1,190 +0,0 @@
-require("../env");
-require("../../d3");
-require("../../d3.layout");
-
-var vows = require("vows"),
-    assert = require("assert");
-
-var suite = vows.describe("d3.layout.treemap");
-
-suite.addBatch({
-  "treemap": {
-    topic: function() {
-      return d3.layout.treemap;
-    },
-    "outputs a squarified treemap": function(treemap) {
-      var t = treemap().size([1000, 1000]).sort(null);
-      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
-        {x: 0, y: 0, dx: 1000, dy: 1000},
-        {x: 0, y: 833, dx: 1000, dy: 167},
-        {x: 600, y: 0, dx: 400, dy: 833},
-        {x: 0, y: 0, dx: 600, dy: 833},
-        {x: 0, y: 555, dx: 600, dy: 278},
-        {x: 0, y: 0, dx: 600, dy: 555}
-      ]);
-    },
-    "sorts by value by default": function(treemap) {
-      var t = treemap().size([1000, 1000]);
-      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
-        {x: 0, y: 0, dx: 1000, dy: 1000},
-        {x: 0, y: 0, dx: 333, dy: 500},
-        {x: 333, y: 0, dx: 667, dy: 500},
-        {x: 0, y: 500, dx: 1000, dy: 500},
-        {x: 0, y: 500, dx: 333, dy: 500},
-        {x: 333, y: 500, dx: 667, dy: 500}
-      ]);
-    },
-    "ignores zero values": function(treemap) {
-      var t = treemap().size([1000, 1000]).sort(null);
-      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 0}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
-        {x: 0, y: 0, dx: 1000, dy: 1000},
-        {x: 0, y: 833, dx: 1000, dy: 167},
-        {x: 1000, y: 0, dx: 0, dy: 833},
-        {x: 600, y: 0, dx: 400, dy: 833},
-        {x: 0, y: 0, dx: 600, dy: 833},
-        {x: 0, y: 555, dx: 600, dy: 278},
-        {x: 0, y: 0, dx: 600, dy: 555}
-      ]);
-    },
-    "ignores NaN values": function(treemap) {
-      var t = treemap().size([1000, 1000]).sort(null);
-      assert.deepEqual(t.nodes({children: [{value: 1}, {value: NaN}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
-        {x: 0, y: 0, dx: 1000, dy: 1000},
-        {x: 0, y: 833, dx: 1000, dy: 167},
-        {x: 1000, y: 0, dx: 0, dy: 833},
-        {x: 600, y: 0, dx: 400, dy: 833},
-        {x: 0, y: 0, dx: 600, dy: 833},
-        {x: 0, y: 555, dx: 600, dy: 278},
-        {x: 0, y: 0, dx: 600, dy: 555}
-      ]);
-    },
-    "does not overflow empty size": function(treemap) {
-      var t = treemap().size([0, 0]).sort(null);
-      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
-        {x: 0, y: 0, dx: 0, dy: 0},
-        {x: 0, y: 0, dx: 0, dy: 0},
-        {x: 0, y: 0, dx: 0, dy: 0},
-        {x: 0, y: 0, dx: 0, dy: 0},
-        {x: 0, y: 0, dx: 0, dy: 0},
-        {x: 0, y: 0, dx: 0, dy: 0}
-      ]);
-    },
-    "can specify padding as a number": function(treemap) {
-      var t = treemap().size([1000, 1000]).sort(null).padding(1);
-      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
-        {x: 0, y: 0, dx: 1000, dy: 1000},
-        {x: 1, y: 833, dx: 998, dy: 166},
-        {x: 600, y: 1, dx: 399, dy: 832},
-        {x: 1, y: 1, dx: 599, dy: 832},
-        {x: 2, y: 555, dx: 597, dy: 277},
-        {x: 2, y: 2, dx: 597, dy: 553}
-      ]);
-    },
-    "can specify padding as an array": function(treemap) {
-      var t = treemap().size([1000, 1000]).sort(null).padding([1,2,3,4]);
-      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
-        {x: 0, y: 0, dx: 1000, dy: 1000},
-        {x: 4, y: 831, dx: 994, dy: 166},
-        {x: 600, y: 1, dx: 398, dy: 830},
-        {x: 4, y: 1, dx: 596, dy: 830},
-        {x: 8, y: 553, dx: 590, dy: 275},
-        {x: 8, y: 2, dx: 590, dy: 551}
-      ]);
-    },
-    "can specify padding as null": function(treemap) {
-      var t = treemap().size([1000, 1000]).sort(null).padding(null);
-      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
-        {x: 0, y: 0, dx: 1000, dy: 1000},
-        {x: 0, y: 833, dx: 1000, dy: 167},
-        {x: 600, y: 0, dx: 400, dy: 833},
-        {x: 0, y: 0, dx: 600, dy: 833},
-        {x: 0, y: 555, dx: 600, dy: 278},
-        {x: 0, y: 0, dx: 600, dy: 555}
-      ]);
-    },
-    "can specify padding as a function that returns a number": function(treemap) {
-      var t = treemap().size([1000, 1000]).sort(null).padding(function(d) { return d.depth; });
-      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
-        {x: 0, y: 0, dx: 1000, dy: 1000},
-        {x: 0, y: 833, dx: 1000, dy: 167},
-        {x: 600, y: 0, dx: 400, dy: 833},
-        {x: 0, y: 0, dx: 600, dy: 833},
-        {x: 1, y: 555, dx: 598, dy: 277},
-        {x: 1, y: 1, dx: 598, dy: 554}
-      ]);
-    },
-    "can specify padding as a function that returns an array": function(treemap) {
-      var t = treemap().size([1000, 1000]).sort(null).padding(function(d) { return [d.depth,2,3,4]; });
-      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
-        {x: 0, y: 0, dx: 1000, dy: 1000},
-        {x: 4, y: 831, dx: 994, dy: 166},
-        {x: 600, y: 0, dx: 398, dy: 831},
-        {x: 4, y: 0, dx: 596, dy: 831},
-        {x: 8, y: 552, dx: 590, dy: 276},
-        {x: 8, y: 1, dx: 590, dy: 551}
-      ]);
-    },
-    "can specify padding as a function that returns null": function(treemap) {
-      var t = treemap().size([1000, 1000]).sort(null).padding(function(d) { return d.depth & 1 ? null : 1; });
-      assert.deepEqual(t.nodes({children: [{value: 1}, {value: 2}, {children: [{value: 1}, {value: 2}]}]}).map(layout), [
-        {x: 0, y: 0, dx: 1000, dy: 1000},
-        {x: 1, y: 833, dx: 998, dy: 166},
-        {x: 600, y: 1, dx: 399, dy: 832},
-        {x: 1, y: 1, dx: 599, dy: 832},
-        {x: 1, y: 556, dx: 599, dy: 277},
-        {x: 1, y: 1, dx: 599, dy: 555}
-      ]);
-    },
-    "no negatively sized rectangles": function(treemap) {
-      var t = treemap().size([615, 500]).sort(function(a, b) { return a.value - b.value; }).padding(29),
-          nodes = t.nodes({"children": [
-            {"value": 1},
-            {"value": 9},
-            {"value": 3},
-            {"value": 15},
-            {"value": 44},
-            {"value": 28},
-            {"value": 32},
-            {"value": 41},
-            {"value": 50},
-            {"value": 60},
-            {"value": 64},
-            {"value": 75},
-            {"value": 76},
-            {"value": 84},
-            {"value": 88},
-            {"value": 100},
-            {"value": 140},
-            {"value": 142},
-            {"value": 363},
-            {"value": 657},
-            {"value": 670},
-            {"value": 822},
-            {"value": 1173},
-            {"value": 1189}
-          ]}).map(layout);
-      assert.equal(nodes.filter(function(n) { return n.dx < 0 || n.dy < 0; }).length, 0);
-    },
-    "can handle an empty children array": function(treemap) {
-      assert.deepEqual(treemap().nodes({children: []}).map(layout), [
-        {x: 0, y: 0, dx: 1, dy: 1}
-      ]);
-      assert.deepEqual(treemap().nodes({children: [{children: []}, {value: 1}]}).map(layout), [
-        {x: 0, y: 0, dx: 1, dy: 1},
-        {x: 0, y: 0, dx: 0, dy: 1},
-        {x: 0, y: 0, dx: 1, dy: 1}
-      ]);
-    }
-  }
-});
-
-function layout(node) {
-  return {
-    x: node.x,
-    y: node.y,
-    dx: node.dx,
-    dy: node.dy
-  };
-}
-
-suite.export(module);

data/lib/picky-statistics/application/javascripts/d3/test/scale/category-test.js

@@ -1,74 +0,0 @@
-require("../env");
-require("../../d3");
-
-var vows = require("vows"),
-    assert = require("assert");
-
-var suite = vows.describe("d3.scale.category");
-
-suite.addBatch({
-  "category10": category(d3.scale.category10, 10),
-  "category20": category(d3.scale.category20, 20),
-  "category20b": category(d3.scale.category20b, 20),
-  "category20c": category(d3.scale.category20c, 20)
-});
-
-function category(category, n) {
-  return {
-    "is an ordinal scale": function() {
-      var x = category(), colors = x.range();
-      assert.lengthOf(x.domain(), 0);
-      assert.lengthOf(x.range(), n);
-      assert.equal(x(1), colors[0]);
-      assert.equal(x(2), colors[1]);
-      assert.equal(x(1), colors[0]);
-      var y = x.copy();
-      assert.deepEqual(y.domain(), x.domain());
-      assert.deepEqual(y.range(), x.range());
-      x.domain(d3.range(n));
-      for (var i = 0; i < n; ++i) assert.equal(x(i + n), x(i));
-      assert.equal(y(1), colors[0]);
-      assert.equal(y(2), colors[1]);
-    },
-    "each instance is isolated": function() {
-      var a = category(), b = category(), colors = a.range();
-      assert.equal(a(1), colors[0]);
-      assert.equal(b(2), colors[0]);
-      assert.equal(b(1), colors[1]);
-      assert.equal(a(1), colors[0]);
-    },
-    "contains the expected number of values in the range": function() {
-      var x = category();
-      assert.lengthOf(x.range(), n);
-    },
-    "each range value is distinct": function() {
-      var map = {}, count = 0, x = category();
-      x.range().forEach(function(v) {
-        if (!(v in map)) {
-          map[v] = ++count;
-        }
-      });
-      assert.equal(count, x.range().length);
-    },
-    "each range value is a hexadecimal color": function() {
-      var x = category();
-      x.range().forEach(function(v) {
-        assert.match(v, /#[0-9a-f]{6}/);
-        v = d3.rgb(v);
-        assert.isFalse(isNaN(v.r));
-        assert.isFalse(isNaN(v.g));
-        assert.isFalse(isNaN(v.b));
-      });
-    },
-    "no range values are very dark or very light": function() {
-      var x = category();
-      x.range().forEach(function(v) {
-        var c = d3.hsl(v);
-        assert.isTrue(c.l >= .34, "expected " + v + " to be lighter (l = " + c.l + ")");
-        assert.isTrue(c.l <= .89, "expected " + v + " to be darker (l = " + c.l + ")");
-      });
-    }
-  };
-}
-
-suite.export(module);

data/lib/picky-statistics/application/javascripts/d3/test/scale/linear-test.js

@@ -1,243 +0,0 @@
-require("../env");
-require("../../d3");
-
-var vows = require("vows"),
-    assert = require("assert");
-
-var suite = vows.describe("d3.scale.linear");
-
-suite.addBatch({
-  "linear": {
-    topic: function() {
-      return d3.scale.linear;
-    },
-
-    "domain": {
-      "defaults to [0, 1]": function(linear) {
-        var x = linear();
-        assert.deepEqual(x.domain(), [0, 1]);
-        assert.inDelta(x(.5), .5, 1e-6);
-      },
-      "coerces domain values to numbers": function(linear) {
-        var x = linear().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 = linear().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 = linear().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 polylinear domain and range": function(linear) {
-        var x = linear().domain([-10, 0, 100]).range(["red", "white", "green"]);
-        assert.equal(x(-5), "#ff8080");
-        assert.equal(x(50), "#80c080");
-        assert.equal(x(75), "#40a040");
-      },
-      "an empty domain maps to the range start": function(linear) {
-        var x = linear().domain([0, 0]).range(["red", "green"]);
-        assert.equal(x(0), "#ff0000");
-        assert.equal(x(-1), "#ff0000");
-        assert.equal(x(1), "#ff0000");
-      }
-    },
-
-    "range": {
-      "defaults to [0, 1]": function(linear) {
-        var x = linear();
-        assert.deepEqual(x.range(), [0, 1]);
-        assert.inDelta(x.invert(.5), .5, 1e-6);
-      },
-      "does not coerce range to numbers": function(linear) {
-        var x = linear().range(["0", "2"]);
-        assert.equal(typeof x.range()[0], "string");
-        assert.equal(typeof x.range()[1], "string");
-      },
-      "can specify range values as colors": function(linear) {
-        var x = linear().range(["red", "blue"]);
-        assert.equal(x(.5), "#800080");
-        var x = linear().range(["#ff0000", "#0000ff"]);
-        assert.equal(x(.5), "#800080");
-        var x = linear().range(["#f00", "#00f"]);
-        assert.equal(x(.5), "#800080");
-        var x = linear().range([d3.rgb(255,0,0), d3.hsl(240,1,.5)]);
-        assert.equal(x(.5), "#800080");
-        var x = linear().range(["hsl(0,100%,50%)", "hsl(240,100%,50%)"]);
-        assert.equal(x(.5), "#800080");
-      },
-      "can specify range values as arrays or objects": function(linear) {
-        var x = linear().range([{color: "red"}, {color: "blue"}]);
-        assert.deepEqual(x(.5), {color: "#800080"});
-        var x = linear().range([["red"], ["blue"]]);
-        assert.deepEqual(x(.5), ["#800080"]);
-      }
-    },
-
-    "interpolate": {
-      "defaults to d3.interpolate": function(linear) {
-        var x = linear().range(["red", "blue"]);
-        assert.equal(x.interpolate(), d3.interpolate);
-        assert.equal(x(.5), "#800080");
-      },
-      "can specify a custom interpolator": function(linear) {
-        var x = linear().range(["red", "blue"]).interpolate(d3.interpolateHsl);
-        assert.equal(x(.5), "#00ff00");
-      }
-    },
-
-    "clamp": {
-      "defaults to false": function(linear) {
-        var x = linear();
-        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(linear) {
-        var x = linear().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 = linear().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(linear) {
-      var x = linear().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);
-    },
-
-    "invert": {
-      "maps a number to a number": function(linear) {
-        var x = linear().range([1, 2]);
-        assert.inDelta(x.invert(.5), -.5, 1e-6);
-        assert.inDelta(x.invert(1), 0, 1e-6);
-        assert.inDelta(x.invert(1.5), .5, 1e-6);
-        assert.inDelta(x.invert(2), 1, 1e-6);
-        assert.inDelta(x.invert(2.5), 1.5, 1e-6);
-      },
-      "coerces range value to numbers": function(linear) {
-        var x = linear().range(["0", "2"]);
-        assert.inDelta(x.invert("1"), .5, 1e-6);
-        var x = linear().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 = linear().range(["#000", "#fff"]);
-        assert.isNaN(x.invert("#999"));
-      }
-    },
-
-    "ticks": {
-      "generates ticks of varying degree": function(linear) {
-        var x = linear();
-        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 = linear().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]);
-      },
-      "formats ticks with the appropriate precision": function(linear) {
-        var x = linear().domain([.123456789, 1.23456789]);
-        assert.strictEqual(x.tickFormat(1)(x.ticks(1)[0]), "1");
-        assert.strictEqual(x.tickFormat(2)(x.ticks(2)[0]), "0.5");
-        assert.strictEqual(x.tickFormat(4)(x.ticks(4)[0]), "0.2");
-        assert.strictEqual(x.tickFormat(8)(x.ticks(8)[0]), "0.2");
-        assert.strictEqual(x.tickFormat(16)(x.ticks(16)[0]), "0.2");
-        assert.strictEqual(x.tickFormat(32)(x.ticks(32)[0]), "0.15");
-        assert.strictEqual(x.tickFormat(64)(x.ticks(64)[0]), "0.14");
-        assert.strictEqual(x.tickFormat(128)(x.ticks(128)[0]), "0.13");
-        assert.strictEqual(x.tickFormat(256)(x.ticks(256)[0]), "0.125");
-      }
-    },
-
-    "nice": {
-      "nices the domain, extending it to round numbers": function(linear) {
-        var x = linear().domain([1.1, 10.9]).nice();
-        assert.deepEqual(x.domain(), [1, 11]);
-        var x = linear().domain([10.9, 1.1]).nice();
-        assert.deepEqual(x.domain(), [11, 1]);
-        var x = linear().domain([.7, 11.001]).nice();
-        assert.deepEqual(x.domain(), [0, 12]);
-        var x = linear().domain([123.1, 6.7]).nice();
-        assert.deepEqual(x.domain(), [130, 0]);
-        var x = linear().domain([0, .49]).nice();
-        assert.deepEqual(x.domain(), [0, .5]);
-        var x = linear().domain([0, 0]).nice();
-        assert.deepEqual(x.domain(), [0, 0]);
-        var x = linear().domain([.5, .5]).nice();
-        assert.deepEqual(x.domain(), [.5, .5]);
-      },
-      "nicing a polylinear domain only affects the extent": function(linear) {
-        var x = linear().domain([1.1, 1, 2, 3, 10.9]).nice();
-        assert.deepEqual(x.domain(), [1, 1, 2, 3, 11]);
-        var x = linear().domain([123.1, 1, 2, 3, -.9]).nice();
-        assert.deepEqual(x.domain(), [130, 1, 2, 3, -10]);
-      }
-    },
-
-    "copy": {
-      "changes to the domain are isolated": function(linear) {
-        var x = linear(), 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(linear) {
-        var x = linear(), 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 interpolator are isolated": function(linear) {
-        var x = linear().range(["red", "blue"]), y = x.copy();
-        x.interpolate(d3.interpolateHsl);
-        assert.equal(x(0.5), "#00ff00");
-        assert.equal(y(0.5), "#800080");
-        assert.equal(y.interpolate(), d3.interpolate);
-      },
-      "changes to clamping are isolated": function(linear) {
-        var x = linear().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);