stripmem 0.0.1

data/lib/stripmem/public/components/d3/src/scale/category.js

@@ -0,0 +1,57 @@
+import "ordinal";
+import "scale";
+
+/*
+ * This product includes color specifications and designs developed by Cynthia
+ * Brewer (http://colorbrewer.org/). See lib/colorbrewer for more information.
+ */
+
+d3.scale.category10 = function() {
+  return d3.scale.ordinal().range(d3_category10);
+};
+
+d3.scale.category20 = function() {
+  return d3.scale.ordinal().range(d3_category20);
+};
+
+d3.scale.category20b = function() {
+  return d3.scale.ordinal().range(d3_category20b);
+};
+
+d3.scale.category20c = function() {
+  return d3.scale.ordinal().range(d3_category20c);
+};
+
+var d3_category10 = [
+  "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd",
+  "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf"
+];
+
+var d3_category20 = [
+  "#1f77b4", "#aec7e8",
+  "#ff7f0e", "#ffbb78",
+  "#2ca02c", "#98df8a",
+  "#d62728", "#ff9896",
+  "#9467bd", "#c5b0d5",
+  "#8c564b", "#c49c94",
+  "#e377c2", "#f7b6d2",
+  "#7f7f7f", "#c7c7c7",
+  "#bcbd22", "#dbdb8d",
+  "#17becf", "#9edae5"
+];
+
+var d3_category20b = [
+  "#393b79", "#5254a3", "#6b6ecf", "#9c9ede",
+  "#637939", "#8ca252", "#b5cf6b", "#cedb9c",
+  "#8c6d31", "#bd9e39", "#e7ba52", "#e7cb94",
+  "#843c39", "#ad494a", "#d6616b", "#e7969c",
+  "#7b4173", "#a55194", "#ce6dbd", "#de9ed6"
+];
+
+var d3_category20c = [
+  "#3182bd", "#6baed6", "#9ecae1", "#c6dbef",
+  "#e6550d", "#fd8d3c", "#fdae6b", "#fdd0a2",
+  "#31a354", "#74c476", "#a1d99b", "#c7e9c0",
+  "#756bb1", "#9e9ac8", "#bcbddc", "#dadaeb",
+  "#636363", "#969696", "#bdbdbd", "#d9d9d9"
+];

data/lib/stripmem/public/components/d3/src/scale/identity.js

@@ -0,0 +1,33 @@
+import "linear";
+import "scale";
+
+d3.scale.identity = function() {
+  return d3_scale_identity([0, 1]);
+};
+
+function d3_scale_identity(domain) {
+
+  function identity(x) { return +x; }
+
+  identity.invert = identity;
+
+  identity.domain = identity.range = function(x) {
+    if (!arguments.length) return domain;
+    domain = x.map(identity);
+    return identity;
+  };
+
+  identity.ticks = function(m) {
+    return d3_scale_linearTicks(domain, m);
+  };
+
+  identity.tickFormat = function(m, format) {
+    return d3_scale_linearTickFormat(domain, m, format);
+  };
+
+  identity.copy = function() {
+    return d3_scale_identity(domain);
+  };
+
+  return identity;
+}

data/lib/stripmem/public/components/d3/src/scale/index.js

@@ -0,0 +1,11 @@
+import "scale";
+import "linear";
+import "log";
+import "pow";
+import "sqrt";
+import "ordinal";
+import "category";
+import "quantile";
+import "quantize";
+import "threshold";
+import "identity";

data/lib/stripmem/public/components/d3/src/scale/linear.js

