// https://d3js.org/d3-array/ v2.4.0 Copyright 2019 Mike Bostock (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'], factory) : (global = global || self, factory(global.d3 = global.d3 || {})); }(this, function (exports) { 'use strict'; function ascending(a, b) { return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; } function bisector(compare) { if (compare.length === 1) compare = ascendingComparator(compare); return { left: function(a, x, lo, hi) { if (lo == null) lo = 0; if (hi == null) hi = a.length; while (lo < hi) { var mid = lo + hi >>> 1; if (compare(a[mid], x) < 0) lo = mid + 1; else hi = mid; } return lo; }, right: function(a, x, lo, hi) { if (lo == null) lo = 0; if (hi == null) hi = a.length; while (lo < hi) { var mid = lo + hi >>> 1; if (compare(a[mid], x) > 0) hi = mid; else lo = mid + 1; } return lo; } }; } function ascendingComparator(f) { return function(d, x) { return ascending(f(d), x); }; } var ascendingBisect = bisector(ascending); var bisectRight = ascendingBisect.right; var bisectLeft = ascendingBisect.left; function count(values, valueof) { let count = 0; if (valueof === undefined) { for (let value of values) { if (value != null && (value = +value) >= value) { ++count; } } } else { let index = -1; for (let value of values) { if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) { ++count; } } } return count; } function length(array) { return array.length | 0; } function empty(length) { return !(length > 0); } function arrayify(values) { return typeof values !== "object" || "length" in values ? values : Array.from(values); } function reducer(reduce) { return values => reduce(...values); } function cross(...values) { const reduce = typeof values[values.length - 1] === "function" && reducer(values.pop()); values = values.map(arrayify); const lengths = values.map(length); const j = values.length - 1; const index = new Array(j + 1).fill(0); const product = []; if (j < 0 || lengths.some(empty)) return product; while (true) { product.push(index.map((j, i) => values[i][j])); let i = j; while (++index[i] === lengths[i]) { if (i === 0) return reduce ? product.map(reduce) : product; index[i--] = 0; } } } function cumsum(values, valueof) { var sum = 0, index = 0; return Float64Array.from(values, valueof === undefined ? v => (sum += +v || 0) : v => (sum += +valueof(v, index++, values) || 0)); } function descending(a, b) { return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; } function variance(values, valueof) { let count = 0; let delta; let mean = 0; let sum = 0; if (valueof === undefined) { for (let value of values) { if (value != null && (value = +value) >= value) { delta = value - mean; mean += delta / ++count; sum += delta * (value - mean); } } } else { let index = -1; for (let value of values) { if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) { delta = value - mean; mean += delta / ++count; sum += delta * (value - mean); } } } if (count > 1) return sum / (count - 1); } function deviation(values, valueof) { const v = variance(values, valueof); return v ? Math.sqrt(v) : v; } function extent(values, valueof) { let min; let max; if (valueof === undefined) { for (const value of values) { if (value != null) { if (min === undefined) { if (value >= value) min = max = value; } else { if (min > value) min = value; if (max < value) max = value; } } } } else { let index = -1; for (let value of values) { if ((value = valueof(value, ++index, values)) != null) { if (min === undefined) { if (value >= value) min = max = value; } else { if (min > value) min = value; if (max < value) max = value; } } } } return [min, max]; } function identity(x) { return x; } function group(values, ...keys) { return nest(values, identity, identity, keys); } function groups(values, ...keys) { return nest(values, Array.from, identity, keys); } function rollup(values, reduce, ...keys) { return nest(values, identity, reduce, keys); } function rollups(values, reduce, ...keys) { return nest(values, Array.from, reduce, keys); } function nest(values, map, reduce, keys) { return (function regroup(values, i) { if (i >= keys.length) return reduce(values); const groups = new Map(); const keyof = keys[i++]; let index = -1; for (const value of values) { const key = keyof(value, ++index, values); const group = groups.get(key); if (group) group.push(value); else groups.set(key, [value]); } for (const [key, values] of groups) { groups.set(key, regroup(values, i)); } return map(groups); })(values, 0); } var array = Array.prototype; var slice = array.slice; function constant(x) { return function() { return x; }; } function range(start, stop, step) { start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step; var i = -1, n = Math.max(0, Math.ceil((stop - start) / step)) | 0, range = new Array(n); while (++i < n) { range[i] = start + i * step; } return range; } var e10 = Math.sqrt(50), e5 = Math.sqrt(10), e2 = Math.sqrt(2); function ticks(start, stop, count) { var reverse, i = -1, n, ticks, step; stop = +stop, start = +start, count = +count; if (start === stop && count > 0) return [start]; if (reverse = stop < start) n = start, start = stop, stop = n; if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return []; if (step > 0) { start = Math.ceil(start / step); stop = Math.floor(stop / step); ticks = new Array(n = Math.ceil(stop - start + 1)); while (++i < n) ticks[i] = (start + i) * step; } else { start = Math.floor(start * step); stop = Math.ceil(stop * step); ticks = new Array(n = Math.ceil(start - stop + 1)); while (++i < n) ticks[i] = (start - i) / step; } if (reverse) ticks.reverse(); return ticks; } function tickIncrement(start, stop, count) { var step = (stop - start) / Math.max(0, count), power = Math.floor(Math.log(step) / Math.LN10), error = step / Math.pow(10, power); return power >= 0 ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power) : -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1); } function tickStep(start, stop, count) { var step0 = Math.abs(stop - start) / Math.max(0, count), step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)), error = step0 / step1; if (error >= e10) step1 *= 10; else if (error >= e5) step1 *= 5; else if (error >= e2) step1 *= 2; return stop < start ? -step1 : step1; } function sturges(values) { return Math.ceil(Math.log(count(values)) / Math.LN2) + 1; } function bin() { var value = identity, domain = extent, threshold = sturges; function histogram(data) { if (!Array.isArray(data)) data = Array.from(data); var i, n = data.length, x, values = new Array(n); for (i = 0; i < n; ++i) { values[i] = value(data[i], i, data); } var xz = domain(values), x0 = xz[0], x1 = xz[1], tz = threshold(values, x0, x1); // Convert number of thresholds into uniform thresholds. if (!Array.isArray(tz)) { tz = tickStep(x0, x1, tz); tz = range(Math.ceil(x0 / tz) * tz, x1, tz); // exclusive } // Remove any thresholds outside the domain. var m = tz.length; while (tz[0] <= x0) tz.shift(), --m; while (tz[m - 1] > x1) tz.pop(), --m; var bins = new Array(m + 1), bin; // Initialize bins. for (i = 0; i <= m; ++i) { bin = bins[i] = []; bin.x0 = i > 0 ? tz[i - 1] : x0; bin.x1 = i < m ? tz[i] : x1; } // Assign data to bins by value, ignoring any outside the domain. for (i = 0; i < n; ++i) { x = values[i]; if (x0 <= x && x <= x1) { bins[bisectRight(tz, x, 0, m)].push(data[i]); } } return bins; } histogram.value = function(_) { return arguments.length ? (value = typeof _ === "function" ? _ : constant(_), histogram) : value; }; histogram.domain = function(_) { return arguments.length ? (domain = typeof _ === "function" ? _ : constant([_[0], _[1]]), histogram) : domain; }; histogram.thresholds = function(_) { return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold; }; return histogram; } function max(values, valueof) { let max; if (valueof === undefined) { for (const value of values) { if (value != null && (max < value || (max === undefined && value >= value))) { max = value; } } } else { let index = -1; for (let value of values) { if ((value = valueof(value, ++index, values)) != null && (max < value || (max === undefined && value >= value))) { max = value; } } } return max; } function min(values, valueof) { let min; if (valueof === undefined) { for (const value of values) { if (value != null && (min > value || (min === undefined && value >= value))) { min = value; } } } else { let index = -1; for (let value of values) { if ((value = valueof(value, ++index, values)) != null && (min > value || (min === undefined && value >= value))) { min = value; } } } return min; } // Based on https://github.com/mourner/quickselect // ISC license, Copyright 2018 Vladimir Agafonkin. function quickselect(array, k, left = 0, right = array.length - 1, compare = ascending) { while (right > left) { if (right - left > 600) { const n = right - left + 1; const m = k - left + 1; const z = Math.log(n); const s = 0.5 * Math.exp(2 * z / 3); const sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1); const newLeft = Math.max(left, Math.floor(k - m * s / n + sd)); const newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd)); quickselect(array, k, newLeft, newRight, compare); } const t = array[k]; let i = left; let j = right; swap(array, left, k); if (compare(array[right], t) > 0) swap(array, left, right); while (i < j) { swap(array, i, j), ++i, --j; while (compare(array[i], t) < 0) ++i; while (compare(array[j], t) > 0) --j; } if (compare(array[left], t) === 0) swap(array, left, j); else ++j, swap(array, j, right); if (j <= k) left = j + 1; if (k <= j) right = j - 1; } return array; } function swap(array, i, j) { const t = array[i]; array[i] = array[j]; array[j] = t; } function number(x) { return x === null ? NaN : +x; } function* numbers(values, valueof) { if (valueof === undefined) { for (let value of values) { if (value != null && (value = +value) >= value) { yield value; } } } else { let index = -1; for (let value of values) { if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) { yield value; } } } } function quantile(values, p, valueof) { values = Float64Array.from(numbers(values, valueof)); if (!(n = values.length)) return; if ((p = +p) <= 0 || n < 2) return min(values); if (p >= 1) return max(values); var n, i = (n - 1) * p, i0 = Math.floor(i), value0 = max(quickselect(values, i0).subarray(0, i0 + 1)), value1 = min(values.subarray(i0 + 1)); return value0 + (value1 - value0) * (i - i0); } function quantileSorted(values, p, valueof = number) { if (!(n = values.length)) return; if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values); if (p >= 1) return +valueof(values[n - 1], n - 1, values); var n, i = (n - 1) * p, i0 = Math.floor(i), value0 = +valueof(values[i0], i0, values), value1 = +valueof(values[i0 + 1], i0 + 1, values); return value0 + (value1 - value0) * (i - i0); } function freedmanDiaconis(values, min, max) { return Math.ceil((max - min) / (2 * (quantile(values, 0.75) - quantile(values, 0.25)) * Math.pow(count(values), -1 / 3))); } function scott(values, min, max) { return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(count(values), -1 / 3))); } function maxIndex(values, valueof) { let max; let maxIndex = -1; let index = -1; if (valueof === undefined) { for (const value of values) { ++index; if (value != null && (max < value || (max === undefined && value >= value))) { max = value, maxIndex = index; } } } else { for (let value of values) { if ((value = valueof(value, ++index, values)) != null && (max < value || (max === undefined && value >= value))) { max = value, maxIndex = index; } } } return maxIndex; } function mean(values, valueof) { let count = 0; let sum = 0; if (valueof === undefined) { for (let value of values) { if (value != null && (value = +value) >= value) { ++count, sum += value; } } } else { let index = -1; for (let value of values) { if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) { ++count, sum += value; } } } if (count) return sum / count; } function median(values, valueof) { return quantile(values, 0.5, valueof); } function* flatten(arrays) { for (const array of arrays) { yield* array; } } function merge(arrays) { return Array.from(flatten(arrays)); } function minIndex(values, valueof) { let min; let minIndex = -1; let index = -1; if (valueof === undefined) { for (const value of values) { ++index; if (value != null && (min > value || (min === undefined && value >= value))) { min = value, minIndex = index; } } } else { for (let value of values) { if ((value = valueof(value, ++index, values)) != null && (min > value || (min === undefined && value >= value))) { min = value, minIndex = index; } } } return minIndex; } function pairs(values, pairof = pair) { const pairs = []; let previous; let first = false; for (const value of values) { if (first) pairs.push(pairof(previous, value)); previous = value; first = true; } return pairs; } function pair(a, b) { return [a, b]; } function permute(source, keys) { return Array.from(keys, key => source[key]); } function least(values, compare = ascending) { let min; let defined = false; if (compare.length === 1) { let minValue; for (const element of values) { const value = compare(element); if (defined ? ascending(value, minValue) < 0 : ascending(value, value) === 0) { min = element; minValue = value; defined = true; } } } else { for (const value of values) { if (defined ? compare(value, min) < 0 : compare(value, value) === 0) { min = value; defined = true; } } } return min; } function leastIndex(values, compare = ascending) { if (compare.length === 1) return minIndex(values, compare); let minValue; let min = -1; let index = -1; for (const value of values) { ++index; if (min < 0 ? compare(value, value) === 0 : compare(value, minValue) < 0) { minValue = value; min = index; } } return min; } function greatest(values, compare = ascending) { let max; let defined = false; if (compare.length === 1) { let maxValue; for (const element of values) { const value = compare(element); if (defined ? ascending(value, maxValue) > 0 : ascending(value, value) === 0) { max = element; maxValue = value; defined = true; } } } else { for (const value of values) { if (defined ? compare(value, max) > 0 : compare(value, value) === 0) { max = value; defined = true; } } } return max; } function greatestIndex(values, compare = ascending) { if (compare.length === 1) return maxIndex(values, compare); let maxValue; let max = -1; let index = -1; for (const value of values) { ++index; if (max < 0 ? compare(value, value) === 0 : compare(value, maxValue) > 0) { maxValue = value; max = index; } } return max; } function scan(values, compare) { const index = leastIndex(values, compare); return index < 0 ? undefined : index; } function shuffle(array, i0 = 0, i1 = array.length) { var m = i1 - (i0 = +i0), t, i; while (m) { i = Math.random() * m-- | 0; t = array[m + i0]; array[m + i0] = array[i + i0]; array[i + i0] = t; } return array; } function sum(values, valueof) { let sum = 0; if (valueof === undefined) { for (let value of values) { if (value = +value) { sum += value; } } } else { let index = -1; for (let value of values) { if (value = +valueof(value, ++index, values)) { sum += value; } } } return sum; } function transpose(matrix) { if (!(n = matrix.length)) return []; for (var i = -1, m = min(matrix, length$1), transpose = new Array(m); ++i < m;) { for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) { row[j] = matrix[j][i]; } } return transpose; } function length$1(d) { return d.length; } function zip() { return transpose(arguments); } exports.ascending = ascending; exports.bin = bin; exports.bisect = bisectRight; exports.bisectLeft = bisectLeft; exports.bisectRight = bisectRight; exports.bisector = bisector; exports.count = count; exports.cross = cross; exports.cumsum = cumsum; exports.descending = descending; exports.deviation = deviation; exports.extent = extent; exports.greatest = greatest; exports.greatestIndex = greatestIndex; exports.group = group; exports.groups = groups; exports.histogram = bin; exports.least = least; exports.leastIndex = leastIndex; exports.max = max; exports.maxIndex = maxIndex; exports.mean = mean; exports.median = median; exports.merge = merge; exports.min = min; exports.minIndex = minIndex; exports.pairs = pairs; exports.permute = permute; exports.quantile = quantile; exports.quantileSorted = quantileSorted; exports.quickselect = quickselect; exports.range = range; exports.rollup = rollup; exports.rollups = rollups; exports.scan = scan; exports.shuffle = shuffle; exports.sum = sum; exports.thresholdFreedmanDiaconis = freedmanDiaconis; exports.thresholdScott = scott; exports.thresholdSturges = sturges; exports.tickIncrement = tickIncrement; exports.tickStep = tickStep; exports.ticks = ticks; exports.transpose = transpose; exports.variance = variance; exports.zip = zip; Object.defineProperty(exports, '__esModule', { value: true }); }));