stripchart 0.0.3

data/lib/stripchart/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/stripchart/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/stripchart/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/stripchart/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/stripchart/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/stripchart/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/stripchart/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/stripchart/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);
+  };
+}