mdarray-sol 0.1.0-java

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

@@ -0,0 +1,42 @@
+import "../core/source";
+import "../core/target";
+import "geo";
+import "distance";
+
+// @deprecated use {type: "LineString"} or d3.geo.distance instead.
+d3.geo.greatArc = function() {
+  var source = d3_source, source_,
+      target = d3_target, target_;
+
+  function greatArc() {
+    return {type: "LineString", coordinates: [
+      source_ || source.apply(this, arguments),
+      target_ || target.apply(this, arguments)
+    ]};
+  }
+
+  greatArc.distance = function() {
+    return d3.geo.distance(
+      source_ || source.apply(this, arguments),
+      target_ || target.apply(this, arguments)
+    );
+  };
+
+  greatArc.source = function(_) {
+    if (!arguments.length) return source;
+    source = _, source_ = typeof _ === "function" ? null : _;
+    return greatArc;
+  };
+
+  greatArc.target = function(_) {
+    if (!arguments.length) return target;
+    target = _, target_ = typeof _ === "function" ? null : _;
+    return greatArc;
+  };
+
+  greatArc.precision = function() {
+    return arguments.length ? greatArc : 0;
+  };
+
+  return greatArc;
+};

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

@@ -0,0 +1,33 @@
+import "geo";
+import "area";
+import "bounds";
+import "centroid";
+import "circle";
+import "distance";
+import "graticule";
+import "greatArc";
+import "interpolate";
+import "length";
+import "path";
+import "path-area";
+import "path-buffer";
+import "path-centroid";
+import "path-context";
+import "projection";
+import "rotation";
+import "stream";
+import "transform";
+import "albers";
+import "albers-usa";
+import "azimuthal";
+import "azimuthal-equal-area";
+import "azimuthal-equidistant";
+import "conic-conformal";
+import "conic-equal-area";
+import "conic-equidistant";
+import "equirectangular";
+import "gnomonic";
+import "mercator";
+import "orthographic";
+import "stereographic";
+import "transverse-mercator";

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

@@ -0,0 +1,38 @@
+import "../math/trigonometry";
+import "geo";
+
+d3.geo.interpolate = function(source, target) {
+  return d3_geo_interpolate(
+    source[0] * d3_radians, source[1] * d3_radians,
+    target[0] * d3_radians, target[1] * d3_radians
+  );
+};
+
+function d3_geo_interpolate(x0, y0, x1, y1) {
+  var cy0 = Math.cos(y0),
+      sy0 = Math.sin(y0),
+      cy1 = Math.cos(y1),
+      sy1 = Math.sin(y1),
+      kx0 = cy0 * Math.cos(x0),
+      ky0 = cy0 * Math.sin(x0),
+      kx1 = cy1 * Math.cos(x1),
+      ky1 = cy1 * Math.sin(x1),
+      d = 2 * Math.asin(Math.sqrt(d3_haversin(y1 - y0) + cy0 * cy1 * d3_haversin(x1 - x0))),
+      k = 1 / Math.sin(d);
+
+  var interpolate = d ? function(t) {
+    var B = Math.sin(t *= d) * k,
+        A = Math.sin(d - t) * k,
+        x = A * kx0 + B * kx1,
+        y = A * ky0 + B * ky1,
+        z = A * sy0 + B * sy1;
+    return [
+      Math.atan2(y, x) * d3_degrees,
+      Math.atan2(z, Math.sqrt(x * x + y * y)) * d3_degrees
+    ];
+  } : function() { return [x0 * d3_degrees, y0 * d3_degrees]; };
+
+  interpolate.distance = d;
+
+  return interpolate;
+};

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

