d3js-plugins-rails 0.0.2 → 0.0.3

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/eisenlohr-test.js

@@ -0,0 +1,34 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.eisenlohr");
+
+suite.addBatch({
+  "eisenlohr": {
+    topic: d3.geo.eisenlohr,
+    "projections and inverse projections": function(eisenlohr) {
+      assert.equalInverse(eisenlohr, [  0,   0], [480,         250]);
+      assert.equalInverse(eisenlohr, [  0, -45], [480,         377.392745]);
+      assert.equalInverse(eisenlohr, [  0,  45], [480,         122.607254]);
+      assert.equalInverse(eisenlohr, [  0,  90], [480,        -125.237349]);
+      assert.equalInverse(eisenlohr, [  0,  80], [480,         -35.291289]);
+      assert.equalInverse(eisenlohr, [-90,   0], [211.729605,  250]);
+      assert.equalInverse(eisenlohr, [ 90,   0], [748.270394,  250]);
+      assert.equalInverse(eisenlohr, [-80,  15], [251.382362,  196.991404]);
+      assert.equalInverse(eisenlohr, [  1,   1], [482.617916,  247.381795]);
+      assert.equalInverse(eisenlohr, [ 15,  80], [497.624439,  -36.694591]);
+      assert.equalInverse(eisenlohr, [100,  50], [728.016830,   33.813625]);
+      assert.equalInverse(eisenlohr, [179,  80], [562.029382, -249.246945]);
+      assert.equalInverse(eisenlohr, [179,  89], [482.929745, -140.157928]);
+      assert.equalInverse(eisenlohr, [180,   0], [1411.685689, 250]);
+      assert.equalInverse(eisenlohr, [180,  60], [842.900816, -348.742594]);
+      assert.equalInverse(eisenlohr, [180,  80], [560.323951, -251.261143]);
+      assert.equalInverse(eisenlohr, [180,  89], [482.673656, -140.229826]);
+      assert.inDelta(eisenlohr.invert([480 + 6 * 3, 250 - 126 * 3]), [108.053239, 88.652617], 1e-6);
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/env.js

@@ -9,11 +9,12 @@ assert.inDelta = function(actual, expected, delta, message) {
   }
 };
 
-assert.equalInverse = function(projection, location, point) {
+assert.equalInverse = function(projection, location, point, delta) {
+  delta = delta || 1e-6;
   var projected;
-  assert.inDelta(projected = projection(location), point, 1e-6);
-  assert.inDelta(projection.invert(projected), location, 1e-6);
-  assert.inDelta(projection(projection.invert(point)), point, 1e-6);
+  assert.inDelta(projected = projection(location), point, delta);
+  assert.inDelta(projection.invert(projected), location, delta);
+  assert.inDelta(projection(projection.invert(point)), point, delta);
 };
 
 function inDelta(actual, expected, delta) {

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/fahey-test.js

@@ -0,0 +1,25 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.fahey");
+
+suite.addBatch({
+  "fahey": {
+    topic: d3.geo.fahey,
+    "projections and inverse projections": function(fahey) {
+      assert.equalInverse(fahey, [   0,   0], [480,        250]);
+      assert.equalInverse(fahey, [   0, -90], [480,        522.872806]);
+      assert.equalInverse(fahey, [   0,  90], [480,        -22.872806]);
+      assert.equalInverse(fahey, [   0, -45], [480,        363.027617]);
+      assert.equalInverse(fahey, [   0,  45], [480,        136.972382]);
+      assert.equalInverse(fahey, [-180,   0], [ 93.983693, 250]);
+      assert.equalInverse(fahey, [ 180,   0], [866.016306, 250]);
+      assert.equalInverse(fahey, [-179,  15], [ 99.469475, 214.075613]);
+      assert.equalInverse(fahey, [   1,   1], [482.144453, 247.618675]);
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/guyou-test.js

@@ -0,0 +1,26 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.guyou");
+
+suite.addBatch({
+  "guyou": {
+    topic: d3.geo.guyou,
+    "projections and inverse projections": function(guyou) {
+      assert.equalInverse(guyou, [  0,   0], [480,        250]);
+      assert.equalInverse(guyou, [  0, -45], [480,        487.382], 1e-3);
+      assert.equalInverse(guyou, [  0,  45], [480,         12.6172], 1e-4);
+      assert.equalInverse(guyou, [-90,   0], [242.617240, 250]);
+      assert.equalInverse(guyou, [ 90,   0], [717.382759, 250]);
+      assert.equalInverse(guyou, [ 45,   0], [611.625205, 250]);
+      assert.equalInverse(guyou, [-80,  15], [264.628233, 216.032299]);
+      assert.equalInverse(guyou, [  1,   1], [483.160518, 246.839962]);
+      assert.equalInverse(guyou, [ 15,  45], [561.412842,  86.826667]);
+      assert.equalInverse(guyou, [180, -60], [823.140312, 487.382759], 1e-4);
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/hammer-retroazimuthal-test.js

@@ -0,0 +1,39 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.hammerRetroazimuthal");
+
+suite.addBatch({
+  "hammerRetroazimuthal": {
+    "0° parallel": {
+      topic: d3.geo.hammerRetroazimuthal,
+      "projections and inverse projections": function(hammerRetroazimuthal) {
+        assert.equalInverse(hammerRetroazimuthal, [  0,   0], [480,        250]);
+        assert.equalInverse(hammerRetroazimuthal, [  0, -45], [480,        367.809724]);
+        assert.equalInverse(hammerRetroazimuthal, [  0,  45], [480,        132.190275]);
+        assert.equalInverse(hammerRetroazimuthal, [-80,  15], [269.878429, 240.410727]);
+        assert.equalInverse(hammerRetroazimuthal, [  1,   1], [482.618126, 247.382271]);
+        assert.equalInverse(hammerRetroazimuthal, [ 15,  45], [523.527397, 135.133006]);
+        assert.equalInverse(hammerRetroazimuthal, [120,  30], [770.915361, 166.019968]);
+      }
+    },
+    "30° parallel": {
+      topic: function() {
+        return d3.geo.hammerRetroazimuthal().parallel(30);
+      },
+      "projections and inverse projections": function(hammerRetroazimuthal) {
+        assert.equalInverse(hammerRetroazimuthal, [  0,   0], [480,        328.539816]);
+        assert.equalInverse(hammerRetroazimuthal, [  0, -45], [480,        446.349540]);
+        assert.equalInverse(hammerRetroazimuthal, [  0,  45], [480,        210.730091]);
+        assert.equalInverse(hammerRetroazimuthal, [-80,  15], [308.029420, 339.535421]);
+        assert.equalInverse(hammerRetroazimuthal, [  1,   1], [482.367018, 325.925728]);
+        assert.equalInverse(hammerRetroazimuthal, [ 15,  45], [514.251164, 213.638684]);
+        assert.equalInverse(hammerRetroazimuthal, [120,  30], [672.322402,  83.443914]);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/lagrange-test.js

@@ -0,0 +1,59 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.lagrange");
+
+suite.addBatch({
+  "lagrange": {
+    "spacing(.5)": {
+      topic: d3.geo.lagrange,
+      "projections and inverse projections": function(lagrange) {
+        assert.equalInverse(lagrange, [  0,   0], [480,        250]);
+        assert.equalInverse(lagrange, [  0, -45], [480,        315.053600]);
+        assert.equalInverse(lagrange, [  0,  45], [480,        184.946399]);
+        assert.equalInverse(lagrange, [  0,  90], [480,        -50]);
+        assert.equalInverse(lagrange, [  0,  80], [480,         86.960158]);
+        assert.equalInverse(lagrange, [-90,   0], [355.735931, 250]);
+        assert.equalInverse(lagrange, [ 90,   0], [604.264068, 250]);
+        assert.equalInverse(lagrange, [-80,  15], [371.349124, 227.551283]);
+        assert.equalInverse(lagrange, [  1,   1], [481.308980, 248.690919]);
+        assert.equalInverse(lagrange, [ 15,  45], [498.734660, 184.680127]);
+        assert.equalInverse(lagrange, [ 15,  80], [493.837895,  86.467244]);
+        assert.equalInverse(lagrange, [ 15,  89], [486.127550,   0.928863]);
+        assert.equalInverse(lagrange, [ 45,  89], [498.157041,  -1.732667]);
+        assert.equalInverse(lagrange, [150,  89], [531.217097, -31.323054]);
+        assert.equalInverse(lagrange, [-150, 89], [428.782902, -31.323054]);
+        assert.equalInverse(lagrange, [-179, 89], [424.526070, -44.333441]);
+        assert.equalInverse(lagrange, [0,  89.9], [480,        -32.784034]);
+      }
+    },
+    "spacing(.25)": {
+      topic: function() {
+        return d3.geo.lagrange().spacing(.25);
+      },
+      "projections and inverse projections": function(lagrange) {
+        assert.equalInverse(lagrange, [  0,   0], [480,        250]);
+        assert.equalInverse(lagrange, [  0, -45], [480,        282.918431]);
+        assert.equalInverse(lagrange, [  0,  45], [480,        217.081568]);
+        assert.equalInverse(lagrange, [  0,  90], [480,        -50]);
+        assert.equalInverse(lagrange, [  0,  80], [480,        161.363985]);
+        assert.equalInverse(lagrange, [-90,   0], [420.326289, 250]);
+        assert.equalInverse(lagrange, [ 90,   0], [539.673710, 250]);
+        assert.equalInverse(lagrange, [-80,  15], [427.161636, 239.763718]);
+        assert.equalInverse(lagrange, [  1,   1], [480.654496, 249.345466]);
+        assert.equalInverse(lagrange, [ 15,  45], [489.702610, 217.046715]);
+        assert.equalInverse(lagrange, [ 15,  80], [488.962844, 161.277295]);
+        assert.equalInverse(lagrange, [ 15,  89], [487.041237,  90.333761]);
+        assert.equalInverse(lagrange, [ 45,  89], [501.132716,  89.349438]);
+        assert.equalInverse(lagrange, [150,  89], [550.729469,  77.687845]);
+        assert.equalInverse(lagrange, [-150, 89], [409.270530,  77.687845]);
+        assert.equalInverse(lagrange, [-179, 89], [395.481107,  71.952986]);
+        assert.equalInverse(lagrange, [0,  89.9], [480,         37.999854]);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/loximuthal-test.js

@@ -16,7 +16,7 @@ suite.addBatch({
       assert.equalInverse(loximuthal, [   0,  45], [480,        132.190275]);
       assert.equalInverse(loximuthal, [-180,   0], [ 48.773559, 250]);
       assert.equalInverse(loximuthal, [ 180,   0], [911.226440, 250]);
-      assert.equalInverse(loximuthal, [-179,  15], [69.4643149, 210.730091]);
+      assert.equalInverse(loximuthal, [-179,  15], [ 69.464314, 210.730091]);
       assert.equalInverse(loximuthal, [   1,   1], [482.390500, 247.382006]);
     }
   }

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/modified-stereographic-test.js

@@ -0,0 +1,24 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.modifiedStereographic");
+
+suite.addBatch({
+  "modifiedStereographic": {
+    topic: d3.geo.modifiedStereographic,
+    "projections and inverse projections": function(modifiedStereographic) {
+      assert.equalInverse(modifiedStereographic, [  0,   0], [480,        250]);
+      assert.equalInverse(modifiedStereographic, [  0, -45], [480,        363.225114]);
+      assert.equalInverse(modifiedStereographic, [  0,  45], [480,        136.774885]);
+      assert.equalInverse(modifiedStereographic, [-90,   0], [179.334000, 250]);
+      assert.equalInverse(modifiedStereographic, [ 90,   0], [780.666000, 250]);
+      assert.equalInverse(modifiedStereographic, [-80,  15], [244.261692, 178.493228]);
+      assert.equalInverse(modifiedStereographic, [  1,   1], [482.420181, 247.579387]);
+      assert.equalInverse(modifiedStereographic, [ 15,  45], [508.846677, 134.854913]);
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/peirce-quincuncial-test.js

@@ -0,0 +1,24 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.peirceQuincuncial");
+
+suite.addBatch({
+  "peirceQuincuncial": {
+    topic: d3.geo.peirceQuincuncial,
+    "projections and inverse projections": function(peirceQuincuncial) {
+      assert.inDelta(peirceQuincuncial([0, 90]), [480, 250], 1e-6);
+      assert.equalInverse(peirceQuincuncial, [  0,   0], [480,        585.709], 1e-2);
+      assert.equalInverse(peirceQuincuncial, [-90,   0], [144.290082, 250], 1e-5);
+      assert.equalInverse(peirceQuincuncial, [ 90,   0], [815.709915, 250], 1e-1);
+      assert.equalInverse(peirceQuincuncial, [ 45,   0], [647.854958, 417.854958]);
+      assert.equalInverse(peirceQuincuncial, [-80,  15], [282.302142, 290.470613]);
+      assert.equalInverse(peirceQuincuncial, [  1,   1], [495.393500, 548.541114]);
+      assert.equalInverse(peirceQuincuncial, [ 15,  45], [507.756185, 352.529945]);
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/polyconic-test.js

@@ -0,0 +1,26 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.polyconic");
+
+suite.addBatch({
+  "polyconic": {
+    topic: d3.geo.polyconic,
+    "projections and inverse projections": function(polyconic) {
+      assert.equalInverse(polyconic, [  0,   0], [480,        250]);
+      assert.equalInverse(polyconic, [  0, -45], [480,        367.809724]);
+      assert.equalInverse(polyconic, [  0,  45], [480,        132.190275]);
+      assert.equalInverse(polyconic, [-90,   0], [244.380550, 250]);
+      assert.equalInverse(polyconic, [ 90,   0], [715.619449, 250]);
+      assert.equalInverse(polyconic, [-80,  15], [282.071605, 174.572089]);
+      assert.equalInverse(polyconic, [120,  15], [768.810227, 130.477707]);
+      assert.equalInverse(polyconic, [  1,   1], [482.617595, 247.381607]);
+      assert.equalInverse(polyconic, [ 15,  45], [507.609690, 129.627397]);
+      assert.equalInverse(polyconic,[-179,  45], [359.533865,-107.184834]);
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/rectangular-polyconic-test.js

@@ -0,0 +1,48 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.rectangularPolyconic");
+
+suite.addBatch({
+  "rectangularPolyconic": {
+    "0° parallel": {
+      topic: d3.geo.rectangularPolyconic,
+      "projections and inverse projections": function(rectangularPolyconic) {
+        assert.equalInverse(rectangularPolyconic, [  0,   0], [480,        250]);
+        assert.equalInverse(rectangularPolyconic, [  0, -45], [480,        367.809724]);
+        assert.equalInverse(rectangularPolyconic, [  0,  45], [480,        132.190275]);
+        assert.equalInverse(rectangularPolyconic, [-90,   0], [244.380550, 250]);
+        assert.equalInverse(rectangularPolyconic, [ 90,   0], [715.619449, 250]);
+        assert.equalInverse(rectangularPolyconic, [-80,  15], [284.093092, 175.331715]);
+        assert.equalInverse(rectangularPolyconic, [  1,   1], [482.617595, 247.381607]);
+        assert.equalInverse(rectangularPolyconic, [ 15,  45], [507.532140, 129.641898]);
+        assert.equalInverse(rectangularPolyconic, [120,  45], [623.475113,  25.949753]);
+        assert.equalInverse(rectangularPolyconic, [150,   5], [866.178341, 192.852256]);
+        assert.equalInverse(rectangularPolyconic, [179,   5], [938.342281, 174.509780]);
+        assert.equalInverse(rectangularPolyconic, [179,  85], [491.937069,   8.894941]);
+      }
+    },
+    "30° parallel": {
+      topic: function() {
+        return d3.geo.rectangularPolyconic().parallel(30);
+      },
+      "projections and inverse projections": function(rectangularPolyconic) {
+        assert.equalInverse(rectangularPolyconic, [  0,   0], [480,        250]);
+        assert.equalInverse(rectangularPolyconic, [  0, -45], [480,        367.809724]);
+        assert.equalInverse(rectangularPolyconic, [  0,  45], [480,        132.190275]);
+        assert.equalInverse(rectangularPolyconic, [-90,   0], [231.471862, 250]);
+        assert.equalInverse(rectangularPolyconic, [ 90,   0], [728.528137, 250]);
+        assert.equalInverse(rectangularPolyconic, [-80,  15], [276.290019, 172.350142]);
+        assert.equalInverse(rectangularPolyconic, [  1,   1], [482.617611, 247.381607]);
+        assert.equalInverse(rectangularPolyconic, [ 15,  45], [507.570850, 129.634665]);
+        assert.equalInverse(rectangularPolyconic, [120,  45], [626.969384,  12.190275]);
+        assert.equalInverse(rectangularPolyconic, [150,   5], [930.583263, 176.642758]);
+        assert.equalInverse(rectangularPolyconic, [179,   5],[1055.344304, 137.492301]);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/times-test.js

@@ -0,0 +1,24 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.times");
+
+suite.addBatch({
+  "times": {
+    topic: d3.geo.times,
+    "projections and inverse projections": function(times) {
+      assert.equalInverse(times, [  0,   0], [480,        250]);
+      assert.equalInverse(times, [  0, -45], [480,        356.066217]);
+      assert.equalInverse(times, [  0,  45], [480,        143.933782]);
+      assert.equalInverse(times, [-90,   0], [304.505921, 250]);
+      assert.equalInverse(times, [ 90,   0], [655.494078, 250]);
+      assert.equalInverse(times, [-80,  15], [324.777008, 216.288205]);
+      assert.equalInverse(times, [  1,   1], [481.949891, 247.765341]);
+      assert.equalInverse(times, [ 15,  45], [507.861496, 143.933782]);
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/two-point-azimuthal-test.js

@@ -0,0 +1,22 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.twoPointAzimuthal");
+
+suite.addBatch({
+  "twoPointAzimuthal": {
+    topic: d3.geo.twoPointAzimuthal,
+    "projections and inverse projections": function(twoPointAzimuthal) {
+      assert.equalInverse(twoPointAzimuthal, [  0,   0], [ 480,        250]);
+      assert.equalInverse(twoPointAzimuthal, [  0, -45], [ 480,        400]);
+      assert.equalInverse(twoPointAzimuthal, [  0,  45], [ 480,        100]);
+      assert.equalInverse(twoPointAzimuthal, [-80,  15], [-370.692272,  18.541314]);
+      assert.equalInverse(twoPointAzimuthal, [  1,   1], [ 482.618259, 247.381341]);
+      assert.equalInverse(twoPointAzimuthal, [ 15,  45], [ 520.192378,  94.708572]);
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/two-point-equidistant-test.js

@@ -0,0 +1,24 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.twoPointEquidistant");
+
+suite.addBatch({
+  "twoPointEquidistant": {
+    topic: function() {
+      return d3.geo.twoPointEquidistant().points([[-158, 21.5], [-77, 39]]);
+    },
+    "projections and inverse projections": function(twoPointEquidistant) {
+      assert.equalInverse(twoPointEquidistant, [  0,   0], [779.584187, 227.923736]);
+      assert.equalInverse(twoPointEquidistant, [  0, -45], [681.938143, 512.400576]);
+      assert.equalInverse(twoPointEquidistant, [  0,  45], [651.469553, 129.175958]);
+      assert.equalInverse(twoPointEquidistant, [-80,  15], [570.636740, 313.204406]);
+      assert.equalInverse(twoPointEquidistant, [  1,   1], [778.820119, 219.170442]);
+      assert.equalInverse(twoPointEquidistant, [ 15,  45], [641.328901,  95.403073]);
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/van-der-grinten2-test.js

@@ -0,0 +1,24 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.vanDerGrinten2");
+
+suite.addBatch({
+  "vanDerGrinten2": {
+    topic: d3.geo.vanDerGrinten2,
+    "projections and inverse projections": function(vanDerGrinten2) {
+      assert.equalInverse(vanDerGrinten2, [  0,   0], [480,        250]);
+      assert.equalInverse(vanDerGrinten2, [  0, -45], [480,        376.268082]);
+      assert.equalInverse(vanDerGrinten2, [  0,  45], [480,        123.731917]);
+      assert.equalInverse(vanDerGrinten2, [-90,   0], [244.380550, 250]);
+      assert.equalInverse(vanDerGrinten2, [ 90,   0], [715.619449, 250]);
+      assert.equalInverse(vanDerGrinten2, [-80,  15], [272.324393, 202.707670]);
+      assert.equalInverse(vanDerGrinten2, [  1,   1], [482.617913, 247.381844]);
+      assert.equalInverse(vanDerGrinten2, [ 15,  45], [516.432290, 122.918417]);
+    }
+  }
+});
+
+suite.export(module);