@@ -0,0 +1,128 @@
+import "../arrays/range";
+import "../core/rebind";
+import "../interpolate/interpolate";
+import "../interpolate/round";
+import "../interpolate/uninterpolate";
+import "../format/format";
+import "bilinear";
+import "nice";
+import "polylinear";
+import "scale";
+
+d3.scale.linear = function() {
+  return d3_scale_linear([0, 1], [0, 1], d3_interpolate, false);
+};
+
+function d3_scale_linear(domain, range, interpolate, clamp) {
+  var output,
+      input;
+
+  function rescale() {
+    var linear = Math.min(domain.length, range.length) > 2 ? d3_scale_polylinear : d3_scale_bilinear,
+        uninterpolate = clamp ? d3_uninterpolateClamp : d3_uninterpolateNumber;
+    output = linear(domain, range, uninterpolate, interpolate);
+    input = linear(range, domain, uninterpolate, d3_interpolate);
+    return scale;
+  }
+
+  function scale(x) {
+    return output(x);
+  }
+
+  // Note: requires range is coercible to number!
+  scale.invert = function(y) {
+    return input(y);
+  };
+
+  scale.domain = function(x) {
+    if (!arguments.length) return domain;
+    domain = x.map(Number);
+    return rescale();
+  };
+
+  scale.range = function(x) {
+    if (!arguments.length) return range;
+    range = x;
+    return rescale();
+  };
+
+  scale.rangeRound = function(x) {
+    return scale.range(x).interpolate(d3_interpolateRound);
+  };
+
+  scale.clamp = function(x) {
+    if (!arguments.length) return clamp;
+    clamp = x;
+    return rescale();
+  };
+
+  scale.interpolate = function(x) {
+    if (!arguments.length) return interpolate;
+    interpolate = x;
+    return rescale();
+  };
+
+  scale.ticks = function(m) {
+    return d3_scale_linearTicks(domain, m);
+  };
+
+  scale.tickFormat = function(m, format) {
+    return d3_scale_linearTickFormat(domain, m, format);
+  };
+
+  scale.nice = function(m) {
+    d3_scale_linearNice(domain, m);
+    return rescale();
+  };
+
+  scale.copy = function() {
+    return d3_scale_linear(domain, range, interpolate, clamp);
+  };
+
+  return rescale();
+}
+
+function d3_scale_linearRebind(scale, linear) {
+  return d3.rebind(scale, linear, "range", "rangeRound", "interpolate", "clamp");
+}
+
+function d3_scale_linearNice(domain, m) {
+  return d3_scale_nice(domain, d3_scale_niceStep(m
+      ? d3_scale_linearTickRange(domain, m)[2]
+      : d3_scale_linearNiceStep(domain)));
+}
+
+function d3_scale_linearNiceStep(domain) {
+  var extent = d3_scaleExtent(domain),
+      span = extent[1] - extent[0];
+  return Math.pow(10, Math.round(Math.log(span) / Math.LN10) - 1);
+}
+
+function d3_scale_linearTickRange(domain, m) {
+  var extent = d3_scaleExtent(domain),
+      span = extent[1] - extent[0],
+      step = Math.pow(10, Math.floor(Math.log(span / m) / Math.LN10)),
+      err = m / span * step;
+
+  // Filter ticks to get closer to the desired count.
+  if (err <= .15) step *= 10;
+  else if (err <= .35) step *= 5;
+  else if (err <= .75) step *= 2;
+
+  // Round start and stop values to step interval.
+  extent[0] = Math.ceil(extent[0] / step) * step;
+  extent[1] = Math.floor(extent[1] / step) * step + step * .5; // inclusive
+  extent[2] = step;
+  return extent;
+}
+
+function d3_scale_linearTicks(domain, m) {
+  return d3.range.apply(d3, d3_scale_linearTickRange(domain, m));
+}
+
+function d3_scale_linearTickFormat(domain, m, format) {
+  var precision = -Math.floor(Math.log(d3_scale_linearTickRange(domain, m)[2]) / Math.LN10 + .01);
+  return d3.format(format
+      ? format.replace(d3_format_re, function(a, b, c, d, e, f, g, h, i, j) { return [b, c, d, e, f, g, h, i || "." + (precision - (j === "%") * 2), j].join(""); })
+      : ",." + precision + "f");
+}

