mdarray-sol 0.1.0-java

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

@@ -0,0 +1,64 @@
+import "../../math/abs";
+
+function d3_geom_voronoiCell(site) {
+  this.site = site;
+  this.edges = [];
+}
+
+d3_geom_voronoiCell.prototype.prepare = function() {
+  var halfEdges = this.edges,
+      iHalfEdge = halfEdges.length,
+      edge;
+
+  while (iHalfEdge--) {
+    edge = halfEdges[iHalfEdge].edge;
+    if (!edge.b || !edge.a) halfEdges.splice(iHalfEdge, 1);
+  }
+
+  halfEdges.sort(d3_geom_voronoiHalfEdgeOrder);
+  return halfEdges.length;
+};
+
+function d3_geom_voronoiCloseCells(extent) {
+  var x0 = extent[0][0],
+      x1 = extent[1][0],
+      y0 = extent[0][1],
+      y1 = extent[1][1],
+      x2,
+      y2,
+      x3,
+      y3,
+      cells = d3_geom_voronoiCells,
+      iCell = cells.length,
+      cell,
+      iHalfEdge,
+      halfEdges,
+      nHalfEdges,
+      start,
+      end;
+
+  while (iCell--) {
+    cell = cells[iCell];
+    if (!cell || !cell.prepare()) continue;
+    halfEdges = cell.edges;
+    nHalfEdges = halfEdges.length;
+    iHalfEdge = 0;
+    while (iHalfEdge < nHalfEdges) {
+      end = halfEdges[iHalfEdge].end(), x3 = end.x, y3 = end.y;
+      start = halfEdges[++iHalfEdge % nHalfEdges].start(), x2 = start.x, y2 = start.y;
+      if (abs(x3 - x2) > ε || abs(y3 - y2) > ε) {
+        halfEdges.splice(iHalfEdge, 0, new d3_geom_voronoiHalfEdge(d3_geom_voronoiCreateBorderEdge(cell.site, end,
+            abs(x3 - x0) < ε && y1 - y3 > ε ? {x: x0, y: abs(x2 - x0) < ε ? y2 : y1}
+            : abs(y3 - y1) < ε && x1 - x3 > ε ? {x: abs(y2 - y1) < ε ? x2 : x1, y: y1}
+            : abs(x3 - x1) < ε && y3 - y0 > ε ? {x: x1, y: abs(x2 - x1) < ε ? y2 : y0}
+            : abs(y3 - y0) < ε && x3 - x0 > ε ? {x: abs(y2 - y0) < ε ? x2 : x0, y: y0}
+            : null), cell.site, null));
+        ++nHalfEdges;
+      }
+    }
+  }
+}
+
+function d3_geom_voronoiHalfEdgeOrder(a, b) {
+  return b.angle - a.angle;
+}

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

@@ -0,0 +1,73 @@
+function d3_geom_voronoiCircle() {
+  d3_geom_voronoiRedBlackNode(this);
+  this.x =
+  this.y =
+  this.arc =
+  this.site =
+  this.cy = null;
+}
+
+function d3_geom_voronoiAttachCircle(arc) {
+  var lArc = arc.P,
+      rArc = arc.N;
+
+  if (!lArc || !rArc) return;
+
+  var lSite = lArc.site,
+      cSite = arc.site,
+      rSite = rArc.site;
+
+  if (lSite === rSite) return;
+
+  var bx = cSite.x,
+      by = cSite.y,
+      ax = lSite.x - bx,
+      ay = lSite.y - by,
+      cx = rSite.x - bx,
+      cy = rSite.y - by;
+
+  var d = 2 * (ax * cy - ay * cx);
+  if (d >= -ε2) return;
+
+  var ha = ax * ax + ay * ay,
+      hc = cx * cx + cy * cy,
+      x = (cy * ha - ay * hc) / d,
+      y = (ax * hc - cx * ha) / d,
+      cy = y + by;
+
+  var circle = d3_geom_voronoiCirclePool.pop() || new d3_geom_voronoiCircle;
+  circle.arc = arc;
+  circle.site = cSite;
+  circle.x = x + bx;
+  circle.y = cy + Math.sqrt(x * x + y * y); // y bottom
+  circle.cy = cy;
+
+  arc.circle = circle;
+
+  var before = null,
+      node = d3_geom_voronoiCircles._;
+
+  while (node) {
+    if (circle.y < node.y || (circle.y === node.y && circle.x <= node.x)) {
+      if (node.L) node = node.L;
+      else { before = node.P; break; }
+    } else {
+      if (node.R) node = node.R;
+      else { before = node; break; }
+    }
+  }
+
+  d3_geom_voronoiCircles.insert(before, circle);
+  if (!before) d3_geom_voronoiFirstCircle = circle;
+}
+
+function d3_geom_voronoiDetachCircle(arc) {
+  var circle = arc.circle;
+  if (circle) {
+    if (!circle.P) d3_geom_voronoiFirstCircle = circle.N;
+    d3_geom_voronoiCircles.remove(circle);
+    d3_geom_voronoiCirclePool.push(circle);
+    d3_geom_voronoiRedBlackNode(circle);
+    arc.circle = null;
+  }
+}

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