@@ -0,0 +1,44 @@
+import "../core/noop";
+import "../math/abs";
+import "../math/trigonometry";
+import "geo";
+import "stream";
+
+d3.geo.length = function(object) {
+  d3_geo_lengthSum = 0;
+  d3.geo.stream(object, d3_geo_length);
+  return d3_geo_lengthSum;
+};
+
+var d3_geo_lengthSum;
+
+var d3_geo_length = {
+  sphere: d3_noop,
+  point: d3_noop,
+  lineStart: d3_geo_lengthLineStart,
+  lineEnd: d3_noop,
+  polygonStart: d3_noop,
+  polygonEnd: d3_noop
+};
+
+function d3_geo_lengthLineStart() {
+  var λ0, sinφ0, cosφ0;
+
+  d3_geo_length.point = function(λ, φ) {
+    λ0 = λ * d3_radians, sinφ0 = Math.sin(φ *= d3_radians), cosφ0 = Math.cos(φ);
+    d3_geo_length.point = nextPoint;
+  };
+
+  d3_geo_length.lineEnd = function() {
+    d3_geo_length.point = d3_geo_length.lineEnd = d3_noop;
+  };
+
+  function nextPoint(λ, φ) {
+    var sinφ = Math.sin(φ *= d3_radians),
+        cosφ = Math.cos(φ),
+        t = abs((λ *= d3_radians) - λ0),
+        cosΔλ = Math.cos(t);
+    d3_geo_lengthSum += Math.atan2(Math.sqrt((t = cosφ * Math.sin(t)) * t + (t = cosφ0 * sinφ - sinφ0 * cosφ * cosΔλ) * t), sinφ0 * sinφ + cosφ0 * cosφ * cosΔλ);
+    λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ;
+  }
+}

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

@@ -0,0 +1,48 @@
+import "../math/trigonometry";
+import "geo";
+import "projection";
+
+function d3_geo_mercator(λ, φ) {
+  return [λ, Math.log(Math.tan(π / 4 + φ / 2))];
+}
+
+d3_geo_mercator.invert = function(x, y) {
+  return [x, 2 * Math.atan(Math.exp(y)) - halfπ];
+};
+
+function d3_geo_mercatorProjection(project) {
+  var m = d3_geo_projection(project),
+      scale = m.scale,
+      translate = m.translate,
+      clipExtent = m.clipExtent,
+      clipAuto;
+
+  m.scale = function() {
+    var v = scale.apply(m, arguments);
+    return v === m ? (clipAuto ? m.clipExtent(null) : m) : v;
+  };
+
+  m.translate = function() {
+    var v = translate.apply(m, arguments);
+    return v === m ? (clipAuto ? m.clipExtent(null) : m) : v;
+  };
+
+  m.clipExtent = function(_) {
+    var v = clipExtent.apply(m, arguments);
+    if (v === m) {
+      if (clipAuto = _ == null) {
+        var k = π * scale(), t = translate();
+        clipExtent([[t[0] - k, t[1] - k], [t[0] + k, t[1] + k]]);
+      }
+    } else if (clipAuto) {
+      v = null;
+    }
+    return v;
+  };
+
+  return m.clipExtent(null);
+}
+
+(d3.geo.mercator = function() {
+  return d3_geo_mercatorProjection(d3_geo_mercator);
+}).raw = d3_geo_mercator;

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

@@ -0,0 +1,12 @@
+import "azimuthal";
+import "geo";
+import "projection";
+
+var d3_geo_orthographic = d3_geo_azimuthal(
+  function() { return 1; },
+  Math.asin
+);
+
+(d3.geo.orthographic = function() {
+  return d3_geo_projection(d3_geo_orthographic);
+}).raw = d3_geo_orthographic;

data/node_modules/dc/node_modules/d3/src/geo/path-area.js

