mdarray-sol 0.1.0-java

data/node_modules/dc/node_modules/d3/src/geom/quadtree.js

@@ -0,0 +1,243 @@
+import "../core/functor";
+import "../math/abs";
+import "geom";
+import "point";
+
+d3.geom.quadtree = function(points, x1, y1, x2, y2) {
+  var x = d3_geom_pointX,
+      y = d3_geom_pointY,
+      compat;
+
+  // For backwards-compatibility.
+  if (compat = arguments.length) {
+    x = d3_geom_quadtreeCompatX;
+    y = d3_geom_quadtreeCompatY;
+    if (compat === 3) {
+      y2 = y1;
+      x2 = x1;
+      y1 = x1 = 0;
+    }
+    return quadtree(points);
+  }
+
+  function quadtree(data) {
+    var d,
+        fx = d3_functor(x),
+        fy = d3_functor(y),
+        xs,
+        ys,
+        i,
+        n,
+        x1_,
+        y1_,
+        x2_,
+        y2_;
+
+    if (x1 != null) {
+      x1_ = x1, y1_ = y1, x2_ = x2, y2_ = y2;
+    } else {
+      // Compute bounds, and cache points temporarily.
+      x2_ = y2_ = -(x1_ = y1_ = Infinity);
+      xs = [], ys = [];
+      n = data.length;
+      if (compat) for (i = 0; i < n; ++i) {
+        d = data[i];
+        if (d.x < x1_) x1_ = d.x;
+        if (d.y < y1_) y1_ = d.y;
+        if (d.x > x2_) x2_ = d.x;
+        if (d.y > y2_) y2_ = d.y;
+        xs.push(d.x);
+        ys.push(d.y);
+      } else for (i = 0; i < n; ++i) {
+        var x_ = +fx(d = data[i], i),
+            y_ = +fy(d, i);
+        if (x_ < x1_) x1_ = x_;
+        if (y_ < y1_) y1_ = y_;
+        if (x_ > x2_) x2_ = x_;
+        if (y_ > y2_) y2_ = y_;
+        xs.push(x_);
+        ys.push(y_);
+      }
+    }
+
+    // Squarify the bounds.
+    var dx = x2_ - x1_,
+        dy = y2_ - y1_;
+    if (dx > dy) y2_ = y1_ + dx;
+    else x2_ = x1_ + dy;
+
+    // Recursively inserts the specified point p at the node n or one of its
+    // descendants. The bounds are defined by [x1, x2] and [y1, y2].
+    function insert(n, d, x, y, x1, y1, x2, y2) {
+      if (isNaN(x) || isNaN(y)) return; // ignore invalid points
+      if (n.leaf) {
+        var nx = n.x,
+            ny = n.y;
+        if (nx != null) {
+          // If the point at this leaf node is at the same position as the new
+          // point we are adding, we leave the point associated with the
+          // internal node while adding the new point to a child node. This
+          // avoids infinite recursion.
+          if ((abs(nx - x) + abs(ny - y)) < 0.01) {
+            insertChild(n, d, x, y, x1, y1, x2, y2);
+          } else {
+            var nPoint = n.point;
+            n.x = n.y = n.point = null;
+            insertChild(n, nPoint, nx, ny, x1, y1, x2, y2);
+            insertChild(n, d, x, y, x1, y1, x2, y2);
+          }
+        } else {
+          n.x = x, n.y = y, n.point = d;
+        }
+      } else {
+        insertChild(n, d, x, y, x1, y1, x2, y2);
+      }
+    }
+
+    // Recursively inserts the specified point [x, y] into a descendant of node
+    // n. The bounds are defined by [x1, x2] and [y1, y2].
+    function insertChild(n, d, x, y, x1, y1, x2, y2) {
+      // Compute the split point, and the quadrant in which to insert p.
+      var xm = (x1 + x2) * 0.5,
+          ym = (y1 + y2) * 0.5,
+          right = x >= xm,
+          below = y >= ym,
+          i = below << 1 | right;
+
+      // Recursively insert into the child node.
+      n.leaf = false;
+      n = n.nodes[i] || (n.nodes[i] = d3_geom_quadtreeNode());
+
+      // Update the bounds as we recurse.
+      if (right) x1 = xm; else x2 = xm;
+      if (below) y1 = ym; else y2 = ym;
+      insert(n, d, x, y, x1, y1, x2, y2);
+    }
+
+    // Create the root node.
+    var root = d3_geom_quadtreeNode();
+
+    root.add = function(d) {
+      insert(root, d, +fx(d, ++i), +fy(d, i), x1_, y1_, x2_, y2_);
+    };
+
+    root.visit = function(f) {
+      d3_geom_quadtreeVisit(f, root, x1_, y1_, x2_, y2_);
+    };
+
+    // Find the closest point to the specified point.
+    // TODO allow the initial search extent to be specified?
+    // TODO allow the initial minimum distance to be specified?
+    // TODO allow searching below any node?
+    root.find = function(point) {
+      return d3_geom_quadtreeFind(root, point[0], point[1], x1_, y1_, x2_, y2_);
+    };
+
+    // Insert all points.
+    i = -1;
+    if (x1 == null) {
+      while (++i < n) {
+        insert(root, data[i], xs[i], ys[i], x1_, y1_, x2_, y2_);
+      }
+      --i; // index of last insertion
+    } else data.forEach(root.add);
+
+    // Discard captured fields.
+    xs = ys = data = d = null;
+
+    return root;
+  }
+
+  quadtree.x = function(_) {
+    return arguments.length ? (x = _, quadtree) : x;
+  };
+
+  quadtree.y = function(_) {
+    return arguments.length ? (y = _, quadtree) : y;
+  };
+
+  quadtree.extent = function(_) {
+    if (!arguments.length) return x1 == null ? null : [[x1, y1], [x2, y2]];
+    if (_ == null) x1 = y1 = x2 = y2 = null;
+    else x1 = +_[0][0], y1 = +_[0][1], x2 = +_[1][0], y2 = +_[1][1];
+    return quadtree;
+  };
+
+  quadtree.size = function(_) {
+    if (!arguments.length) return x1 == null ? null : [x2 - x1, y2 - y1];
+    if (_ == null) x1 = y1 = x2 = y2 = null;
+    else x1 = y1 = 0, x2 = +_[0], y2 = +_[1];
+    return quadtree;
+  };
+
+  return quadtree;
+};
+
+function d3_geom_quadtreeCompatX(d) { return d.x; }
+function d3_geom_quadtreeCompatY(d) { return d.y; }
+
+function d3_geom_quadtreeNode() {
+  return {
+    leaf: true,
+    nodes: [],
+    point: null,
+    x: null,
+    y: null
+  };
+}
+
+function d3_geom_quadtreeVisit(f, node, x1, y1, x2, y2) {
+  if (!f(node, x1, y1, x2, y2)) {
+    var sx = (x1 + x2) * 0.5,
+        sy = (y1 + y2) * 0.5,
+        children = node.nodes;
+    if (children[0]) d3_geom_quadtreeVisit(f, children[0], x1, y1, sx, sy);
+    if (children[1]) d3_geom_quadtreeVisit(f, children[1], sx, y1, x2, sy);
+    if (children[2]) d3_geom_quadtreeVisit(f, children[2], x1, sy, sx, y2);
+    if (children[3]) d3_geom_quadtreeVisit(f, children[3], sx, sy, x2, y2);
+  }
+}
+
+function d3_geom_quadtreeFind(root, x, y, x0, y0, x3, y3) {
+  var minDistance2 = Infinity,
+      closestPoint;
+
+  (function find(node, x1, y1, x2, y2) {
+
+    // stop searching if this cell can’t contain a closer node
+    if (x1 > x3 || y1 > y3 || x2 < x0 || y2 < y0) return;
+
+    // visit this point
+    if (point = node.point) {
+      var point,
+          dx = x - node.x,
+          dy = y - node.y,
+          distance2 = dx * dx + dy * dy;
+      if (distance2 < minDistance2) {
+        var distance = Math.sqrt(minDistance2 = distance2);
+        x0 = x - distance, y0 = y - distance;
+        x3 = x + distance, y3 = y + distance;
+        closestPoint = point;
+      }
+    }
+
+    // bisect the current node
+    var children = node.nodes,
+        xm = (x1 + x2) * 0.5,
+        ym = (y1 + y2) * 0.5,
+        right = x >= xm,
+        below = y >= ym;
+
+    // visit closest cell first
+    for (var i = below << 1 | right, j = i + 4; i < j; ++i) {
+      if (node = children[i & 3]) switch (i & 3) {
+        case 0: find(node, x1, y1, xm, ym); break;
+        case 1: find(node, xm, y1, x2, ym); break;
+        case 2: find(node, x1, ym, xm, y2); break;
+        case 3: find(node, xm, ym, x2, y2); break;
+      }
+    }
+  })(root, x0, y0, x3, y3);
+
+  return closestPoint;
+}

