picky-statistics 4.0.0pre3 → 4.0.0pre5

data/lib/picky-statistics/application/javascripts/d3/src/core/transition-style.js

@@ -0,0 +1,14 @@
+d3_transitionPrototype.style = function(name, value, priority) {
+  if (arguments.length < 3) priority = "";
+  return this.styleTween(name, d3_transitionTween(name, value), priority);
+};
+
+d3_transitionPrototype.styleTween = function(name, tween, priority) {
+  if (arguments.length < 3) priority = "";
+  return this.tween("style." + name, function(d, i) {
+    var f = tween.call(this, d, i, window.getComputedStyle(this, null).getPropertyValue(name));
+    return f === d3_transitionRemove
+        ? (this.style.removeProperty(name), null)
+        : f && function(t) { this.style.setProperty(name, f(t), priority); };
+  });
+};

data/lib/picky-statistics/application/javascripts/d3/src/core/transition-text.js

@@ -0,0 +1,7 @@
+d3_transitionPrototype.text = function(value) {
+  return this.tween("text", function(d, i) {
+    this.textContent = typeof value === "function"
+        ? value.call(this, d, i)
+        : value;
+  });
+};

data/lib/picky-statistics/application/javascripts/d3/src/core/transition-transition.js

@@ -0,0 +1,3 @@
+d3_transitionPrototype.transition = function() {
+  return this.select(d3_this);
+};

data/lib/picky-statistics/application/javascripts/d3/src/core/transition.js

@@ -0,0 +1,125 @@
+function d3_transition(groups, id, time) {
+  d3_arraySubclass(groups, d3_transitionPrototype);
+
+  var tweens = {},
+      event = d3.dispatch("start", "end"),
+      ease = d3_transitionEase;
+
+  groups.id = id;
+
+  groups.time = time;
+
+  groups.tween = function(name, tween) {
+    if (arguments.length < 2) return tweens[name];
+    if (tween == null) delete tweens[name];
+    else tweens[name] = tween;
+    return groups;
+  };
+
+  groups.ease = function(value) {
+    if (!arguments.length) return ease;
+    ease = typeof value === "function" ? value : d3.ease.apply(d3, arguments);
+    return groups;
+  };
+
+  groups.each = function(type, listener) {
+    if (arguments.length < 2) return d3_transition_each.call(groups, type);
+    event.on(type, listener);
+    return groups;
+  };
+
+  d3.timer(function(elapsed) {
+    groups.each(function(d, i, j) {
+      var tweened = [],
+          node = this,
+          delay = groups[j][i].delay,
+          duration = groups[j][i].duration,
+          lock = node.__transition__ || (node.__transition__ = {active: 0, count: 0});
+
+      ++lock.count;
+
+      delay <= elapsed ? start(elapsed) : d3.timer(start, delay, time);
+
+      function start(elapsed) {
+        if (lock.active > id) return stop();
+        lock.active = id;
+
+        for (var tween in tweens) {
+          if (tween = tweens[tween].call(node, d, i)) {
+            tweened.push(tween);
+          }
+        }
+
+        event.start.call(node, d, i);
+        if (!tick(elapsed)) d3.timer(tick, 0, time);
+        return 1;
+      }
+
+      function tick(elapsed) {
+        if (lock.active !== id) return stop();
+
+        var t = (elapsed - delay) / duration,
+            e = ease(t),
+            n = tweened.length;
+
+        while (n > 0) {
+          tweened[--n].call(node, e);
+        }
+
+        if (t >= 1) {
+          stop();
+          d3_transitionInheritId = id;
+          event.end.call(node, d, i);
+          d3_transitionInheritId = 0;
+          return 1;
+        }
+      }
+
+      function stop() {
+        if (!--lock.count) delete node.__transition__;
+        return 1;
+      }
+    });
+    return 1;
+  }, 0, time);
+
+  return groups;
+}
+
+var d3_transitionRemove = {};
+
+function d3_transitionNull(d, i, a) {
+  return a != "" && d3_transitionRemove;
+}
+
+function d3_transitionTween(name, b) {
+  var interpolate = d3_interpolateByName(name);
+
+  function transitionFunction(d, i, a) {
+    var v = b.call(this, d, i);
+    return v == null
+        ? a != "" && d3_transitionRemove
+        : a != v && interpolate(a, v);
+  }
+
+  function transitionString(d, i, a) {
+    return a != b && interpolate(a, b);
+  }
+
+  return typeof b === "function" ? transitionFunction
+      : b == null ? d3_transitionNull
+      : (b += "", transitionString);
+}
+
+var d3_transitionPrototype = [],
+    d3_transitionId = 0,
+    d3_transitionInheritId = 0,
+    d3_transitionEase = d3.ease("cubic-in-out");
+
+d3_transitionPrototype.call = d3_selectionPrototype.call;
+
+d3.transition = function() {
+  return d3_selectionRoot.transition();
+};
+
+d3.transition.prototype = d3_transitionPrototype;

data/lib/picky-statistics/application/javascripts/d3/src/core/transpose.js

@@ -0,0 +1,3 @@
+d3.transpose = function(matrix) {
+  return d3.zip.apply(d3, matrix);
+};

