RubyGems - picky-statistics - Versions diffs - 4.0.0pre3 → 4.0.0pre5 - Mend

picky-statistics 4.0.0pre3 → 4.0.0pre5

Files changed (596) hide show

data/lib/picky-statistics/application/javascripts/d3/examples/dot/dot.html ADDED Viewed

@@ -0,0 +1,103 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Dot Plot</title>
+    <script type="text/javascript" src="../../d3.js"></script>
+    <style type="text/css">
+body {
+  font: 10px sans-serif;
+}
+path.dot {
+  fill: white;
+  stroke-width: 1.5px;
+}
+rect {
+  fill: none;
+  stroke: black;
+  shape-rendering: crispEdges;
+}
+.x line, .y line {
+  stroke: #ccc;
+  shape-rendering: crispEdges;
+}
+    </style>
+  </head>
+  <body>
+    <script type="text/javascript">
+var data = d3.range(100).map(function(i) {
+  return {x: i / 99, y: Math.random()};
+});
+var w = 450,
+    h = 450,
+    p = 20,
+    x = d3.scale.linear().range([0, w]),
+    y = d3.scale.linear().range([h, 0]),
+    symbol = d3.scale.ordinal().range(d3.svg.symbolTypes),
+    color = d3.scale.category10();
+var vis = d3.select("body")
+  .append("svg")
+    .attr("width", w + p * 2)
+    .attr("height", h + p * 2)
+  .append("g")
+    .attr("transform", "translate(" + p + "," + p + ")");
+var xrule = vis.selectAll("g.x")
+    .data(x.ticks(10))
+  .enter().append("g")
+    .attr("class", "x");
+xrule.append("line")
+    .attr("x1", x)
+    .attr("x2", x)
+    .attr("y1", 0)
+    .attr("y2", h);
+xrule.append("text")
+    .attr("x", x)
+    .attr("y", h + 3)
+    .attr("dy", ".71em")
+    .attr("text-anchor", "middle")
+    .text(x.tickFormat(10));
+var yrule = vis.selectAll("g.y")
+    .data(y.ticks(10))
+  .enter().append("g")
+    .attr("class", "y");
+yrule.append("line")
+    .attr("x1", 0)
+    .attr("x2", w)
+    .attr("y1", y)
+    .attr("y2", y);
+yrule.append("text")
+    .attr("x", -3)
+    .attr("y", y)
+    .attr("dy", ".35em")
+    .attr("text-anchor", "end")
+    .text(y.tickFormat(10));
+vis.append("rect")
+    .attr("width", w)
+    .attr("height", h);
+vis.selectAll("path.dot")
+    .data(data)
+  .enter().append("path")
+    .attr("class", "dot")
+    .attr("stroke", function(d, i) { return color(i); })
+    .attr("transform", function(d) { return "translate(" + x(d.x) + "," + y(d.y) + ")"; })
+    .attr("d", d3.svg.symbol()
+    .type(function(d, i) { return symbol(i); }));
+    </script>
+  </body>
+</html>

data/lib/picky-statistics/application/javascripts/d3/examples/drag/drag.html ADDED Viewed

@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html;charset=utf-8"/>
+    <style type="text/css">
+svg {
+  border: solid 1px #aaa;
+}
+    </style>
+  </head>
+  <body>
+    <script type="text/javascript" src="../../d3.js"></script>
+    <script type="text/javascript">
+var w = 960,
+    h = 500,
+    r = 120;
+var drag = d3.behavior.drag()
+    .origin(Object)
+    .on("drag", dragmove);
+var svg = d3.select("body").append("svg")
+    .attr("width", w)
+    .attr("height", h)
+var circle = svg.append("circle")
+    .data([{x: w / 2, y: h / 2}])
+    .attr("r", r)
+    .attr("cx", function(d) { return d.x; })
+    .attr("cy", function(d) { return d.y; })
+    .call(drag);
+function dragmove(d) {
+  circle
+      .attr("cx", d.x = Math.max(r, Math.min(w - r, d3.event.x)))
+      .attr("cy", d.y = Math.max(r, Math.min(h - r, d3.event.y)));
+}
+    </script>
+  </body>
+</html>

data/lib/picky-statistics/application/javascripts/d3/examples/force/README ADDED Viewed

@@ -0,0 +1,10 @@
+The miserables.json file contains the weighted network of coappearances of
+characters in Victor Hugo's novel /Les Miserables/. Nodes represent characters
+as indicated by the labels, and edges connect any pair of characters that
+appear in the same chapter of the book. The values on the edges are the number
+of such coappearances. The data on coappearances were taken from D. E. Knuth,
+"The Stanford GraphBase: A Platform for Combinatorial Computing",
+Addison-Wesley, Reading, MA (1993).
+The group labels were transcribed from "Finding and evaluating community
+structure in networks" by M. E. J. Newman and M. Girvan.