data/lib/stripmem/public/components/d3/src/scale/log.js

@@ -0,0 +1,92 @@
+import "../format/format";
+import "linear";
+import "nice";
+import "scale";
+
+d3.scale.log = function() {
+  return d3_scale_log(d3.scale.linear().domain([0, 1]), 10, true, [1, 10]);
+};
+
+function d3_scale_log(linear, base, positive, domain) {
+
+  function log(x) {
+    return (positive ? Math.log(x < 0 ? 0 : x) : -Math.log(x > 0 ? 0 : -x)) / Math.log(base);
+  }
+
+  function pow(x) {
+    return positive ? Math.pow(base, x) : -Math.pow(base, -x);
+  }
+
+  function scale(x) {
+    return linear(log(x));
+  }
+
+  scale.invert = function(x) {
+    return pow(linear.invert(x));
+  };
+
+  scale.domain = function(x) {
+    if (!arguments.length) return domain;
+    positive = x[0] >= 0;
+    linear.domain((domain = x.map(Number)).map(log));
+    return scale;
+  };
+
+  scale.base = function(_) {
+    if (!arguments.length) return base;
+    base = +_;
+    linear.domain(domain.map(log));
+    return scale;
+  };
+
+  scale.nice = function() {
+    var niced = d3_scale_nice(domain.map(log), positive ? Math : d3_scale_logNiceNegative);
+    linear.domain(niced); // do not modify the linear scale’s domain in-place!
+    domain = niced.map(pow);
+    return scale;
+  };
+
+  scale.ticks = function() {
+    var extent = d3_scaleExtent(domain),
+        ticks = [];
+    if (extent.every(isFinite)) {
+      var u = extent[0],
+          v = extent[1],
+          i = Math.floor(log(u)),
+          j = Math.ceil(log(v)),
+          n = base % 1 ? 2 : base;
+      if (positive) {
+        for (; i < j; i++) for (var k = 1; k < n; k++) ticks.push(pow(i) * k);
+        ticks.push(pow(i));
+      } else {
+        ticks.push(pow(i));
+        for (; i++ < j;) for (var k = n - 1; k > 0; k--) ticks.push(pow(i) * k);
+      }
+      for (i = 0; ticks[i] < u; i++) {} // strip small values
+      for (j = ticks.length; ticks[j - 1] > v; j--) {} // strip big values
+      ticks = ticks.slice(i, j);
+    }
+    return ticks;
+  };
+
+  scale.tickFormat = function(n, format) {
+    if (!arguments.length) return d3_scale_logFormat;
+    if (arguments.length < 2) format = d3_scale_logFormat;
+    else if (typeof format !== "function") format = d3.format(format);
+    var k = Math.max(.1, n / scale.ticks().length),
+        f = positive ? (e = 1e-12, Math.ceil) : (e = -1e-12, Math.floor),
+        e;
+    return function(d) {
+      return d / pow(f(log(d) + e)) <= k ? format(d) : "";
+    };
+  };
+
+  scale.copy = function() {
+    return d3_scale_log(linear.copy(), base, positive, domain);
+  };
+
+  return d3_scale_linearRebind(scale, linear);
+}
+
+var d3_scale_logFormat = d3.format(".0e"),
+    d3_scale_logNiceNegative = {floor: function(x) { return -Math.ceil(-x); }, ceil: function(x) { return -Math.floor(-x); }};

data/lib/stripmem/public/components/d3/src/scale/nice.js

