mdarray-sol 0.1.0-java

data/node_modules/dc/node_modules/d3/src/geo/clip-polygon.js

@@ -0,0 +1,104 @@
+import "../math/trigonometry";
+import "spherical";
+
+// General spherical polygon clipping algorithm: takes a polygon, cuts it into
+// visible line segments and rejoins the segments by interpolating along the
+// clip edge.
+function d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener) {
+  var subject = [],
+      clip = [];
+
+  segments.forEach(function(segment) {
+    if ((n = segment.length - 1) <= 0) return;
+    var n, p0 = segment[0], p1 = segment[n];
+
+    // If the first and last points of a segment are coincident, then treat as
+    // a closed ring.
+    // TODO if all rings are closed, then the winding order of the exterior
+    // ring should be checked.
+    if (d3_geo_sphericalEqual(p0, p1)) {
+      listener.lineStart();
+      for (var i = 0; i < n; ++i) listener.point((p0 = segment[i])[0], p0[1]);
+      listener.lineEnd();
+      return;
+    }
+
+    var a = new d3_geo_clipPolygonIntersection(p0, segment, null, true),
+        b = new d3_geo_clipPolygonIntersection(p0, null, a, false);
+    a.o = b;
+    subject.push(a);
+    clip.push(b);
+    a = new d3_geo_clipPolygonIntersection(p1, segment, null, false);
+    b = new d3_geo_clipPolygonIntersection(p1, null, a, true);
+    a.o = b;
+    subject.push(a);
+    clip.push(b);
+  });
+  clip.sort(compare);
+  d3_geo_clipPolygonLinkCircular(subject);
+  d3_geo_clipPolygonLinkCircular(clip);
+  if (!subject.length) return;
+
+  for (var i = 0, entry = clipStartInside, n = clip.length; i < n; ++i) {
+    clip[i].e = entry = !entry;
+  }
+
+  var start = subject[0],
+      points,
+      point;
+  while (1) {
+    // Find first unvisited intersection.
+    var current = start,
+        isSubject = true;
+    while (current.v) if ((current = current.n) === start) return;
+    points = current.z;
+    listener.lineStart();
+    do {
+      current.v = current.o.v = true;
+      if (current.e) {
+        if (isSubject) {
+          for (var i = 0, n = points.length; i < n; ++i) listener.point((point = points[i])[0], point[1]);
+        } else {
+          interpolate(current.x, current.n.x, 1, listener);
+        }
+        current = current.n;
+      } else {
+        if (isSubject) {
+          points = current.p.z;
+          for (var i = points.length - 1; i >= 0; --i) listener.point((point = points[i])[0], point[1]);
+        } else {
+          interpolate(current.x, current.p.x, -1, listener);
+        }
+        current = current.p;
+      }
+      current = current.o;
+      points = current.z;
+      isSubject = !isSubject;
+    } while (!current.v);
+    listener.lineEnd();
+  }
+}
+
+function d3_geo_clipPolygonLinkCircular(array) {
+  if (!(n = array.length)) return;
+  var n,
+      i = 0,
+      a = array[0],
+      b;
+  while (++i < n) {
+    a.n = b = array[i];
+    b.p = a;
+    a = b;
+  }
+  a.n = b = array[0];
+  b.p = a;
+}
+
+function d3_geo_clipPolygonIntersection(point, points, other, entry) {
+  this.x = point;
+  this.z = points;
+  this.o = other; // another intersection
+  this.e = entry; // is an entry?
+  this.v = false; // visited
+  this.n = this.p = null; // next & previous
+}

data/node_modules/dc/node_modules/d3/src/geo/clip.js

