mdarray-sol 0.1.0-java

data/node_modules/dc/node_modules/d3/src/locale/zh-CN.js

@@ -0,0 +1,16 @@
+import "locale";
+
+var d3_locale_zhCN = d3.locale({
+  decimal: ".",
+  thousands: ",",
+  grouping: [3],
+  currency: ["¥", ""],
+  dateTime: "%x %A %X",
+  date: "%Y年%-m月%-d日",
+  time: "%H:%M:%S",
+  periods: ["上午", "下午"],
+  days: ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"],
+  shortDays: ["周日", "周一", "周二", "周三", "周四", "周五", "周六"],
+  months: ["一月", "二月", "三月", "四月", "五月", "六月", "七月", "八月", "九月", "十月", "十一月", "十二月"],
+  shortMonths: ["一月", "二月", "三月", "四月", "五月", "六月", "七月", "八月", "九月", "十月", "十一月", "十二月"]
+});

data/node_modules/dc/node_modules/d3/src/math/abs.js

@@ -0,0 +1 @@
+var abs = Math.abs;

data/node_modules/dc/node_modules/d3/src/math/adder.js

@@ -0,0 +1,34 @@
+// Adds floating point numbers with twice the normal precision.
+// Reference: J. R. Shewchuk, Adaptive Precision Floating-Point Arithmetic and
+// Fast Robust Geometric Predicates, Discrete & Computational Geometry 18(3)
+// 305–363 (1997).
+// Code adapted from GeographicLib by Charles F. F. Karney,
+// http://geographiclib.sourceforge.net/
+// See lib/geographiclib/LICENSE for details.
+
+function d3_adder() {}
+
+d3_adder.prototype = {
+  s: 0, // rounded value
+  t: 0, // exact error
+  add: function(y) {
+    d3_adderSum(y, this.t, d3_adderTemp);
+    d3_adderSum(d3_adderTemp.s, this.s, this);
+    if (this.s) this.t += d3_adderTemp.t;
+    else this.s = d3_adderTemp.t;
+  },
+  reset: function() {
+    this.s = this.t = 0;
+  },
+  valueOf: function() {
+    return this.s;
+  }
+};
+
+var d3_adderTemp = new d3_adder;
+
+function d3_adderSum(a, b, o) {
+  var x = o.s = a + b, // a + b
+      bv = x - a, av = x - bv; // b_virtual & a_virtual
+  o.t = (a - av) + (b - bv); // a_roundoff + b_roundoff
+}

data/node_modules/dc/node_modules/d3/src/math/index.js

@@ -0,0 +1,2 @@
+import "random";
+import "transform";

data/node_modules/dc/node_modules/d3/src/math/number.js

@@ -0,0 +1,7 @@
+function d3_number(x) {
+  return x === null ? NaN : +x;
+}
+
+function d3_numeric(x) {
+  return !isNaN(x);
+}

data/node_modules/dc/node_modules/d3/src/math/random.js

@@ -0,0 +1,34 @@
+d3.random = {
+  normal: function(µ, σ) {
+    var n = arguments.length;
+    if (n < 2) σ = 1;
+    if (n < 1) µ = 0;
+    return function() {
+      var x, y, r;
+      do {
+        x = Math.random() * 2 - 1;
+        y = Math.random() * 2 - 1;
+        r = x * x + y * y;
+      } while (!r || r > 1);
+      return µ + σ * x * Math.sqrt(-2 * Math.log(r) / r);
+    };
+  },
+  logNormal: function() {
+    var random = d3.random.normal.apply(d3, arguments);
+    return function() {
+      return Math.exp(random());
+    };
+  },
+  bates: function(m) {
+    var random = d3.random.irwinHall(m);
+    return function() {
+      return random() / m;
+    };
+  },
+  irwinHall: function(m) {
+    return function() {
+      for (var s = 0, j = 0; j < m; j++) s += Math.random();
+      return s;
+    };
+  }
+};

data/node_modules/dc/node_modules/d3/src/math/transform.js