@@ -0,0 +1,80 @@
+import "../../math/abs";
+import "../clip-line";
+
+function d3_geom_voronoiClipEdges(extent) {
+  var edges = d3_geom_voronoiEdges,
+      clip = d3_geom_clipLine(extent[0][0], extent[0][1], extent[1][0], extent[1][1]),
+      i = edges.length,
+      e;
+  while (i--) {
+    e = edges[i];
+    if (!d3_geom_voronoiConnectEdge(e, extent)
+        || !clip(e)
+        || (abs(e.a.x - e.b.x) < ε && abs(e.a.y - e.b.y) < ε)) {
+      e.a = e.b = null;
+      edges.splice(i, 1);
+    }
+  }
+}
+
+function d3_geom_voronoiConnectEdge(edge, extent) {
+  var vb = edge.b;
+  if (vb) return true;
+
+  var va = edge.a,
+      x0 = extent[0][0],
+      x1 = extent[1][0],
+      y0 = extent[0][1],
+      y1 = extent[1][1],
+      lSite = edge.l,
+      rSite = edge.r,
+      lx = lSite.x,
+      ly = lSite.y,
+      rx = rSite.x,
+      ry = rSite.y,
+      fx = (lx + rx) / 2,
+      fy = (ly + ry) / 2,
+      fm,
+      fb;
+
+  if (ry === ly) {
+    if (fx < x0 || fx >= x1) return;
+    if (lx > rx) {
+      if (!va) va = {x: fx, y: y0};
+      else if (va.y >= y1) return;
+      vb = {x: fx, y: y1};
+    } else {
+      if (!va) va = {x: fx, y: y1};
+      else if (va.y < y0) return;
+      vb = {x: fx, y: y0};
+    }
+  } else {
+    fm = (lx - rx) / (ry - ly);
+    fb = fy - fm * fx;
+    if (fm < -1 || fm > 1) {
+      if (lx > rx) {
+        if (!va) va = {x: (y0 - fb) / fm, y: y0};
+        else if (va.y >= y1) return;
+        vb = {x: (y1 - fb) / fm, y: y1};
+      } else {
+        if (!va) va = {x: (y1 - fb) / fm, y: y1};
+        else if (va.y < y0) return;
+        vb = {x: (y0 - fb) / fm, y: y0};
+      }
+    } else {
+      if (ly < ry) {
+        if (!va) va = {x: x0, y: fm * x0 + fb};
+        else if (va.x >= x1) return;
+        vb = {x: x1, y: fm * x1 + fb};
+      } else {
+        if (!va) va = {x: x1, y: fm * x1 + fb};
+        else if (va.x < x0) return;
+        vb = {x: x0, y: fm * x0 + fb};
+      }
+    }
+  }
+
+  edge.a = va;
+  edge.b = vb;
+  return true;
+}

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

@@ -0,0 +1,50 @@
+function d3_geom_voronoiEdge(lSite, rSite) {
+  this.l = lSite;
+  this.r = rSite;
+  this.a = this.b = null; // for border edges
+}
+
+function d3_geom_voronoiCreateEdge(lSite, rSite, va, vb) {
+  var edge = new d3_geom_voronoiEdge(lSite, rSite);
+  d3_geom_voronoiEdges.push(edge);
+  if (va) d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, va);
+  if (vb) d3_geom_voronoiSetEdgeEnd(edge, rSite, lSite, vb);
+  d3_geom_voronoiCells[lSite.i].edges.push(new d3_geom_voronoiHalfEdge(edge, lSite, rSite));
+  d3_geom_voronoiCells[rSite.i].edges.push(new d3_geom_voronoiHalfEdge(edge, rSite, lSite));
+  return edge;
+}
+
+function d3_geom_voronoiCreateBorderEdge(lSite, va, vb) {
+  var edge = new d3_geom_voronoiEdge(lSite, null);
+  edge.a = va;
+  edge.b = vb;
+  d3_geom_voronoiEdges.push(edge);
+  return edge;
+}
+
+function d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, vertex) {
+  if (!edge.a && !edge.b) {
+    edge.a = vertex;
+    edge.l = lSite;
+    edge.r = rSite;
+  } else if (edge.l === rSite) {
+    edge.b = vertex;
+  } else {
+    edge.a = vertex;
+  }
+}
+
+function d3_geom_voronoiHalfEdge(edge, lSite, rSite) {
+  var va = edge.a,
+      vb = edge.b;
+  this.edge = edge;
+  this.site = lSite;
+  this.angle = rSite ? Math.atan2(rSite.y - lSite.y, rSite.x - lSite.x)
+      : edge.l === lSite ? Math.atan2(vb.x - va.x, va.y - vb.y)
+      : Math.atan2(va.x - vb.x, vb.y - va.y);
+};
+
+d3_geom_voronoiHalfEdge.prototype = {
+  start: function() { return this.edge.l === this.site ? this.edge.a : this.edge.b; },
+  end: function() { return this.edge.l === this.site ? this.edge.b : this.edge.a; }
+};

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