data/lib/picky-statistics/application/javascripts/d3/examples/force/force-bounds.html ADDED Viewed

@@ -0,0 +1,70 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Force-Directed Layout</title>
+    <script type="text/javascript" src="../../d3.js"></script>
+    <script type="text/javascript" src="../../d3.geom.js"></script>
+    <script type="text/javascript" src="../../d3.layout.js"></script>
+    <style type="text/css">
+circle {
+  stroke-width: 1.5px;
+}
+line {
+  stroke: #999;
+}
+    </style>
+  </head>
+  <body>
+    <script type="text/javascript">
+var w = 960,
+    h = 500,
+    r = 6,
+    fill = d3.scale.category20();
+var force = d3.layout.force()
+    .gravity(.01)
+    .charge(-120)
+    .linkDistance(30)
+    .size([w, h]);
+var svg = d3.select("body").append("svg")
+    .attr("width", w)
+    .attr("height", h);
+d3.json("miserables.json", function(json) {
+  var link = svg.selectAll("line")
+      .data(json.links)
+    .enter().append("line");
+  var node = svg.selectAll("circle")
+      .data(json.nodes)
+    .enter().append("circle")
+      .attr("r", r - .75)
+      .style("fill", function(d) { return fill(d.group); })
+      .style("stroke", function(d) { return d3.rgb(fill(d.group)).darker(); })
+      .call(force.drag);
+  force
+      .nodes(json.nodes)
+      .links(json.links)
+      .on("tick", tick)
+      .start();
+  function tick() {
+    node.attr("cx", function(d) { return d.x = Math.max(r, Math.min(w - r, d.x)); })
+        .attr("cy", function(d) { return d.y = Math.max(r, Math.min(h - r, d.y)); });
+    link.attr("x1", function(d) { return d.source.x; })
+        .attr("y1", function(d) { return d.source.y; })
+        .attr("x2", function(d) { return d.target.x; })
+        .attr("y2", function(d) { return d.target.y; });
+  }
+});
+    </script>
+  </body>
+</html>

data/lib/picky-statistics/application/javascripts/d3/examples/force/force-cluster.html ADDED Viewed

