RubyGems - stripchart - Versions diffs - 0.0.3 - Mend

stripchart 0.0.3

Files changed (504) hide show

data/lib/stripchart/public/components/d3/lib/science/science.stats.min.js ADDED

@@ -0,0 +1 @@

data/lib/stripchart/public/components/d3/package.json ADDED

@@ -0,0 +1,53 @@
+{
+  "name": "d3",
+  "version": "3.2.6",
+  "description": "A small, free JavaScript library for manipulating documents based on data.",
+  "keywords": [
+    "dom",
+    "w3c",
+    "visualization",
+    "svg",
+    "animation",
+    "canvas"
+  ],
+  "homepage": "http://d3js.org",
+  "author": {
+    "name": "Mike Bostock",
+    "url": "http://bost.ocks.org/mike"
+  },
+  "contributors": [
+    {
+      "name": "Jason Davies",
+      "url": "http://jasondavies.com"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mbostock/d3.git"
+  },
+  "main": "index.js",
+  "browserify": "index-browserify.js",
+  "jam": {
+    "main": "d3.js",
+    "shim": {
+      "exports": "d3"
+    }
+  },
+  "dependencies": {
+    "jsdom": "~0.5.3"
+  },
+  "devDependencies": {
+    "smash": "~0.0.8",
+    "uglify-js": "2.3.6",
+    "vows": "0.7.x"
+  },
+  "scripts": {
+    "test": "node_modules/.bin/vows"
+  },
+  "licenses": [
+    {
+      "type": "BSD",
+      "url": "https://github.com/mbostock/d3/blob/master/LICENSE"
+    }
+  ]
+}

data/lib/stripchart/public/components/d3/src/arrays/ascending.js ADDED

@@ -0,0 +1,3 @@
+d3.ascending = function(a, b) {
+  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+};

data/lib/stripchart/public/components/d3/src/arrays/bisect.js ADDED

@@ -0,0 +1,28 @@
+d3.bisector = function(f) {
+  return {
+    left: function(a, x, lo, hi) {
+      if (arguments.length < 3) lo = 0;
+      if (arguments.length < 4) hi = a.length;
+      while (lo < hi) {
+        var mid = lo + hi >>> 1;
+        if (f.call(a, a[mid], mid) < x) lo = mid + 1;
+        else hi = mid;
+      }
+      return lo;
+    },
+    right: function(a, x, lo, hi) {
+      if (arguments.length < 3) lo = 0;
+      if (arguments.length < 4) hi = a.length;
+      while (lo < hi) {
+        var mid = lo + hi >>> 1;
+        if (x < f.call(a, a[mid], mid)) hi = mid;
+        else lo = mid + 1;
+      }
+      return lo;
+    }
+  };
+};
+var d3_bisector = d3.bisector(function(d) { return d; });
+d3.bisectLeft = d3_bisector.left;
+d3.bisect = d3.bisectRight = d3_bisector.right;

data/lib/stripchart/public/components/d3/src/arrays/descending.js ADDED

@@ -0,0 +1,3 @@
+d3.descending = function(a, b) {
+  return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+};

data/lib/stripchart/public/components/d3/src/arrays/entries.js ADDED

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

data/lib/stripchart/public/components/d3/src/arrays/extent.js ADDED

@@ -0,0 +1,21 @@
+d3.extent = function(array, f) {
+  var i = -1,
+      n = array.length,
+      a,
+      b,
+      c;
+  if (arguments.length === 1) {
+    while (++i < n && !((a = c = array[i]) != null && a <= a)) a = c = undefined;
+    while (++i < n) if ((b = array[i]) != null) {
+      if (a > b) a = b;
+      if (c < b) c = b;
+    }
+  } else {
+    while (++i < n && !((a = c = f.call(array, array[i], i)) != null && a <= a)) a = undefined;
+    while (++i < n) if ((b = f.call(array, array[i], i)) != null) {
+      if (a > b) a = b;
+      if (c < b) c = b;
+    }
+  }
+  return [a, c];
+};

data/lib/stripchart/public/components/d3/src/arrays/index.js ADDED

@@ -0,0 +1,22 @@
+import "ascending";
+import "descending";
+import "min";
+import "max";
+import "extent";
+import "sum";
+import "mean";
+import "median";
+import "quantile";
+import "bisect";
+import "shuffle";
+import "permute";
+import "zip";
+import "transpose";
+import "keys";
+import "values";
+import "entries";
+import "merge";
+import "range";
+import "nest";
+import "map";
+import "set";

data/lib/stripchart/public/components/d3/src/arrays/keys.js ADDED

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

data/lib/stripchart/public/components/d3/src/arrays/map.js ADDED

@@ -0,0 +1,50 @@
+import "../core/class";
+d3.map = function(object) {
+  var map = new d3_Map;
+  for (var key in object) map.set(key, object[key]);
+  return map;
+};
+function d3_Map() {}
+d3_class(d3_Map, {
+  has: function(key) {
+    return d3_map_prefix + key in this;
+  },
+  get: function(key) {
+    return this[d3_map_prefix + key];
+  },
+  set: function(key, value) {
+    return this[d3_map_prefix + key] = value;
+  },
+  remove: function(key) {
+    key = d3_map_prefix + key;
+    return key in this && delete this[key];
+  },
+  keys: function() {
+    var keys = [];
+    this.forEach(function(key) { keys.push(key); });
+    return keys;
+  },
+  values: function() {
+    var values = [];
+    this.forEach(function(key, value) { values.push(value); });
+    return values;
+  },
+  entries: function() {
+    var entries = [];
+    this.forEach(function(key, value) { entries.push({key: key, value: value}); });
+    return entries;
+  },
+  forEach: function(f) {
+    for (var key in this) {
+      if (key.charCodeAt(0) === d3_map_prefixCode) {
+        f.call(this, key.substring(1), this[key]);
+      }
+    }
+  }
+});
+var d3_map_prefix = "\0", // prevent collision with built-ins
+    d3_map_prefixCode = d3_map_prefix.charCodeAt(0);

data/lib/stripchart/public/components/d3/src/arrays/max.js ADDED

@@ -0,0 +1,14 @@
+d3.max = function(array, f) {
+  var i = -1,
+      n = array.length,
+      a,
+      b;
+  if (arguments.length === 1) {
+    while (++i < n && !((a = array[i]) != null && a <= a)) a = undefined;
+    while (++i < n) if ((b = array[i]) != null && b > a) a = b;
+  } else {
+    while (++i < n && !((a = f.call(array, array[i], i)) != null && a <= a)) a = undefined;
+    while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;
+  }
+  return a;
+};

data/lib/stripchart/public/components/d3/src/arrays/mean.js ADDED

@@ -0,0 +1,15 @@
+import "../math/number";
+d3.mean = function(array, f) {
+  var n = array.length,
+      a,
+      m = 0,
+      i = -1,
+      j = 0;
+  if (arguments.length === 1) {
+    while (++i < n) if (d3_number(a = array[i])) m += (a - m) / ++j;
+  } else {
+    while (++i < n) if (d3_number(a = f.call(array, array[i], i))) m += (a - m) / ++j;
+  }
+  return j ? m : undefined;
+};

data/lib/stripchart/public/components/d3/src/arrays/median.js ADDED

@@ -0,0 +1,9 @@
+import "../math/number";
+import "ascending";
+import "quantile";
+d3.median = function(array, f) {
+  if (arguments.length > 1) array = array.map(f);
+  array = array.filter(d3_number);
+  return array.length ? d3.quantile(array.sort(d3.ascending), .5) : undefined;
+};

data/lib/stripchart/public/components/d3/src/arrays/merge.js ADDED

@@ -0,0 +1,3 @@
+d3.merge = function(arrays) {
+  return Array.prototype.concat.apply([], arrays);
+};

data/lib/stripchart/public/components/d3/src/arrays/min.js ADDED

@@ -0,0 +1,14 @@
+d3.min = function(array, f) {
+  var i = -1,
+      n = array.length,
+      a,
+      b;
+  if (arguments.length === 1) {
+    while (++i < n && !((a = array[i]) != null && a <= a)) a = undefined;
+    while (++i < n) if ((b = array[i]) != null && a > b) a = b;
+  } else {
+    while (++i < n && !((a = f.call(array, array[i], i)) != null && a <= a)) a = undefined;
+    while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;
+  }
+  return a;
+};

data/lib/stripchart/public/components/d3/src/arrays/nest.js ADDED

@@ -0,0 +1,97 @@
+import "map";
+d3.nest = function() {
+  var nest = {},
+      keys = [],
+      sortKeys = [],
+      sortValues,
+      rollup;
+  function map(mapType, array, depth) {
+    if (depth >= keys.length) return rollup
+        ? rollup.call(nest, array) : (sortValues
+        ? array.sort(sortValues)
+        : array);
+    var i = -1,
+        n = array.length,
+        key = keys[depth++],
+        keyValue,
+        object,
+        setter,
+        valuesByKey = new d3_Map,
+        values;
+    while (++i < n) {
+      if (values = valuesByKey.get(keyValue = key(object = array[i]))) {
+        values.push(object);
+      } else {
+        valuesByKey.set(keyValue, [object]);
+      }
+    }
+    if (mapType) {
+      object = mapType();
+      setter = function(keyValue, values) {
+        object.set(keyValue, map(mapType, values, depth));
+      };
+    } else {
+      object = {};
+      setter = function(keyValue, values) {
+        object[keyValue] = map(mapType, values, depth);
+      };
+    }
+    valuesByKey.forEach(setter);
+    return object;
+  }
+  function entries(map, depth) {
+    if (depth >= keys.length) return map;
+    var array = [],
+        sortKey = sortKeys[depth++];
+    map.forEach(function(key, keyMap) {
+      array.push({key: key, values: entries(keyMap, depth)});
+    });
+    return sortKey
+        ? array.sort(function(a, b) { return sortKey(a.key, b.key); })
+        : array;
+  }
+  nest.map = function(array, mapType) {
+    return map(mapType, array, 0);
+  };
+  nest.entries = function(array) {
+    return entries(map(d3.map, array, 0), 0);
+  };
+  nest.key = function(d) {
+    keys.push(d);
+    return nest;
+  };
+  // Specifies the order for the most-recently specified key.
+  // Note: only applies to entries. Map keys are unordered!
+  nest.sortKeys = function(order) {
+    sortKeys[keys.length - 1] = order;
+    return nest;
+  };
+  // Specifies the order for leaf values.
+  // Applies to both maps and entries array.
+  nest.sortValues = function(order) {
+    sortValues = order;
+    return nest;
+  };
+  nest.rollup = function(f) {
+    rollup = f;
+    return nest;
+  };
+  return nest;
+};

data/lib/stripchart/public/components/d3/src/arrays/permute.js ADDED

@@ -0,0 +1,7 @@
+d3.permute = function(array, indexes) {
+  var permutes = [],
+      i = -1,
+      n = indexes.length;
+  while (++i < n) permutes[i] = array[indexes[i]];
+  return permutes;
+};

data/lib/stripchart/public/components/d3/src/arrays/quantile.js ADDED

@@ -0,0 +1,8 @@
+// R-7 per <http://en.wikipedia.org/wiki/Quantile>
+d3.quantile = function(values, p) {
+  var H = (values.length - 1) * p + 1,
+      h = Math.floor(H),
+      v = +values[h - 1],
+      e = H - h;
+  return e ? v + e * (values[h] - v) : v;
+};

data/lib/stripchart/public/components/d3/src/arrays/range.js ADDED

@@ -0,0 +1,24 @@
+d3.range = function(start, stop, step) {
+  if (arguments.length < 3) {
+    step = 1;
+    if (arguments.length < 2) {
+      stop = start;
+      start = 0;
+    }
+  }
+  if ((stop - start) / step === Infinity) throw new Error("infinite range");
+  var range = [],
+       k = d3_range_integerScale(Math.abs(step)),
+       i = -1,
+       j;
+  start *= k, stop *= k, step *= k;
+  if (step < 0) while ((j = start + step * ++i) > stop) range.push(j / k);
+  else while ((j = start + step * ++i) < stop) range.push(j / k);
+  return range;
+};
+function d3_range_integerScale(x) {
+  var k = 1;
+  while (x * k % 1) k *= 10;
+  return k;
+}

data/lib/stripchart/public/components/d3/src/arrays/set.js ADDED

@@ -0,0 +1,38 @@
+import "../core/class";
+import "map";
+d3.set = function(array) {
+  var set = new d3_Set();
+  if (array) for (var i = 0; i < array.length; i++) set.add(array[i]);
+  return set;
+};
+function d3_Set() {}
+d3_class(d3_Set, {
+  has: function(value) {
+    return d3_map_prefix + value in this;
+  },
+  add: function(value) {
+    this[d3_map_prefix + value] = true;
+    return value;
+  },
+  remove: function(value) {
+    value = d3_map_prefix + value;
+    return value in this && delete this[value];
+  },
+  values: function() {
+    var values = [];
+    this.forEach(function(value) {
+      values.push(value);
+    });
+    return values;
+  },
+  forEach: function(f) {
+    for (var value in this) {
+      if (value.charCodeAt(0) === d3_map_prefixCode) {
+        f.call(this, value.substring(1));
+      }
+    }
+  }
+});