@@ -0,0 +1,64 @@
+import "../core/document";
+import "../core/ns";
+
+d3.transform = function(string) {
+  var g = d3_document.createElementNS(d3.ns.prefix.svg, "g");
+  return (d3.transform = function(string) {
+    if (string != null) {
+      g.setAttribute("transform", string);
+      var t = g.transform.baseVal.consolidate();
+    }
+    return new d3_transform(t ? t.matrix : d3_transformIdentity);
+  })(string);
+};
+
+// Compute x-scale and normalize the first row.
+// Compute shear and make second row orthogonal to first.
+// Compute y-scale and normalize the second row.
+// Finally, compute the rotation.
+function d3_transform(m) {
+  var r0 = [m.a, m.b],
+      r1 = [m.c, m.d],
+      kx = d3_transformNormalize(r0),
+      kz = d3_transformDot(r0, r1),
+      ky = d3_transformNormalize(d3_transformCombine(r1, r0, -kz)) || 0;
+  if (r0[0] * r1[1] < r1[0] * r0[1]) {
+    r0[0] *= -1;
+    r0[1] *= -1;
+    kx *= -1;
+    kz *= -1;
+  }
+  this.rotate = (kx ? Math.atan2(r0[1], r0[0]) : Math.atan2(-r1[0], r1[1])) * d3_degrees;
+  this.translate = [m.e, m.f];
+  this.scale = [kx, ky];
+  this.skew = ky ? Math.atan2(kz, ky) * d3_degrees : 0;
+};
+
+d3_transform.prototype.toString = function() {
+  return "translate(" + this.translate
+      + ")rotate(" + this.rotate
+      + ")skewX(" + this.skew
+      + ")scale(" + this.scale
+      + ")";
+};
+
+function d3_transformDot(a, b) {
+  return a[0] * b[0] + a[1] * b[1];
+}
+
+function d3_transformNormalize(a) {
+  var k = Math.sqrt(d3_transformDot(a, a));
+  if (k) {
+    a[0] /= k;
+    a[1] /= k;
+  }
+  return k;
+}
+
+function d3_transformCombine(a, b, k) {
+  a[0] += k * b[0];
+  a[1] += k * b[1];
+  return a;
+}
+
+var d3_transformIdentity = {a: 1, b: 0, c: 0, d: 1, e: 0, f: 0};

data/node_modules/dc/node_modules/d3/src/math/trigonometry.js

@@ -0,0 +1,44 @@
+var ε = 1e-6,
+    ε2 = ε * ε,
+    π = Math.PI,
+    τ = 2 * π,
+    τε = τ - ε,
+    halfπ = π / 2,
+    d3_radians = π / 180,
+    d3_degrees = 180 / π;
+
+function d3_sgn(x) {
+  return x > 0 ? 1 : x < 0 ? -1 : 0;
+}
+
+// Returns the 2D cross product of AB and AC vectors, i.e., the z-component of
+// the 3D cross product in a quadrant I Cartesian coordinate system (+x is
+// right, +y is up). Returns a positive value if ABC is counter-clockwise,
+// negative if clockwise, and zero if the points are collinear.
+function d3_cross2d(a, b, c) {
+  return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+}
+
+function d3_acos(x) {
+  return x > 1 ? 0 : x < -1 ? π : Math.acos(x);
+}
+
+function d3_asin(x) {
+  return x > 1 ? halfπ : x < -1 ? -halfπ : Math.asin(x);
+}
+
+function d3_sinh(x) {
+  return ((x = Math.exp(x)) - 1 / x) / 2;
+}
+
+function d3_cosh(x) {
+  return ((x = Math.exp(x)) + 1 / x) / 2;
+}
+
+function d3_tanh(x) {
+  return ((x = Math.exp(2 * x)) - 1) / (x + 1);
+}
+
+function d3_haversin(x) {
+  return (x = Math.sin(x / 2)) * x;
+}

data/node_modules/dc/node_modules/d3/src/scale/bilinear.js

@@ -0,0 +1,7 @@
+function d3_scale_bilinear(domain, range, uninterpolate, interpolate) {
+  var u = uninterpolate(domain[0], domain[1]),
+      i = interpolate(range[0], range[1]);
+  return function(x) {
+    return i(u(x));
+  };
+}

data/node_modules/dc/node_modules/d3/src/scale/category.js