@@ -0,0 +1,41 @@
+import "../core/noop";
+import "../math/abs";
+
+// TODO Unify this code with d3.geom.polygon area?
+
+var d3_geo_pathAreaSum, d3_geo_pathAreaPolygon, d3_geo_pathArea = {
+  point: d3_noop,
+  lineStart: d3_noop,
+  lineEnd: d3_noop,
+
+  // Only count area for polygon rings.
+  polygonStart: function() {
+    d3_geo_pathAreaPolygon = 0;
+    d3_geo_pathArea.lineStart = d3_geo_pathAreaRingStart;
+  },
+  polygonEnd: function() {
+    d3_geo_pathArea.lineStart = d3_geo_pathArea.lineEnd = d3_geo_pathArea.point = d3_noop;
+    d3_geo_pathAreaSum += abs(d3_geo_pathAreaPolygon / 2);
+  }
+};
+
+function d3_geo_pathAreaRingStart() {
+  var x00, y00, x0, y0;
+
+  // For the first point, …
+  d3_geo_pathArea.point = function(x, y) {
+    d3_geo_pathArea.point = nextPoint;
+    x00 = x0 = x, y00 = y0 = y;
+  };
+
+  // For subsequent points, …
+  function nextPoint(x, y) {
+    d3_geo_pathAreaPolygon += y0 * x - x0 * y;
+    x0 = x, y0 = y;
+  }
+
+  // For the last point, return to the start.
+  d3_geo_pathArea.lineEnd = function() {
+    nextPoint(x00, y00);
+  };
+}

data/node_modules/dc/node_modules/d3/src/geo/path-bounds.js

@@ -0,0 +1,21 @@
+import "../core/noop";
+
+var d3_geo_pathBoundsX0,
+    d3_geo_pathBoundsY0,
+    d3_geo_pathBoundsX1,
+    d3_geo_pathBoundsY1;
+
+var d3_geo_pathBounds = {
+  point: d3_geo_pathBoundsPoint,
+  lineStart: d3_noop,
+  lineEnd: d3_noop,
+  polygonStart: d3_noop,
+  polygonEnd: d3_noop
+};
+
+function d3_geo_pathBoundsPoint(x, y) {
+  if (x < d3_geo_pathBoundsX0) d3_geo_pathBoundsX0 = x;
+  if (x > d3_geo_pathBoundsX1) d3_geo_pathBoundsX1 = x;
+  if (y < d3_geo_pathBoundsY0) d3_geo_pathBoundsY0 = y;
+  if (y > d3_geo_pathBoundsY1) d3_geo_pathBoundsY1 = y;
+}

data/node_modules/dc/node_modules/d3/src/geo/path-buffer.js

@@ -0,0 +1,59 @@
+function d3_geo_pathBuffer() {
+  var pointCircle = d3_geo_pathBufferCircle(4.5),
+      buffer = [];
+
+  var stream = {
+    point: point,
+
+    // While inside a line, override point to moveTo then lineTo.
+    lineStart: function() { stream.point = pointLineStart; },
+    lineEnd: lineEnd,
+
+    // While inside a polygon, override lineEnd to closePath.
+    polygonStart: function() { stream.lineEnd = lineEndPolygon; },
+    polygonEnd: function() { stream.lineEnd = lineEnd; stream.point = point; },
+
+    pointRadius: function(_) {
+      pointCircle = d3_geo_pathBufferCircle(_);
+      return stream;
+    },
+
+    result: function() {
+      if (buffer.length) {
+        var result = buffer.join("");
+        buffer = [];
+        return result;
+      }
+    }
+  };
+
+  function point(x, y) {
+    buffer.push("M", x, ",", y, pointCircle);
+  }
+
+  function pointLineStart(x, y) {
+    buffer.push("M", x, ",", y);
+    stream.point = pointLine;
+  }
+
+  function pointLine(x, y) {
+    buffer.push("L", x, ",", y);
+  }
+
+  function lineEnd() {
+    stream.point = point;
+  }
+
+  function lineEndPolygon() {
+    buffer.push("Z");
+  }
+
+  return stream;
+}
+
+function d3_geo_pathBufferCircle(radius) {
+  return "m0," + radius
+      + "a" + radius + "," + radius + " 0 1,1 0," + -2 * radius
+      + "a" + radius + "," + radius + " 0 1,1 0," + 2 * radius
+      + "z";
+}

data/node_modules/dc/node_modules/d3/src/geo/path-centroid.js