data/node_modules/dc/node_modules/d3/src/geom/voronoi.js

@@ -0,0 +1,110 @@
+import "../core/functor";
+import "voronoi/";
+import "geom";
+import "point";
+
+d3.geom.voronoi = function(points) {
+  var x = d3_geom_pointX,
+      y = d3_geom_pointY,
+      fx = x,
+      fy = y,
+      clipExtent = d3_geom_voronoiClipExtent;
+
+  // @deprecated; use voronoi(data) instead.
+  if (points) return voronoi(points);
+
+  function voronoi(data) {
+    var polygons = new Array(data.length),
+        x0 = clipExtent[0][0],
+        y0 = clipExtent[0][1],
+        x1 = clipExtent[1][0],
+        y1 = clipExtent[1][1];
+
+    d3_geom_voronoi(sites(data), clipExtent).cells.forEach(function(cell, i) {
+      var edges = cell.edges,
+          site = cell.site,
+          polygon = polygons[i] = edges.length ? edges.map(function(e) { var s = e.start(); return [s.x, s.y]; })
+              : site.x >= x0 && site.x <= x1 && site.y >= y0 && site.y <= y1 ? [[x0, y1], [x1, y1], [x1, y0], [x0, y0]]
+              : [];
+      polygon.point = data[i];
+    });
+
+    return polygons;
+  }
+
+  function sites(data) {
+    return data.map(function(d, i) {
+      return {
+        x: Math.round(fx(d, i) / ε) * ε,
+        y: Math.round(fy(d, i) / ε) * ε,
+        i: i
+      };
+    });
+  }
+
+  voronoi.links = function(data) {
+    return d3_geom_voronoi(sites(data)).edges.filter(function(edge) {
+      return edge.l && edge.r;
+    }).map(function(edge) {
+      return {
+        source: data[edge.l.i],
+        target: data[edge.r.i]
+      };
+    });
+  };
+
+  voronoi.triangles = function(data) {
+    var triangles = [];
+
+    d3_geom_voronoi(sites(data)).cells.forEach(function(cell, i) {
+      var site = cell.site,
+          edges = cell.edges.sort(d3_geom_voronoiHalfEdgeOrder),
+          j = -1,
+          m = edges.length,
+          e0,
+          s0,
+          e1 = edges[m - 1].edge,
+          s1 = e1.l === site ? e1.r : e1.l;
+
+      while (++j < m) {
+        e0 = e1;
+        s0 = s1;
+        e1 = edges[j].edge;
+        s1 = e1.l === site ? e1.r : e1.l;
+        if (i < s0.i && i < s1.i && d3_geom_voronoiTriangleArea(site, s0, s1) < 0) {
+          triangles.push([data[i], data[s0.i], data[s1.i]]);
+        }
+      }
+    });
+
+    return triangles;
+  };
+
+  voronoi.x = function(_) {
+    return arguments.length ? (fx = d3_functor(x = _), voronoi) : x;
+  };
+
+  voronoi.y = function(_) {
+    return arguments.length ? (fy = d3_functor(y = _), voronoi) : y;
+  };
+
+  voronoi.clipExtent = function(_) {
+    if (!arguments.length) return clipExtent === d3_geom_voronoiClipExtent ? null : clipExtent;
+    clipExtent = _ == null ? d3_geom_voronoiClipExtent : _;
+    return voronoi;
+  };
+
+  // @deprecated; use clipExtent instead.
+  voronoi.size = function(_) {
+    if (!arguments.length) return clipExtent === d3_geom_voronoiClipExtent ? null : clipExtent && clipExtent[1];
+    return voronoi.clipExtent(_ && [[0, 0], _]);
+  };
+
+  return voronoi;
+};
+
+var d3_geom_voronoiClipExtent = [[-1e6, -1e6], [1e6, 1e6]];
+
+function d3_geom_voronoiTriangleArea(a, b, c) {
+  return (a.x - c.x) * (b.y - a.y) - (a.x - b.x) * (c.y - a.y);
+}