@@ -0,0 +1,149 @@
+import "../arrays/merge";
+import "../core/noop";
+import "../math/trigonometry";
+import "clip-polygon";
+
+function d3_geo_clip(pointVisible, clipLine, interpolate, clipStart) {
+  return function(rotate, listener) {
+    var line = clipLine(listener),
+        rotatedClipStart = rotate.invert(clipStart[0], clipStart[1]);
+
+    var clip = {
+      point: point,
+      lineStart: lineStart,
+      lineEnd: lineEnd,
+      polygonStart: function() {
+        clip.point = pointRing;
+        clip.lineStart = ringStart;
+        clip.lineEnd = ringEnd;
+        segments = [];
+        polygon = [];
+      },
+      polygonEnd: function() {
+        clip.point = point;
+        clip.lineStart = lineStart;
+        clip.lineEnd = lineEnd;
+
+        segments = d3.merge(segments);
+        var clipStartInside = d3_geo_pointInPolygon(rotatedClipStart, polygon);
+        if (segments.length) {
+          if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
+          d3_geo_clipPolygon(segments, d3_geo_clipSort, clipStartInside, interpolate, listener);
+        } else if (clipStartInside) {
+          if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
+          listener.lineStart();
+          interpolate(null, null, 1, listener);
+          listener.lineEnd();
+        }
+        if (polygonStarted) listener.polygonEnd(), polygonStarted = false;
+        segments = polygon = null;
+      },
+      sphere: function() {
+        listener.polygonStart();
+        listener.lineStart();
+        interpolate(null, null, 1, listener);
+        listener.lineEnd();
+        listener.polygonEnd();
+      }
+    };
+
+    function point(λ, φ) {
+      var point = rotate(λ, φ);
+      if (pointVisible(λ = point[0], φ = point[1])) listener.point(λ, φ);
+    }
+    function pointLine(λ, φ) {
+      var point = rotate(λ, φ);
+      line.point(point[0], point[1]);
+    }
+    function lineStart() { clip.point = pointLine; line.lineStart(); }
+    function lineEnd() { clip.point = point; line.lineEnd(); }
+
+    var segments;
+
+    var buffer = d3_geo_clipBufferListener(),
+        ringListener = clipLine(buffer),
+        polygonStarted = false,
+        polygon,
+        ring;
+
+    function pointRing(λ, φ) {
+      ring.push([λ, φ]);
+      var point = rotate(λ, φ);
+      ringListener.point(point[0], point[1]);
+    }
+
+    function ringStart() {
+      ringListener.lineStart();
+      ring = [];
+    }
+
+    function ringEnd() {
+      pointRing(ring[0][0], ring[0][1]);
+      ringListener.lineEnd();
+
+      var clean = ringListener.clean(),
+          ringSegments = buffer.buffer(),
+          segment,
+          n = ringSegments.length;
+
+      ring.pop();
+      polygon.push(ring);
+      ring = null;
+
+      if (!n) return;
+
+      // No intersections.
+      if (clean & 1) {
+        segment = ringSegments[0];
+        var n = segment.length - 1,
+            i = -1,
+            point;
+        if (n > 0) {
+          if (!polygonStarted) listener.polygonStart(), polygonStarted = true;
+          listener.lineStart();
+          while (++i < n) listener.point((point = segment[i])[0], point[1]);
+          listener.lineEnd();
+        }
+        return;
+      }
+
+      // Rejoin connected segments.
+      // TODO reuse bufferListener.rejoin()?
+      if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));
+
+      segments.push(ringSegments.filter(d3_geo_clipSegmentLength1));
+    }
+
+    return clip;
+  };
+}
+
+function d3_geo_clipSegmentLength1(segment) {
+  return segment.length > 1;
+}
+
+function d3_geo_clipBufferListener() {
+  var lines = [],
+      line;
+  return {
+    lineStart: function() { lines.push(line = []); },
+    point: function(λ, φ) { line.push([λ, φ]); },
+    lineEnd: d3_noop,
+    buffer: function() {
+      var buffer = lines;
+      lines = [];
+      line = null;
+      return buffer;
+    },
+    rejoin: function() {
+      if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));
+    }
+  };
+}
+
+// Intersection points are sorted along the clip edge. For both antimeridian
+// cutting and circle clipping, the same comparison is used.
+function d3_geo_clipSort(a, b) {
+  return ((a = a.x)[0] < 0 ? a[1] - halfπ - ε : halfπ - a[1])
+       - ((b = b.x)[0] < 0 ? b[1] - halfπ - ε : halfπ - b[1]);
+}