@@ -0,0 +1,59 @@
+import "../../math/trigonometry";
+
+var d3_geom_voronoiEdges,
+    d3_geom_voronoiCells,
+    d3_geom_voronoiBeaches,
+    d3_geom_voronoiBeachPool = [],
+    d3_geom_voronoiFirstCircle,
+    d3_geom_voronoiCircles,
+    d3_geom_voronoiCirclePool = [];
+
+import "beach";
+import "cell";
+import "circle";
+import "clip";
+import "edge";
+import "red-black";
+
+function d3_geom_voronoi(sites, bbox) {
+  var site = sites.sort(d3_geom_voronoiVertexOrder).pop(),
+      x0,
+      y0,
+      circle;
+
+  d3_geom_voronoiEdges = [];
+  d3_geom_voronoiCells = new Array(sites.length);
+  d3_geom_voronoiBeaches = new d3_geom_voronoiRedBlackTree;
+  d3_geom_voronoiCircles = new d3_geom_voronoiRedBlackTree;
+
+  while (true) {
+    circle = d3_geom_voronoiFirstCircle;
+    if (site && (!circle || site.y < circle.y || (site.y === circle.y && site.x < circle.x))) {
+      if (site.x !== x0 || site.y !== y0) {
+        d3_geom_voronoiCells[site.i] = new d3_geom_voronoiCell(site);
+        d3_geom_voronoiAddBeach(site);
+        x0 = site.x, y0 = site.y;
+      }
+      site = sites.pop();
+    } else if (circle) {
+      d3_geom_voronoiRemoveBeach(circle.arc);
+    } else {
+      break;
+    }
+  }
+
+  if (bbox) d3_geom_voronoiClipEdges(bbox), d3_geom_voronoiCloseCells(bbox);
+
+  var diagram = {cells: d3_geom_voronoiCells, edges: d3_geom_voronoiEdges};
+
+  d3_geom_voronoiBeaches =
+  d3_geom_voronoiCircles =
+  d3_geom_voronoiEdges =
+  d3_geom_voronoiCells = null;
+
+  return diagram;
+};
+
+function d3_geom_voronoiVertexOrder(a, b) {
+  return b.y - a.y || b.x - a.x;
+}

data/node_modules/dc/node_modules/d3/src/geom/voronoi/red-black.js