@@ -0,0 +1,28 @@
+function d3_scale_nice(domain, nice) {
+  var i0 = 0,
+      i1 = domain.length - 1,
+      x0 = domain[i0],
+      x1 = domain[i1],
+      dx;
+
+  if (x1 < x0) {
+    dx = i0, i0 = i1, i1 = dx;
+    dx = x0, x0 = x1, x1 = dx;
+  }
+
+  domain[i0] = nice.floor(x0);
+  domain[i1] = nice.ceil(x1);
+  return domain;
+}
+
+function d3_scale_niceStep(step) {
+  return step ? {
+    floor: function(x) { return Math.floor(x / step) * step; },
+    ceil: function(x) { return Math.ceil(x / step) * step; }
+  } : d3_scale_niceIdentity;
+}
+
+var d3_scale_niceIdentity = {
+  floor: d3_identity,
+  ceil: d3_identity
+};

data/lib/stripmem/public/components/d3/src/scale/ordinal.js

@@ -0,0 +1,92 @@
+import "../arrays/map";
+import "../arrays/range";
+import "scale";
+
+d3.scale.ordinal = function() {
+  return d3_scale_ordinal([], {t: "range", a: [[]]});
+};
+
+function d3_scale_ordinal(domain, ranger) {
+  var index,
+      range,
+      rangeBand;
+
+  function scale(x) {
+    return range[((index.get(x) || index.set(x, domain.push(x))) - 1) % range.length];
+  }
+
+  function steps(start, step) {
+    return d3.range(domain.length).map(function(i) { return start + step * i; });
+  }
+
+  scale.domain = function(x) {
+    if (!arguments.length) return domain;
+    domain = [];
+    index = new d3_Map;
+    var i = -1, n = x.length, xi;
+    while (++i < n) if (!index.has(xi = x[i])) index.set(xi, domain.push(xi));
+    return scale[ranger.t].apply(scale, ranger.a);
+  };
+
+  scale.range = function(x) {
+    if (!arguments.length) return range;
+    range = x;
+    rangeBand = 0;
+    ranger = {t: "range", a: arguments};
+    return scale;
+  };
+
+  scale.rangePoints = function(x, padding) {
+    if (arguments.length < 2) padding = 0;
+    var start = x[0],
+        stop = x[1],
+        step = (stop - start) / (Math.max(1, domain.length - 1) + padding);
+    range = steps(domain.length < 2 ? (start + stop) / 2 : start + step * padding / 2, step);
+    rangeBand = 0;
+    ranger = {t: "rangePoints", a: arguments};
+    return scale;
+  };
+
+  scale.rangeBands = function(x, padding, outerPadding) {
+    if (arguments.length < 2) padding = 0;
+    if (arguments.length < 3) outerPadding = padding;
+    var reverse = x[1] < x[0],
+        start = x[reverse - 0],
+        stop = x[1 - reverse],
+        step = (stop - start) / (domain.length - padding + 2 * outerPadding);
+    range = steps(start + step * outerPadding, step);
+    if (reverse) range.reverse();
+    rangeBand = step * (1 - padding);
+    ranger = {t: "rangeBands", a: arguments};
+    return scale;
+  };
+
+  scale.rangeRoundBands = function(x, padding, outerPadding) {
+    if (arguments.length < 2) padding = 0;
+    if (arguments.length < 3) outerPadding = padding;
+    var reverse = x[1] < x[0],
+        start = x[reverse - 0],
+        stop = x[1 - reverse],
+        step = Math.floor((stop - start) / (domain.length - padding + 2 * outerPadding)),
+        error = stop - start - (domain.length - padding) * step;
+    range = steps(start + Math.round(error / 2), step);
+    if (reverse) range.reverse();
+    rangeBand = Math.round(step * (1 - padding));
+    ranger = {t: "rangeRoundBands", a: arguments};
+    return scale;
+  };
+
+  scale.rangeBand = function() {
+    return rangeBand;
+  };
+
+  scale.rangeExtent = function() {
+    return d3_scaleExtent(ranger.a[0]);
+  };
+
+  scale.copy = function() {
+    return d3_scale_ordinal(domain, ranger);
+  };
+
+  return scale.domain(domain);
+}