@@ -0,0 +1,249 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Clustered Network</title>
+    <script type="text/javascript" src="../../d3.js"></script>
+    <script type="text/javascript" src="../../d3.geom.js"></script>
+    <script type="text/javascript" src="../../d3.layout.js"></script>
+    <style type="text/css">
+svg {
+  border: 1px solid #ccc;
+}
+body {
+  font: 10px sans-serif;
+}
+circle.node {
+  fill: lightsteelblue;
+  stroke: #fff;
+  stroke-width: 1.5px;
+}
+path.hull {
+  fill: lightsteelblue;
+  fill-opacity: 0.3;
+}
+line.link {
+  stroke: #333;
+  stroke-opacity: 0.5;
+  pointer-events: none;
+}
+    </style>
+  </head>
+  <body>
+    <script type="text/javascript">
+var w = 960,     // svg width
+    h = 600,     // svg height
+    dr = 4,      // default point radius
+    off = 15,    // cluster hull offset
+    expand = {}, // expanded clusters
+    data, net, force, hullg, hull, linkg, link, nodeg, node,
+    curve = d3.svg.line().interpolate("cardinal-closed").tension(.85),
+    fill = d3.scale.category20();
+function noop() { return false; }
+function nodeid(n) {
+  return n.size ? "_g_"+n.group : n.name;
+}
+function linkid(l) {
+  var u = nodeid(l.source),
+      v = nodeid(l.target);
+  return u<v ? u+"|"+v : v+"|"+u;
+}
+function getGroup(n) { return n.group; }
+// constructs the network to visualize
+function network(data, prev, index, expand) {
+  expand = expand || {};
+  var gm = {},    // group map
+      nm = {},    // node map
+      lm = {},    // link map
+      gn = {},    // previous group nodes
+      gc = {},    // previous group centroids
+      nodes = [], // output nodes
+      links = []; // output links
+  // process previous nodes for reuse or centroid calculation
+  if (prev) {
+    prev.nodes.forEach(function(n) {
+      var i = index(n), o;
+      if (n.size > 0) {
+        gn[i] = n;
+        n.size = 0;
+      } else {
+        o = gc[i] || (gc[i] = {x:0,y:0,count:0});
+        o.x += n.x;
+        o.y += n.y;
+        o.count += 1;
+      }
+    });
+  }
+  // determine nodes
+  for (var k=0; k<data.nodes.length; ++k) {
+    var n = data.nodes[k],
+        i = index(n);
+    if (expand[i]) {
+      // the node should be directly visible
+      nm[n.name] = nodes.length;
+      nodes.push(n);
+      if (gn[i]) {
+        // place new nodes at cluster location (plus jitter)
+        n.x = gn[i].x + Math.random();
+        n.y = gn[i].y + Math.random();
+      }
+    } else {
+      // the node is part of a collapsed cluster
+      var l = gm[i] || (gm[i]=gn[i]) || (gm[i]={group:i, size:0, nodes:[]});
+      if (l.size == 0) {
+        // if new cluster, add to set and position at centroid of leaf nodes
+        nm[i] = nodes.length;
+        nodes.push(l);
+        if (gc[i]) {
+          l.x = gc[i].x / gc[i].count;
+          l.y = gc[i].y / gc[i].count;
+        }
+      }
+      l.size += 1;
+      l.nodes.push(n);
+    }
+  }
+  // determine links
+  for (k=0; k<data.links.length; ++k) {
+    var e = data.links[k],
+        u = index(e.source),
+        v = index(e.target);
+    u = expand[u] ? nm[e.source.name] : nm[u];
+    v = expand[v] ? nm[e.target.name] : nm[v];
+    var i = (u<v ? u+"|"+v : v+"|"+u),
+        l = lm[i] || (lm[i] = {source:u, target:v, size:0});
+    l.size += 1;
+  }
+  for (i in lm) { links.push(lm[i]); }
+  return {nodes: nodes, links: links};
+}
+function convexHulls(nodes, index, offset) {
+  var h = {};
+  // create point sets
+  for (var k=0; k<nodes.length; ++k) {
+    var n = nodes[k];
+    if (n.size) continue;
+    var i = index(n),
+        l = h[i] || (h[i] = []);
+    l.push([n.x-offset, n.y-offset]);
+    l.push([n.x-offset, n.y+offset]);
+    l.push([n.x+offset, n.y-offset]);
+    l.push([n.x+offset, n.y+offset]);
+  }
+  // create convex hulls
+  var hulls = [];
+  for (i in h) {
+    hulls.push({group: i, path: d3.geom.hull(h[i])});
+  }
+  return hulls;
+}
+function drawCluster(d) {
+  return curve(d.path); // 0.8
+}
+// --------------------------------------------------------
+var body = d3.select("body");
+var vis = body.append("svg")
+   .attr("width", w)
+   .attr("height", h);
+d3.json("miserables.json", function(json) {
+  data = json;
+  for (var i=0; i<data.links.length; ++i) {
+    o = data.links[i];
+    o.source = data.nodes[o.source];
+    o.target = data.nodes[o.target];
+  }
+  hullg = vis.append("g");
+  linkg = vis.append("g");
+  nodeg = vis.append("g");
+  init();
+  vis.attr("opacity", 1e-6)
+    .transition()
+      .duration(1000)
+      .attr("opacity", 1);
+});
+function init() {
+  if (force) force.stop();
+  net = network(data, net, getGroup, expand);
+  force = d3.layout.force()
+      .nodes(net.nodes)
+      .links(net.links)
+      .size([w, h])
+      .linkDistance(50)
+      .start();
+  hullg.selectAll("path.hull").remove();
+  hull = hullg.selectAll("path.hull")
+      .data(convexHulls(net.nodes, getGroup, off))
+    .enter().append("path")
+      .attr("class", "hull")
+      .attr("d", drawCluster)
+      .style("fill", function(d) { return fill(d.group); })
+      .on("dblclick", function(d) { expand[d.group] = false; init(); });
+  link = linkg.selectAll("line.link").data(net.links, linkid);
+  link.exit().remove();
+  link.enter().append("line")
+      .attr("class", "link")
+      .attr("x1", function(d) { return d.source.x; })
+      .attr("y1", function(d) { return d.source.y; })
+      .attr("x2", function(d) { return d.target.x; })
+      .attr("y2", function(d) { return d.target.y; })
+      .style("stroke-width", function(d) { return d.size || 1; });
+  node = nodeg.selectAll("circle.node").data(net.nodes, nodeid);
+  node.exit().remove();
+  node.enter().append("circle")
+      .attr("class", function(d) { return "node" + (d.size?"":" leaf"); })
+      .attr("r", function(d) { return d.size ? d.size + dr : dr+1; })
+      .attr("cx", function(d) { return d.x; })
+      .attr("cy", function(d) { return d.y; })
+      .style("fill", function(d) { return fill(d.group); })
+      .on("dblclick", function(d) {
+        if (d.size) { expand[d.group] = true; init(); }
+      });
+  node.call(force.drag);
+  force.on("tick", function() {
+    if (!hull.empty()) {
+      hull.data(convexHulls(net.nodes, getGroup, off))
+          .attr("d", drawCluster);
+    }
+    link.attr("x1", function(d) { return d.source.x; })
+        .attr("y1", function(d) { return d.source.y; })
+        .attr("x2", function(d) { return d.target.x; })
+        .attr("y2", function(d) { return d.target.y; });
+    node.attr("cx", function(d) { return d.x; })
+        .attr("cy", function(d) { return d.y; });
+  });
+}
+    </script>
+  </body>
+</html>