@@ -0,0 +1,235 @@
+function d3_geom_voronoiRedBlackTree() {
+  this._ = null; // root node
+}
+
+function d3_geom_voronoiRedBlackNode(node) {
+  node.U = // parent node
+  node.C = // color - true for red, false for black
+  node.L = // left node
+  node.R = // right node
+  node.P = // previous node
+  node.N = null; // next node
+}
+
+d3_geom_voronoiRedBlackTree.prototype = {
+
+  insert: function(after, node) {
+    var parent, grandpa, uncle;
+
+    if (after) {
+      node.P = after;
+      node.N = after.N;
+      if (after.N) after.N.P = node;
+      after.N = node;
+      if (after.R) {
+        after = after.R;
+        while (after.L) after = after.L;
+        after.L = node;
+      } else {
+        after.R = node;
+      }
+      parent = after;
+    } else if (this._) {
+      after = d3_geom_voronoiRedBlackFirst(this._);
+      node.P = null;
+      node.N = after;
+      after.P = after.L = node;
+      parent = after;
+    } else {
+      node.P = node.N = null;
+      this._ = node;
+      parent = null;
+    }
+    node.L = node.R = null;
+    node.U = parent;
+    node.C = true;
+
+    after = node;
+    while (parent && parent.C) {
+      grandpa = parent.U;
+      if (parent === grandpa.L) {
+        uncle = grandpa.R;
+        if (uncle && uncle.C) {
+          parent.C = uncle.C = false;
+          grandpa.C = true;
+          after = grandpa;
+        } else {
+          if (after === parent.R) {
+            d3_geom_voronoiRedBlackRotateLeft(this, parent);
+            after = parent;
+            parent = after.U;
+          }
+          parent.C = false;
+          grandpa.C = true;
+          d3_geom_voronoiRedBlackRotateRight(this, grandpa);
+        }
+      } else {
+        uncle = grandpa.L;
+        if (uncle && uncle.C) {
+          parent.C = uncle.C = false;
+          grandpa.C = true;
+          after = grandpa;
+        } else {
+          if (after === parent.L) {
+            d3_geom_voronoiRedBlackRotateRight(this, parent);
+            after = parent;
+            parent = after.U;
+          }
+          parent.C = false;
+          grandpa.C = true;
+          d3_geom_voronoiRedBlackRotateLeft(this, grandpa);
+        }
+      }
+      parent = after.U;
+    }
+    this._.C = false;
+  },
+
+  remove: function(node) {
+    if (node.N) node.N.P = node.P;
+    if (node.P) node.P.N = node.N;
+    node.N = node.P = null;
+
+    var parent = node.U,
+        sibling,
+        left = node.L,
+        right = node.R,
+        next,
+        red;
+
+    if (!left) next = right;
+    else if (!right) next = left;
+    else next = d3_geom_voronoiRedBlackFirst(right);
+
+    if (parent) {
+      if (parent.L === node) parent.L = next;
+      else parent.R = next;
+    } else {
+      this._ = next;
+    }
+
+    if (left && right) {
+      red = next.C;
+      next.C = node.C;
+      next.L = left;
+      left.U = next;
+      if (next !== right) {
+        parent = next.U;
+        next.U = node.U;
+        node = next.R;
+        parent.L = node;
+        next.R = right;
+        right.U = next;
+      } else {
+        next.U = parent;
+        parent = next;
+        node = next.R;
+      }
+    } else {
+      red = node.C;
+      node = next;
+    }
+
+    if (node) node.U = parent;
+    if (red) return;
+    if (node && node.C) { node.C = false; return; }
+
+    do {
+      if (node === this._) break;
+      if (node === parent.L) {
+        sibling = parent.R;
+        if (sibling.C) {
+          sibling.C = false;
+          parent.C = true;
+          d3_geom_voronoiRedBlackRotateLeft(this, parent);
+          sibling = parent.R;
+        }
+        if ((sibling.L && sibling.L.C)
+            || (sibling.R && sibling.R.C)) {
+          if (!sibling.R || !sibling.R.C) {
+            sibling.L.C = false;
+            sibling.C = true;
+            d3_geom_voronoiRedBlackRotateRight(this, sibling);
+            sibling = parent.R;
+          }
+          sibling.C = parent.C;
+          parent.C = sibling.R.C = false;
+          d3_geom_voronoiRedBlackRotateLeft(this, parent);
+          node = this._;
+          break;
+        }
+      } else {
+        sibling = parent.L;
+        if (sibling.C) {
+          sibling.C = false;
+          parent.C = true;
+          d3_geom_voronoiRedBlackRotateRight(this, parent);
+          sibling = parent.L;
+        }
+        if ((sibling.L && sibling.L.C)
+          || (sibling.R && sibling.R.C)) {
+          if (!sibling.L || !sibling.L.C) {
+            sibling.R.C = false;
+            sibling.C = true;
+            d3_geom_voronoiRedBlackRotateLeft(this, sibling);
+            sibling = parent.L;
+          }
+          sibling.C = parent.C;
+          parent.C = sibling.L.C = false;
+          d3_geom_voronoiRedBlackRotateRight(this, parent);
+          node = this._;
+          break;
+        }
+      }
+      sibling.C = true;
+      node = parent;
+      parent = parent.U;
+    } while (!node.C);
+
+    if (node) node.C = false;
+  }
+
+};
+
+function d3_geom_voronoiRedBlackRotateLeft(tree, node) {
+  var p = node,
+      q = node.R,
+      parent = p.U;
+
+  if (parent) {
+    if (parent.L === p) parent.L = q;
+    else parent.R = q;
+  } else {
+    tree._ = q;
+  }
+
+  q.U = parent;
+  p.U = q;
+  p.R = q.L;
+  if (p.R) p.R.U = p;
+  q.L = p;
+}
+
+function d3_geom_voronoiRedBlackRotateRight(tree, node) {
+  var p = node,
+      q = node.L,
+      parent = p.U;
+
+  if (parent) {
+    if (parent.L === p) parent.L = q;
+    else parent.R = q;
+  } else {
+    tree._ = q;
+  }
+
+  q.U = parent;
+  p.U = q;
+  p.L = q.R;
+  if (p.L) p.L.U = p;
+  q.R = p;
+}
+
+function d3_geom_voronoiRedBlackFirst(node) {
+  while (node.L) node = node.L;
+  return node;
+}