data/lib/stripmem/public/components/d3/src/scale/polylinear.js

@@ -0,0 +1,24 @@
+import "../arrays/bisect";
+
+function d3_scale_polylinear(domain, range, uninterpolate, interpolate) {
+  var u = [],
+      i = [],
+      j = 0,
+      k = Math.min(domain.length, range.length) - 1;
+
+  // Handle descending domains.
+  if (domain[k] < domain[0]) {
+    domain = domain.slice().reverse();
+    range = range.slice().reverse();
+  }
+
+  while (++j <= k) {
+    u.push(uninterpolate(domain[j - 1], domain[j]));
+    i.push(interpolate(range[j - 1], range[j]));
+  }
+
+  return function(x) {
+    var j = d3.bisect(domain, x, 1, k) - 1;
+    return i[j](u[j](x));
+  };
+}

data/lib/stripmem/public/components/d3/src/scale/pow.js

@@ -0,0 +1,58 @@
+import "linear";
+import "nice";
+import "scale";
+
+d3.scale.pow = function() {
+  return d3_scale_pow(d3.scale.linear(), 1, [0, 1]);
+};
+
+function d3_scale_pow(linear, exponent, domain) {
+  var powp = d3_scale_powPow(exponent),
+      powb = d3_scale_powPow(1 / exponent);
+
+  function scale(x) {
+    return linear(powp(x));
+  }
+
+  scale.invert = function(x) {
+    return powb(linear.invert(x));
+  };
+
+  scale.domain = function(x) {
+    if (!arguments.length) return domain;
+    linear.domain((domain = x.map(Number)).map(powp));
+    return scale;
+  };
+
+  scale.ticks = function(m) {
+    return d3_scale_linearTicks(domain, m);
+  };
+
+  scale.tickFormat = function(m, format) {
+    return d3_scale_linearTickFormat(domain, m, format);
+  };
+
+  scale.nice = function(m) {
+    return scale.domain(d3_scale_linearNice(domain, m));
+  };
+
+  scale.exponent = function(x) {
+    if (!arguments.length) return exponent;
+    powp = d3_scale_powPow(exponent = x);
+    powb = d3_scale_powPow(1 / exponent);
+    linear.domain(domain.map(powp));
+    return scale;
+  };
+
+  scale.copy = function() {
+    return d3_scale_pow(linear.copy(), exponent, domain);
+  };
+
+  return d3_scale_linearRebind(scale, linear);
+}
+
+function d3_scale_powPow(e) {
+  return function(x) {
+    return x < 0 ? -Math.pow(-x, e) : Math.pow(x, e);
+  };
+}

data/lib/stripmem/public/components/d3/src/scale/quantile.js

@@ -0,0 +1,54 @@
+import "../arrays/ascending";
+import "../arrays/bisect";
+import "../arrays/quantile";
+import "scale";
+
+d3.scale.quantile = function() {
+  return d3_scale_quantile([], []);
+};
+
+function d3_scale_quantile(domain, range) {
+  var thresholds;
+
+  function rescale() {
+    var k = 0,
+        q = range.length;
+    thresholds = [];
+    while (++k < q) thresholds[k - 1] = d3.quantile(domain, k / q);
+    return scale;
+  }
+
+  function scale(x) {
+    if (!isNaN(x = +x)) return range[d3.bisect(thresholds, x)];
+  }
+
+  scale.domain = function(x) {
+    if (!arguments.length) return domain;
+    domain = x.filter(function(d) { return !isNaN(d); }).sort(d3.ascending);
+    return rescale();
+  };
+
+  scale.range = function(x) {
+    if (!arguments.length) return range;
+    range = x;
+    return rescale();
+  };
+
+  scale.quantiles = function() {
+    return thresholds;
+  };
+
+  scale.invertExtent = function(y) {
+    y = range.indexOf(y);
+    return y < 0 ? [NaN, NaN] : [
+      y > 0 ? thresholds[y - 1] : domain[0],
+      y < thresholds.length ? thresholds[y] : domain[domain.length - 1]
+    ];
+  };
+
+  scale.copy = function() {
+    return d3_scale_quantile(domain, range); // copy on write!
+  };
+
+  return rescale();
+}