@@ -0,0 +1,78 @@
+import "centroid";
+
+// TODO Unify this code with d3.geom.polygon centroid?
+// TODO Enforce positive area for exterior, negative area for interior?
+
+var d3_geo_pathCentroid = {
+  point: d3_geo_pathCentroidPoint,
+
+  // For lines, weight by length.
+  lineStart: d3_geo_pathCentroidLineStart,
+  lineEnd: d3_geo_pathCentroidLineEnd,
+
+  // For polygons, weight by area.
+  polygonStart: function() {
+    d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidRingStart;
+  },
+  polygonEnd: function() {
+    d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
+    d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidLineStart;
+    d3_geo_pathCentroid.lineEnd = d3_geo_pathCentroidLineEnd;
+  }
+};
+
+function d3_geo_pathCentroidPoint(x, y) {
+  d3_geo_centroidX0 += x;
+  d3_geo_centroidY0 += y;
+  ++d3_geo_centroidZ0;
+}
+
+function d3_geo_pathCentroidLineStart() {
+  var x0, y0;
+
+  d3_geo_pathCentroid.point = function(x, y) {
+    d3_geo_pathCentroid.point = nextPoint;
+    d3_geo_pathCentroidPoint(x0 = x, y0 = y);
+  };
+
+  function nextPoint(x, y) {
+    var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy);
+    d3_geo_centroidX1 += z * (x0 + x) / 2;
+    d3_geo_centroidY1 += z * (y0 + y) / 2;
+    d3_geo_centroidZ1 += z;
+    d3_geo_pathCentroidPoint(x0 = x, y0 = y);
+  }
+}
+
+function d3_geo_pathCentroidLineEnd() {
+  d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
+}
+
+function d3_geo_pathCentroidRingStart() {
+  var x00, y00, x0, y0;
+
+  // For the first point, …
+  d3_geo_pathCentroid.point = function(x, y) {
+    d3_geo_pathCentroid.point = nextPoint;
+    d3_geo_pathCentroidPoint(x00 = x0 = x, y00 = y0 = y);
+  };
+
+  // For subsequent points, …
+  function nextPoint(x, y) {
+    var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy);
+    d3_geo_centroidX1 += z * (x0 + x) / 2;
+    d3_geo_centroidY1 += z * (y0 + y) / 2;
+    d3_geo_centroidZ1 += z;
+
+    z = y0 * x - x0 * y;
+    d3_geo_centroidX2 += z * (x0 + x);
+    d3_geo_centroidY2 += z * (y0 + y);
+    d3_geo_centroidZ2 += z * 3;
+    d3_geo_pathCentroidPoint(x0 = x, y0 = y);
+  }
+
+  // For the last point, return to the start.
+  d3_geo_pathCentroid.lineEnd = function() {
+    nextPoint(x00, y00);
+  };
+}

data/node_modules/dc/node_modules/d3/src/geo/path-context.js

@@ -0,0 +1,49 @@
+import "../core/noop";
+import "../math/trigonometry";
+
+function d3_geo_pathContext(context) {
+  var pointRadius = 4.5;
+
+  var stream = {
+    point: point,
+
+    // While inside a line, override point to moveTo then lineTo.
+    lineStart: function() { stream.point = pointLineStart; },
+    lineEnd: lineEnd,
+
+    // While inside a polygon, override lineEnd to closePath.
+    polygonStart: function() { stream.lineEnd = lineEndPolygon; },
+    polygonEnd: function() { stream.lineEnd = lineEnd; stream.point = point; },
+
+    pointRadius: function(_) {
+      pointRadius = _;
+      return stream;
+    },
+
+    result: d3_noop
+  };
+
+  function point(x, y) {
+    context.moveTo(x + pointRadius, y);
+    context.arc(x, y, pointRadius, 0, τ);
+  }
+
+  function pointLineStart(x, y) {
+    context.moveTo(x, y);
+    stream.point = pointLine;
+  }
+
+  function pointLine(x, y) {
+    context.lineTo(x, y);
+  }
+
+  function lineEnd() {
+    stream.point = point;
+  }
+
+  function lineEndPolygon() {
+    context.closePath();
+  }
+
+  return stream;
+}