@@ -0,0 +1,58 @@
+import "../color/rgb";
+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 = [
+  0x1f77b4, 0xff7f0e, 0x2ca02c, 0xd62728, 0x9467bd,
+  0x8c564b, 0xe377c2, 0x7f7f7f, 0xbcbd22, 0x17becf
+].map(d3_rgbString);
+
+var d3_category20 = [
+  0x1f77b4, 0xaec7e8,
+  0xff7f0e, 0xffbb78,
+  0x2ca02c, 0x98df8a,
+  0xd62728, 0xff9896,
+  0x9467bd, 0xc5b0d5,
+  0x8c564b, 0xc49c94,
+  0xe377c2, 0xf7b6d2,
+  0x7f7f7f, 0xc7c7c7,
+  0xbcbd22, 0xdbdb8d,
+  0x17becf, 0x9edae5
+].map(d3_rgbString);
+
+var d3_category20b = [
+  0x393b79, 0x5254a3, 0x6b6ecf, 0x9c9ede,
+  0x637939, 0x8ca252, 0xb5cf6b, 0xcedb9c,
+  0x8c6d31, 0xbd9e39, 0xe7ba52, 0xe7cb94,
+  0x843c39, 0xad494a, 0xd6616b, 0xe7969c,
+  0x7b4173, 0xa55194, 0xce6dbd, 0xde9ed6
+].map(d3_rgbString);
+
+var d3_category20c = [
+  0x3182bd, 0x6baed6, 0x9ecae1, 0xc6dbef,
+  0xe6550d, 0xfd8d3c, 0xfdae6b, 0xfdd0a2,
+  0x31a354, 0x74c476, 0xa1d99b, 0xc7e9c0,
+  0x756bb1, 0x9e9ac8, 0xbcbddc, 0xdadaeb,
+  0x636363, 0x969696, 0xbdbdbd, 0xd9d9d9
+].map(d3_rgbString);

data/node_modules/dc/node_modules/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/node_modules/dc/node_modules/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/node_modules/dc/node_modules/d3/src/scale/linear.js

@@ -0,0 +1,160 @@
+import "../arrays/range";
+import "../core/rebind";
+import "../interpolate/interpolate";
+import "../interpolate/round";
+import "../interpolate/uninterpolate";
+import "../format/format";
+import "../math/abs";
+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) {
+  d3_scale_nice(domain, d3_scale_niceStep(d3_scale_linearTickRange(domain, m)[2]));
+  d3_scale_nice(domain, d3_scale_niceStep(d3_scale_linearTickRange(domain, m)[2]));
+  return domain;
+}
+
+function d3_scale_linearTickRange(domain, m) {
+  if (m == null) m = 10;
+
+  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 <= 0.15) step *= 10;
+  else if (err <= 0.35) step *= 5;
+  else if (err <= 0.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 * 0.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 range = d3_scale_linearTickRange(domain, m);
+  if (format) {
+    var match = d3_format_re.exec(format);
+    match.shift();
+    if (match[8] === "s") {
+      var prefix = d3.formatPrefix(Math.max(abs(range[0]), abs(range[1])));
+      if (!match[7]) match[7] = "." + d3_scale_linearPrecision(prefix.scale(range[2]));
+      match[8] = "f";
+      format = d3.format(match.join(""));
+      return function(d) {
+        return format(prefix.scale(d)) + prefix.symbol;
+      };
+    }
+    if (!match[7]) match[7] = "." + d3_scale_linearFormatPrecision(match[8], range);
+    format = match.join("");
+  } else {
+    format = ",." + d3_scale_linearPrecision(range[2]) + "f";
+  }
+  return d3.format(format);
+}
+
+var d3_scale_linearFormatSignificant = {s: 1, g: 1, p: 1, r: 1, e: 1};
+
+// Returns the number of significant digits after the decimal point.
+function d3_scale_linearPrecision(value) {
+  return -Math.floor(Math.log(value) / Math.LN10 + 0.01);
+}
+
+// For some format types, the precision specifies the number of significant
+// digits; for others, it specifies the number of digits after the decimal
+// point. For significant format types, the desired precision equals one plus
+// the difference between the decimal precision of the range’s maximum absolute
+// value and the tick step’s decimal precision. For format "e", the digit before
+// the decimal point counts as one.
+function d3_scale_linearFormatPrecision(type, range) {
+  var p = d3_scale_linearPrecision(range[2]);
+  return type in d3_scale_linearFormatSignificant
+      ? Math.abs(p - d3_scale_linearPrecision(Math.max(abs(range[0]), abs(range[1])))) + +(type !== "e")
+      : p - (type === "%") * 2;
+}