data/lib/stripmem/public/components/d3/src/scale/quantize.js

@@ -0,0 +1,44 @@
+import "scale";
+
+d3.scale.quantize = function() {
+  return d3_scale_quantize(0, 1, [0, 1]);
+};
+
+function d3_scale_quantize(x0, x1, range) {
+  var kx, i;
+
+  function scale(x) {
+    return range[Math.max(0, Math.min(i, Math.floor(kx * (x - x0))))];
+  }
+
+  function rescale() {
+    kx = range.length / (x1 - x0);
+    i = range.length - 1;
+    return scale;
+  }
+
+  scale.domain = function(x) {
+    if (!arguments.length) return [x0, x1];
+    x0 = +x[0];
+    x1 = +x[x.length - 1];
+    return rescale();
+  };
+
+  scale.range = function(x) {
+    if (!arguments.length) return range;
+    range = x;
+    return rescale();
+  };
+
+  scale.invertExtent = function(y) {
+    y = range.indexOf(y);
+    y = y < 0 ? NaN : y / kx + x0;
+    return [y, y + 1 / kx];
+  };
+
+  scale.copy = function() {
+    return d3_scale_quantize(x0, x1, range); // copy on write
+  };
+
+  return rescale();
+}

data/lib/stripmem/public/components/d3/src/scale/scale.js

@@ -0,0 +1,10 @@
+d3.scale = {};
+
+function d3_scaleExtent(domain) {
+  var start = domain[0], stop = domain[domain.length - 1];
+  return start < stop ? [start, stop] : [stop, start];
+}
+
+function d3_scaleRange(scale) {
+  return scale.rangeExtent ? scale.rangeExtent() : d3_scaleExtent(scale.range());
+}

data/lib/stripmem/public/components/d3/src/scale/sqrt.js

@@ -0,0 +1,6 @@
+import "pow";
+import "scale";
+
+d3.scale.sqrt = function() {
+  return d3.scale.pow().exponent(.5);
+};

data/lib/stripmem/public/components/d3/src/scale/threshold.js

@@ -0,0 +1,36 @@
+import "../arrays/bisect";
+import "scale";
+
+d3.scale.threshold = function() {
+  return d3_scale_threshold([.5], [0, 1]);
+};
+
+function d3_scale_threshold(domain, range) {
+
+  function scale(x) {
+    if (x <= x) return range[d3.bisect(domain, x)];
+  }
+
+  scale.domain = function(_) {
+    if (!arguments.length) return domain;
+    domain = _;
+    return scale;
+  };
+
+  scale.range = function(_) {
+    if (!arguments.length) return range;
+    range = _;
+    return scale;
+  };
+
+  scale.invertExtent = function(y) {
+    y = range.indexOf(y);
+    return [domain[y - 1], domain[y]];
+  };
+
+  scale.copy = function() {
+    return d3_scale_threshold(domain, range);
+  };
+
+  return scale;
+};

data/lib/stripmem/public/components/d3/src/selection/append.js

@@ -0,0 +1,16 @@
+import "../core/document";
+import "../core/ns";
+import "selection";
+
+d3_selectionPrototype.append = function(name) {
+  name = d3_selection_creator(name);
+  return this.select(function() {
+    return this.appendChild(name.apply(this, arguments));
+  });
+};
+
+function d3_selection_creator(name) {
+  return typeof name === "function" ? name
+      : (name = d3.ns.qualify(name)).local ? function() { return d3_document.createElementNS(name.space, name.local); }
+      : function() { return d3_document.createElementNS(this.namespaceURI, name); };
+}