data/lib/picky-statistics/application/javascripts/d3/src/core/uninterpolate.js

@@ -0,0 +1,9 @@
+function d3_uninterpolateNumber(a, b) {
+  b = b - (a = +a) ? 1 / (b - a) : 0;
+  return function(x) { return (x - a) * b; };
+}
+
+function d3_uninterpolateClamp(a, b) {
+  b = b - (a = +a) ? 1 / (b - a) : 0;
+  return function(x) { return Math.max(0, Math.min(1, (x - a) * b)); };
+}

data/lib/picky-statistics/application/javascripts/d3/src/core/values.js

@@ -0,0 +1,5 @@
+d3.values = function(map) {
+  var values = [];
+  for (var key in map) values.push(map[key]);
+  return values;
+};

data/lib/picky-statistics/application/javascripts/d3/src/core/xhr.js

@@ -0,0 +1,10 @@
+d3.xhr = function(url, mime, callback) {
+  var req = new XMLHttpRequest;
+  if (arguments.length < 3) callback = mime;
+  else if (mime && req.overrideMimeType) req.overrideMimeType(mime);
+  req.open("GET", url, true);
+  req.onreadystatechange = function() {
+    if (req.readyState === 4) callback(req.status < 300 ? req : null);
+  };
+  req.send(null);
+};

data/lib/picky-statistics/application/javascripts/d3/src/core/xml.js

@@ -0,0 +1,10 @@
+d3.xml = function(url, mime, callback) {
+  function ready(req) {
+    callback(req && req.responseXML);
+  }
+  if (arguments.length < 3) {
+    callback = mime;
+    mime = null;
+  }
+  d3.xhr(url, mime, ready);
+};

data/lib/picky-statistics/application/javascripts/d3/src/core/zip.js

@@ -0,0 +1,13 @@
+d3.zip = function() {
+  if (!(n = arguments.length)) return [];
+  for (var i = -1, m = d3.min(arguments, d3_zipLength), zips = new Array(m); ++i < m;) {
+    for (var j = -1, n, zip = zips[i] = new Array(n); ++j < n;) {
+      zip[j] = arguments[j][i];
+    }
+  }
+  return zips;
+};
+
+function d3_zipLength(d) {
+  return d.length;
+}

data/lib/picky-statistics/application/javascripts/d3/src/csv/csv.js

@@ -0,0 +1,5 @@
+d3.csv = function(url, callback) {
+  d3.text(url, "text/csv", function(text) {
+    callback(text && d3.csv.parse(text));
+  });
+};

data/lib/picky-statistics/application/javascripts/d3/src/csv/format.js

@@ -0,0 +1,13 @@
+d3.csv.format = function(rows) {
+  return rows.map(d3_csv_formatRow).join("\n");
+};
+
+function d3_csv_formatRow(row) {
+  return row.map(d3_csv_formatValue).join(",");
+}
+
+function d3_csv_formatValue(text) {
+  return /[",\n]/.test(text)
+      ? "\"" + text.replace(/\"/g, "\"\"") + "\""
+      : text;
+}

data/lib/picky-statistics/application/javascripts/d3/src/csv/parse.js

@@ -0,0 +1,73 @@
+d3.csv.parse = function(text) {
+  var header;
+  return d3.csv.parseRows(text, function(row, i) {
+    if (i) {
+      var o = {}, j = -1, m = header.length;
+      while (++j < m) o[header[j]] = row[j];
+      return o;
+    } else {
+      header = row;
+      return null;
+    }
+  });
+};
+
+d3.csv.parseRows = function(text, f) {
+  var EOL = {}, // sentinel value for end-of-line
+      EOF = {}, // sentinel value for end-of-file
+      rows = [], // output rows
+      re = /\r\n|[,\r\n]/g, // field separator regex
+      n = 0, // the current line number
+      t, // the current token
+      eol; // is the current token followed by EOL?
+
+  re.lastIndex = 0; // work-around bug in FF 3.6
+
+  /** @private Returns the next token. */
+  function token() {
+    if (re.lastIndex >= text.length) return EOF; // special case: end of file
+    if (eol) { eol = false; return EOL; } // special case: end of line
+
+    // special case: quotes
+    var j = re.lastIndex;
+    if (text.charCodeAt(j) === 34) {
+      var i = j;
+      while (i++ < text.length) {
+        if (text.charCodeAt(i) === 34) {
+          if (text.charCodeAt(i + 1) !== 34) break;
+          i++;
+        }
+      }
+      re.lastIndex = i + 2;
+      var c = text.charCodeAt(i + 1);
+      if (c === 13) {
+        eol = true;
+        if (text.charCodeAt(i + 2) === 10) re.lastIndex++;
+      } else if (c === 10) {
+        eol = true;
+      }
+      return text.substring(j + 1, i).replace(/""/g, "\"");
+    }
+
+    // common case
+    var m = re.exec(text);
+    if (m) {
+      eol = m[0].charCodeAt(0) !== 44;
+      return text.substring(j, m.index);
+    }
+    re.lastIndex = text.length;
+    return text.substring(j);
+  }
+
+  while ((t = token()) !== EOF) {
+    var a = [];
+    while ((t !== EOL) && (t !== EOF)) {
+      a.push(t);
+      t = token();
+    }
+    if (f && !(a = f(a, n++))) continue;
+    rows.push(a);
+  }
+
+  return rows;
+};

data/lib/picky-statistics/application/javascripts/d3/src/end.js

@@ -0,0 +1 @@
+})();