data/node_modules/dc/node_modules/d3/src/geo/compose.js

@@ -0,0 +1,12 @@
+function d3_geo_compose(a, b) {
+
+  function compose(x, y) {
+    return x = a(x, y), b(x[0], x[1]);
+  }
+
+  if (a.invert && b.invert) compose.invert = function(x, y) {
+    return x = b.invert(x, y), x && a.invert(x[0], x[1]);
+  };
+
+  return compose;
+}

data/node_modules/dc/node_modules/d3/src/geo/conic-conformal.js

@@ -0,0 +1,39 @@
+import "../math/abs";
+import "../math/trigonometry";
+import "conic";
+import "geo";
+import "projection";
+
+function d3_geo_conicConformal(φ0, φ1) {
+  var cosφ0 = Math.cos(φ0),
+      t = function(φ) { return Math.tan(π / 4 + φ / 2); },
+      n = φ0 === φ1 ? Math.sin(φ0) : Math.log(cosφ0 / Math.cos(φ1)) / Math.log(t(φ1) / t(φ0)),
+      F = cosφ0 * Math.pow(t(φ0), n) / n;
+
+  if (!n) return d3_geo_mercator;
+
+  function forward(λ, φ) {
+    if (F > 0) { if (φ < -halfπ + ε) φ = -halfπ + ε; }
+    else { if (φ > halfπ - ε) φ = halfπ - ε; }
+    var ρ = F / Math.pow(t(φ), n);
+    return [
+      ρ * Math.sin(n * λ),
+      F - ρ * Math.cos(n * λ)
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    var ρ0_y = F - y,
+        ρ = d3_sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y);
+    return [
+      Math.atan2(x, ρ0_y) / n,
+      2 * Math.atan(Math.pow(F / ρ, 1 / n)) - halfπ
+    ];
+  };
+
+  return forward;
+}
+
+(d3.geo.conicConformal = function() {
+  return d3_geo_conic(d3_geo_conicConformal);
+}).raw = d3_geo_conicConformal;

data/node_modules/dc/node_modules/d3/src/geo/conic-equal-area.js