data/node_modules/dc/node_modules/d3/src/geom/voronoi/beach.js

@@ -0,0 +1,186 @@
+import "../../math/abs";
+
+function d3_geom_voronoiBeach() {
+  d3_geom_voronoiRedBlackNode(this);
+  this.edge =
+  this.site =
+  this.circle = null;
+}
+
+function d3_geom_voronoiCreateBeach(site) {
+  var beach = d3_geom_voronoiBeachPool.pop() || new d3_geom_voronoiBeach;
+  beach.site = site;
+  return beach;
+}
+
+function d3_geom_voronoiDetachBeach(beach) {
+  d3_geom_voronoiDetachCircle(beach);
+  d3_geom_voronoiBeaches.remove(beach);
+  d3_geom_voronoiBeachPool.push(beach);
+  d3_geom_voronoiRedBlackNode(beach);
+}
+
+function d3_geom_voronoiRemoveBeach(beach) {
+  var circle = beach.circle,
+      x = circle.x,
+      y = circle.cy,
+      vertex = {x: x, y: y},
+      previous = beach.P,
+      next = beach.N,
+      disappearing = [beach];
+
+  d3_geom_voronoiDetachBeach(beach);
+
+  var lArc = previous;
+  while (lArc.circle
+      && abs(x - lArc.circle.x) < ε
+      && abs(y - lArc.circle.cy) < ε) {
+    previous = lArc.P;
+    disappearing.unshift(lArc);
+    d3_geom_voronoiDetachBeach(lArc);
+    lArc = previous;
+  }
+
+  disappearing.unshift(lArc);
+  d3_geom_voronoiDetachCircle(lArc);
+
+  var rArc = next;
+  while (rArc.circle
+      && abs(x - rArc.circle.x) < ε
+      && abs(y - rArc.circle.cy) < ε) {
+    next = rArc.N;
+    disappearing.push(rArc);
+    d3_geom_voronoiDetachBeach(rArc);
+    rArc = next;
+  }
+
+  disappearing.push(rArc);
+  d3_geom_voronoiDetachCircle(rArc);
+
+  var nArcs = disappearing.length,
+      iArc;
+  for (iArc = 1; iArc < nArcs; ++iArc) {
+    rArc = disappearing[iArc];
+    lArc = disappearing[iArc - 1];
+    d3_geom_voronoiSetEdgeEnd(rArc.edge, lArc.site, rArc.site, vertex);
+  }
+
+  lArc = disappearing[0];
+  rArc = disappearing[nArcs - 1];
+  rArc.edge = d3_geom_voronoiCreateEdge(lArc.site, rArc.site, null, vertex);
+
+  d3_geom_voronoiAttachCircle(lArc);
+  d3_geom_voronoiAttachCircle(rArc);
+}
+
+function d3_geom_voronoiAddBeach(site) {
+  var x = site.x,
+      directrix = site.y,
+      lArc,
+      rArc,
+      dxl,
+      dxr,
+      node = d3_geom_voronoiBeaches._;
+
+  while (node) {
+    dxl = d3_geom_voronoiLeftBreakPoint(node, directrix) - x;
+    if (dxl > ε) node = node.L; else {
+      dxr = x - d3_geom_voronoiRightBreakPoint(node, directrix);
+      if (dxr > ε) {
+        if (!node.R) {
+          lArc = node;
+          break;
+        }
+        node = node.R;
+      } else {
+        if (dxl > -ε) {
+          lArc = node.P;
+          rArc = node;
+        } else if (dxr > -ε) {
+          lArc = node;
+          rArc = node.N;
+        } else {
+          lArc = rArc = node;
+        }
+        break;
+      }
+    }
+  }
+
+  var newArc = d3_geom_voronoiCreateBeach(site);
+  d3_geom_voronoiBeaches.insert(lArc, newArc);
+
+  if (!lArc && !rArc) return;
+
+  if (lArc === rArc) {
+    d3_geom_voronoiDetachCircle(lArc);
+    rArc = d3_geom_voronoiCreateBeach(lArc.site);
+    d3_geom_voronoiBeaches.insert(newArc, rArc);
+    newArc.edge = rArc.edge = d3_geom_voronoiCreateEdge(lArc.site, newArc.site);
+    d3_geom_voronoiAttachCircle(lArc);
+    d3_geom_voronoiAttachCircle(rArc);
+    return;
+  }
+
+  if (!rArc) { // && lArc
+    newArc.edge = d3_geom_voronoiCreateEdge(lArc.site, newArc.site);
+    return;
+  }
+
+  // else lArc !== rArc
+  d3_geom_voronoiDetachCircle(lArc);
+  d3_geom_voronoiDetachCircle(rArc);
+
+  var lSite = lArc.site,
+      ax = lSite.x,
+      ay = lSite.y,
+      bx = site.x - ax,
+      by = site.y - ay,
+      rSite = rArc.site,
+      cx = rSite.x - ax,
+      cy = rSite.y - ay,
+      d = 2 * (bx * cy - by * cx),
+      hb = bx * bx + by * by,
+      hc = cx * cx + cy * cy,
+      vertex = {x: (cy * hb - by * hc) / d + ax, y: (bx * hc - cx * hb) / d + ay};
+
+  d3_geom_voronoiSetEdgeEnd(rArc.edge, lSite, rSite, vertex);
+  newArc.edge = d3_geom_voronoiCreateEdge(lSite, site, null, vertex);
+  rArc.edge = d3_geom_voronoiCreateEdge(site, rSite, null, vertex);
+  d3_geom_voronoiAttachCircle(lArc);
+  d3_geom_voronoiAttachCircle(rArc);
+}
+
+function d3_geom_voronoiLeftBreakPoint(arc, directrix) {
+  var site = arc.site,
+      rfocx = site.x,
+      rfocy = site.y,
+      pby2 = rfocy - directrix;
+
+  if (!pby2) return rfocx;
+
+  var lArc = arc.P;
+  if (!lArc) return -Infinity;
+
+  site = lArc.site;
+  var lfocx = site.x,
+      lfocy = site.y,
+      plby2 = lfocy - directrix;
+
+  if (!plby2) return lfocx;
+
+  var hl = lfocx - rfocx,
+      aby2 = 1 / pby2 - 1 / plby2,
+      b = hl / plby2;
+
+  if (aby2) return (-b + Math.sqrt(b * b - 2 * aby2 * (hl * hl / (-2 * plby2) - lfocy + plby2 / 2 + rfocy - pby2 / 2))) / aby2 + rfocx;
+
+  return (rfocx + lfocx) / 2;
+}
+
+function d3_geom_voronoiRightBreakPoint(arc, directrix) {
+  var rArc = arc.N;
+  if (rArc) return d3_geom_voronoiLeftBreakPoint(rArc, directrix);
+  var site = arc.site;
+  return site.y === directrix ? site.x : Infinity;
+}