StackGenVis: Alignment of Data, Algorithms, and Models for Stacking Ensemble Learning Using Performance Metrics
https://doi.org/10.1109/TVCG.2020.3030352
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
797 lines
19 KiB
797 lines
19 KiB
4 years ago
|
// 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 });
|
||
|
|
||
|
}));
|