@@ -0,0 +1,33 @@
+import "../math/trigonometry";
+import "geo";
+import "conic";
+import "projection";
+
+function d3_geo_conicEqualArea(φ0, φ1) {
+  var sinφ0 = Math.sin(φ0),
+      n = (sinφ0 + Math.sin(φ1)) / 2,
+      C = 1 + sinφ0 * (2 * n - sinφ0),
+      ρ0 = Math.sqrt(C) / n;
+
+  function forward(λ, φ) {
+    var ρ = Math.sqrt(C - 2 * n * Math.sin(φ)) / n;
+    return [
+      ρ * Math.sin(λ *= n),
+      ρ0 - ρ * Math.cos(λ)
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    var ρ0_y = ρ0 - y;
+    return [
+      Math.atan2(x, ρ0_y) / n,
+      d3_asin((C - (x * x + ρ0_y * ρ0_y) * n * n) / (2 * n))
+    ];
+  };
+
+  return forward;
+}
+
+(d3.geo.conicEqualArea = function() {
+  return d3_geo_conic(d3_geo_conicEqualArea);
+}).raw = d3_geo_conicEqualArea;

data/node_modules/dc/node_modules/d3/src/geo/conic-equidistant.js

@@ -0,0 +1,36 @@
+import "../math/abs";
+import "../math/trigonometry";
+import "conic";
+import "equirectangular";
+import "geo";
+import "projection";
+
+function d3_geo_conicEquidistant(φ0, φ1) {
+  var cosφ0 = Math.cos(φ0),
+      n = φ0 === φ1 ? Math.sin(φ0) : (cosφ0 - Math.cos(φ1)) / (φ1 - φ0),
+      G = cosφ0 / n + φ0;
+
+  if (abs(n) < ε) return d3_geo_equirectangular;
+
+  function forward(λ, φ) {
+    var ρ = G - φ;
+    return [
+      ρ * Math.sin(n * λ),
+      G - ρ * Math.cos(n * λ)
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    var ρ0_y = G - y;
+    return [
+      Math.atan2(x, ρ0_y) / n,
+      G - d3_sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y)
+    ];
+  };
+
+  return forward;
+}
+
+(d3.geo.conicEquidistant = function() {
+  return d3_geo_conic(d3_geo_conicEquidistant);
+}).raw = d3_geo_conicEquidistant;

data/node_modules/dc/node_modules/d3/src/geo/conic.js

@@ -0,0 +1,16 @@
+import "../math/trigonometry";
+import "projection";
+
+function d3_geo_conic(projectAt) {
+  var φ0 = 0,
+      φ1 = π / 3,
+      m = d3_geo_projectionMutator(projectAt),
+      p = m(φ0, φ1);
+
+  p.parallels = function(_) {
+    if (!arguments.length) return [φ0 / π * 180, φ1 / π * 180];
+    return m(φ0 = _[0] * π / 180, φ1 = _[1] * π / 180);
+  };
+
+  return p;
+}

data/node_modules/dc/node_modules/d3/src/geo/distance.js

@@ -0,0 +1,13 @@
+import "../math/trigonometry";
+import "geo";
+
+// Length returned in radians; multiply by radius for distance.
+d3.geo.distance = function(a, b) {
+  var Δλ = (b[0] - a[0]) * d3_radians,
+      φ0 = a[1] * d3_radians, φ1 = b[1] * d3_radians,
+      sinΔλ = Math.sin(Δλ), cosΔλ = Math.cos(Δλ),
+      sinφ0 = Math.sin(φ0), cosφ0 = Math.cos(φ0),
+      sinφ1 = Math.sin(φ1), cosφ1 = Math.cos(φ1),
+      t;
+  return Math.atan2(Math.sqrt((t = cosφ1 * sinΔλ) * t + (t = cosφ0 * sinφ1 - sinφ0 * cosφ1 * cosΔλ) * t), sinφ0 * sinφ1 + cosφ0 * cosφ1 * cosΔλ);
+};

data/node_modules/dc/node_modules/d3/src/geo/equirectangular.js

@@ -0,0 +1,10 @@
+import "geo";
+import "projection";
+
+function d3_geo_equirectangular(λ, φ) {
+  return [λ, φ];
+}
+
+(d3.geo.equirectangular = function() {
+  return d3_geo_projection(d3_geo_equirectangular);
+}).raw = d3_geo_equirectangular.invert = d3_geo_equirectangular;

data/node_modules/dc/node_modules/d3/src/geo/geo.js

@@ -0,0 +1 @@
+d3.geo = {};

data/node_modules/dc/node_modules/d3/src/geo/gnomonic.js

@@ -0,0 +1,12 @@
+import "azimuthal";
+import "geo";
+import "projection";
+
+var d3_geo_gnomonic = d3_geo_azimuthal(
+  function(cosλcosφ) { return 1 / cosλcosφ; },
+  Math.atan
+);
+
+(d3.geo.gnomonic = function() {
+  return d3_geo_projection(d3_geo_gnomonic);
+}).raw = d3_geo_gnomonic;

data/node_modules/dc/node_modules/d3/src/geo/graticule.js

@@ -0,0 +1,103 @@
+import "../arrays/range";
+import "../math/abs";
+import "../math/trigonometry";
+import "geo";
+
+d3.geo.graticule = function() {
+  var x1, x0, X1, X0,
+      y1, y0, Y1, Y0,
+      dx = 10, dy = dx, DX = 90, DY = 360,
+      x, y, X, Y,
+      precision = 2.5;
+
+  function graticule() {
+    return {type: "MultiLineString", coordinates: lines()};
+  }
+
+  function lines() {
+    return d3.range(Math.ceil(X0 / DX) * DX, X1, DX).map(X)
+        .concat(d3.range(Math.ceil(Y0 / DY) * DY, Y1, DY).map(Y))
+        .concat(d3.range(Math.ceil(x0 / dx) * dx, x1, dx).filter(function(x) { return abs(x % DX) > ε; }).map(x))
+        .concat(d3.range(Math.ceil(y0 / dy) * dy, y1, dy).filter(function(y) { return abs(y % DY) > ε; }).map(y));
+  }
+
+  graticule.lines = function() {
+    return lines().map(function(coordinates) { return {type: "LineString", coordinates: coordinates}; });
+  };
+
+  graticule.outline = function() {
+    return {
+      type: "Polygon",
+      coordinates: [
+        X(X0).concat(
+        Y(Y1).slice(1),
+        X(X1).reverse().slice(1),
+        Y(Y0).reverse().slice(1))
+      ]
+    };
+  };
+
+  graticule.extent = function(_) {
+    if (!arguments.length) return graticule.minorExtent();
+    return graticule.majorExtent(_).minorExtent(_);
+  };
+
+  graticule.majorExtent = function(_) {
+    if (!arguments.length) return [[X0, Y0], [X1, Y1]];
+    X0 = +_[0][0], X1 = +_[1][0];
+    Y0 = +_[0][1], Y1 = +_[1][1];
+    if (X0 > X1) _ = X0, X0 = X1, X1 = _;
+    if (Y0 > Y1) _ = Y0, Y0 = Y1, Y1 = _;
+    return graticule.precision(precision);
+  };
+
+  graticule.minorExtent = function(_) {
+    if (!arguments.length) return [[x0, y0], [x1, y1]];
+    x0 = +_[0][0], x1 = +_[1][0];
+    y0 = +_[0][1], y1 = +_[1][1];
+    if (x0 > x1) _ = x0, x0 = x1, x1 = _;
+    if (y0 > y1) _ = y0, y0 = y1, y1 = _;
+    return graticule.precision(precision);
+  };
+
+  graticule.step = function(_) {
+    if (!arguments.length) return graticule.minorStep();
+    return graticule.majorStep(_).minorStep(_);
+  };
+
+  graticule.majorStep = function(_) {
+    if (!arguments.length) return [DX, DY];
+    DX = +_[0], DY = +_[1];
+    return graticule;
+  };
+
+  graticule.minorStep = function(_) {
+    if (!arguments.length) return [dx, dy];
+    dx = +_[0], dy = +_[1];
+    return graticule;
+  };
+
+  graticule.precision = function(_) {
+    if (!arguments.length) return precision;
+    precision = +_;
+    x = d3_geo_graticuleX(y0, y1, 90);
+    y = d3_geo_graticuleY(x0, x1, precision);
+    X = d3_geo_graticuleX(Y0, Y1, 90);
+    Y = d3_geo_graticuleY(X0, X1, precision);
+    return graticule;
+  };
+
+  return graticule
+      .majorExtent([[-180, -90 + ε], [180, 90 - ε]])
+      .minorExtent([[-180, -80 - ε], [180, 80 + ε]]);
+};
+
+function d3_geo_graticuleX(y0, y1, dy) {
+  var y = d3.range(y0, y1 - ε, dy).concat(y1);
+  return function(x) { return y.map(function(y) { return [x, y]; }); };
+}
+
+function d3_geo_graticuleY(x0, x1, dx) {
+  var x = d3.range(x0, x1 - ε, dx).concat(x1);
+  return function(y) { return x.map(function(x) { return [x, y]; }); };
+}