data/lib/picky-statistics/application/javascripts/d3/src/externs.js

@@ -0,0 +1,6 @@
+// JavaScript built-ins.
+var console,
+    JSON;
+
+// d3
+var d3;

data/lib/picky-statistics/application/javascripts/d3/src/geo/albers.js

@@ -0,0 +1,126 @@
+// Derived from Tom Carden's Albers implementation for Protovis.
+// http://gist.github.com/476238
+// http://mathworld.wolfram.com/AlbersEqual-AreaConicProjection.html
+
+d3.geo.albers = function() {
+  var origin = [-98, 38],
+      parallels = [29.5, 45.5],
+      scale = 1000,
+      translate = [480, 250],
+      lng0, // d3_geo_radians * origin[0]
+      n,
+      C,
+      p0;
+
+  function albers(coordinates) {
+    var t = n * (d3_geo_radians * coordinates[0] - lng0),
+        p = Math.sqrt(C - 2 * n * Math.sin(d3_geo_radians * coordinates[1])) / n;
+    return [
+      scale * p * Math.sin(t) + translate[0],
+      scale * (p * Math.cos(t) - p0) + translate[1]
+    ];
+  }
+
+  albers.invert = function(coordinates) {
+    var x = (coordinates[0] - translate[0]) / scale,
+        y = (coordinates[1] - translate[1]) / scale,
+        p0y = p0 + y,
+        t = Math.atan2(x, p0y),
+        p = Math.sqrt(x * x + p0y * p0y);
+    return [
+      (lng0 + t / n) / d3_geo_radians,
+      Math.asin((C - p * p * n * n) / (2 * n)) / d3_geo_radians
+    ];
+  };
+
+  function reload() {
+    var phi1 = d3_geo_radians * parallels[0],
+        phi2 = d3_geo_radians * parallels[1],
+        lat0 = d3_geo_radians * origin[1],
+        s = Math.sin(phi1),
+        c = Math.cos(phi1);
+    lng0 = d3_geo_radians * origin[0];
+    n = .5 * (s + Math.sin(phi2));
+    C = c * c + 2 * n * s;
+    p0 = Math.sqrt(C - 2 * n * Math.sin(lat0)) / n;
+    return albers;
+  }
+
+  albers.origin = function(x) {
+    if (!arguments.length) return origin;
+    origin = [+x[0], +x[1]];
+    return reload();
+  };
+
+  albers.parallels = function(x) {
+    if (!arguments.length) return parallels;
+    parallels = [+x[0], +x[1]];
+    return reload();
+  };
+
+  albers.scale = function(x) {
+    if (!arguments.length) return scale;
+    scale = +x;
+    return albers;
+  };
+
+  albers.translate = function(x) {
+    if (!arguments.length) return translate;
+    translate = [+x[0], +x[1]];
+    return albers;
+  };
+
+  return reload();
+};
+
+// A composite projection for the United States, 960x500. The set of standard
+// parallels for each region comes from USGS, which is published here:
+// http://egsc.usgs.gov/isb/pubs/MapProjections/projections.html#albers
+// TODO allow the composite projection to be rescaled?
+d3.geo.albersUsa = function() {
+  var lower48 = d3.geo.albers();
+
+  var alaska = d3.geo.albers()
+      .origin([-160, 60])
+      .parallels([55, 65]);
+
+  var hawaii = d3.geo.albers()
+      .origin([-160, 20])
+      .parallels([8, 18]);
+
+  var puertoRico = d3.geo.albers()
+      .origin([-60, 10])
+      .parallels([8, 18]);
+
+  function albersUsa(coordinates) {
+    var lon = coordinates[0],
+        lat = coordinates[1];
+    return (lat > 50 ? alaska
+        : lon < -140 ? hawaii
+        : lat < 21 ? puertoRico
+        : lower48)(coordinates);
+  }
+
+  albersUsa.scale = function(x) {
+    if (!arguments.length) return lower48.scale();
+    lower48.scale(x);
+    alaska.scale(x * .6);
+    hawaii.scale(x);
+    puertoRico.scale(x * 1.5);
+    return albersUsa.translate(lower48.translate());
+  };
+
+  albersUsa.translate = function(x) {
+    if (!arguments.length) return lower48.translate();
+    var dz = lower48.scale() / 1000,
+        dx = x[0],
+        dy = x[1];
+    lower48.translate(x);
+    alaska.translate([dx - 400 * dz, dy + 170 * dz]);
+    hawaii.translate([dx - 190 * dz, dy + 200 * dz]);
+    puertoRico.translate([dx + 580 * dz, dy + 430 * dz]);
+    return albersUsa;
+  };
+
+  return albersUsa.scale(lower48.scale());
+};