@danielmcsheehy/isopleth 0.0.0-stage → 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/auto.d.ts +61 -0
- package/dist/auto.d.ts.map +1 -0
- package/dist/auto.js +213 -0
- package/dist/auto.js.map +1 -0
- package/dist/backend/index.d.ts +24 -0
- package/dist/backend/index.d.ts.map +1 -0
- package/dist/backend/index.js +42 -0
- package/dist/backend/index.js.map +1 -0
- package/dist/backend/js/index.d.ts +7 -0
- package/dist/backend/js/index.d.ts.map +1 -0
- package/dist/backend/js/index.js +33 -0
- package/dist/backend/js/index.js.map +1 -0
- package/dist/backend/js/insights.d.ts +30 -0
- package/dist/backend/js/insights.d.ts.map +1 -0
- package/dist/backend/js/insights.js +663 -0
- package/dist/backend/js/insights.js.map +1 -0
- package/dist/backend/js/kernels.d.ts +22 -0
- package/dist/backend/js/kernels.d.ts.map +1 -0
- package/dist/backend/js/kernels.js +562 -0
- package/dist/backend/js/kernels.js.map +1 -0
- package/dist/backend/js/stats.d.ts +26 -0
- package/dist/backend/js/stats.d.ts.map +1 -0
- package/dist/backend/js/stats.js +237 -0
- package/dist/backend/js/stats.js.map +1 -0
- package/dist/backend/types.d.ts +139 -0
- package/dist/backend/types.d.ts.map +1 -0
- package/dist/backend/types.js +12 -0
- package/dist/backend/types.js.map +1 -0
- package/dist/backend/wasm-wrap.d.ts +9 -0
- package/dist/backend/wasm-wrap.d.ts.map +1 -0
- package/dist/backend/wasm-wrap.js +52 -0
- package/dist/backend/wasm-wrap.js.map +1 -0
- package/dist/backend/wasm.d.ts +30 -0
- package/dist/backend/wasm.d.ts.map +1 -0
- package/dist/backend/wasm.js +29 -0
- package/dist/backend/wasm.js.map +1 -0
- package/dist/channel.d.ts +41 -0
- package/dist/channel.d.ts.map +1 -0
- package/dist/channel.js +205 -0
- package/dist/channel.js.map +1 -0
- package/dist/chart.d.ts +69 -0
- package/dist/chart.d.ts.map +1 -0
- package/dist/chart.js +68 -0
- package/dist/chart.js.map +1 -0
- package/dist/compile/index.d.ts +21 -0
- package/dist/compile/index.d.ts.map +1 -0
- package/dist/compile/index.js +350 -0
- package/dist/compile/index.js.map +1 -0
- package/dist/compile/palette.d.ts +41 -0
- package/dist/compile/palette.d.ts.map +1 -0
- package/dist/compile/palette.js +102 -0
- package/dist/compile/palette.js.map +1 -0
- package/dist/compile/resolve.d.ts +39 -0
- package/dist/compile/resolve.d.ts.map +1 -0
- package/dist/compile/resolve.js +154 -0
- package/dist/compile/resolve.js.map +1 -0
- package/dist/compile/scales.d.ts +47 -0
- package/dist/compile/scales.d.ts.map +1 -0
- package/dist/compile/scales.js +341 -0
- package/dist/compile/scales.js.map +1 -0
- package/dist/compile/series.d.ts +65 -0
- package/dist/compile/series.d.ts.map +1 -0
- package/dist/compile/series.js +868 -0
- package/dist/compile/series.js.map +1 -0
- package/dist/editor/index.d.ts +46 -0
- package/dist/editor/index.d.ts.map +1 -0
- package/dist/editor/index.js +342 -0
- package/dist/editor/index.js.map +1 -0
- package/dist/index.d.ts +47 -0
- package/dist/index.d.ts.map +1 -0
- package/dist/index.js +41 -0
- package/dist/index.js.map +1 -0
- package/dist/insights/index.d.ts +21 -0
- package/dist/insights/index.d.ts.map +1 -0
- package/dist/insights/index.js +461 -0
- package/dist/insights/index.js.map +1 -0
- package/dist/interval.d.ts +19 -0
- package/dist/interval.d.ts.map +1 -0
- package/dist/interval.js +166 -0
- package/dist/interval.js.map +1 -0
- package/dist/marks.d.ts +62 -0
- package/dist/marks.d.ts.map +1 -0
- package/dist/marks.js +176 -0
- package/dist/marks.js.map +1 -0
- package/dist/render.d.ts +21 -0
- package/dist/render.d.ts.map +1 -0
- package/dist/render.js +99 -0
- package/dist/render.js.map +1 -0
- package/dist/spec.d.ts +56 -0
- package/dist/spec.d.ts.map +1 -0
- package/dist/spec.js +191 -0
- package/dist/spec.js.map +1 -0
- package/dist/theme.d.ts +82 -0
- package/dist/theme.d.ts.map +1 -0
- package/dist/theme.js +136 -0
- package/dist/theme.js.map +1 -0
- package/dist/transforms/basic.d.ts +35 -0
- package/dist/transforms/basic.d.ts.map +1 -0
- package/dist/transforms/basic.js +174 -0
- package/dist/transforms/basic.js.map +1 -0
- package/dist/transforms/group.d.ts +32 -0
- package/dist/transforms/group.d.ts.map +1 -0
- package/dist/transforms/group.js +419 -0
- package/dist/transforms/group.js.map +1 -0
- package/dist/transforms/interval.d.ts +24 -0
- package/dist/transforms/interval.d.ts.map +1 -0
- package/dist/transforms/interval.js +104 -0
- package/dist/transforms/interval.js.map +1 -0
- package/dist/transforms/map.d.ts +48 -0
- package/dist/transforms/map.d.ts.map +1 -0
- package/dist/transforms/map.js +192 -0
- package/dist/transforms/map.js.map +1 -0
- package/dist/transforms/select.d.ts +9 -0
- package/dist/transforms/select.d.ts.map +1 -0
- package/dist/transforms/select.js +50 -0
- package/dist/transforms/select.js.map +1 -0
- package/dist/transforms/stack.d.ts +23 -0
- package/dist/transforms/stack.d.ts.map +1 -0
- package/dist/transforms/stack.js +306 -0
- package/dist/transforms/stack.js.map +1 -0
- package/dist/types.d.ts +369 -0
- package/dist/types.d.ts.map +1 -0
- package/dist/types.js +11 -0
- package/dist/types.js.map +1 -0
- package/package.json +65 -4
- package/README.md +0 -3
|
@@ -0,0 +1,663 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Insight kernels in TypeScript. These mirror `isopleth-core::insights`; the
|
|
3
|
+
* models that need augurs (AutoETS, MSTL, periodogram, BOCPD, DBSCAN) are
|
|
4
|
+
* replaced by deterministic alternatives and reported as such in `method`.
|
|
5
|
+
*/
|
|
6
|
+
import * as S from "./stats.js";
|
|
7
|
+
import { aggregate, impute, parseReducer } from "./kernels.js";
|
|
8
|
+
import { BackendError } from "../types.js";
|
|
9
|
+
const arr = (a) => Array.from(a);
|
|
10
|
+
// ------------------------------------------------------------ decompose ---
|
|
11
|
+
export function centredMovingMedian(y, period) {
|
|
12
|
+
const n = y.length;
|
|
13
|
+
const width = Math.max(1, period % 2 === 0 ? period + 1 : period);
|
|
14
|
+
const half = Math.floor(width / 2);
|
|
15
|
+
const out = new Float64Array(n);
|
|
16
|
+
for (let i = 0; i < n; i++) {
|
|
17
|
+
const lo = Math.max(0, i - half);
|
|
18
|
+
const hi = Math.min(n, i + half + 1);
|
|
19
|
+
const buf = [];
|
|
20
|
+
for (let j = lo; j < hi; j++)
|
|
21
|
+
if (Number.isFinite(y[j]))
|
|
22
|
+
buf.push(y[j]);
|
|
23
|
+
buf.sort((a, b) => a - b);
|
|
24
|
+
out[i] = S.quantileSorted(buf, 0.5);
|
|
25
|
+
}
|
|
26
|
+
return out;
|
|
27
|
+
}
|
|
28
|
+
export function centredMovingAverage(y, period) {
|
|
29
|
+
const n = y.length;
|
|
30
|
+
const half = Math.floor(period / 2);
|
|
31
|
+
const out = new Float64Array(n);
|
|
32
|
+
const slice = (lo, hi) => {
|
|
33
|
+
const b = [];
|
|
34
|
+
for (let j = lo; j < hi; j++)
|
|
35
|
+
b.push(y[j]);
|
|
36
|
+
return b;
|
|
37
|
+
};
|
|
38
|
+
if (period % 2 === 1 || period === 0) {
|
|
39
|
+
for (let i = 0; i < n; i++)
|
|
40
|
+
out[i] = S.mean(slice(Math.max(0, i - half), Math.min(n, i + half + 1)));
|
|
41
|
+
return out;
|
|
42
|
+
}
|
|
43
|
+
for (let i = 0; i < n; i++) {
|
|
44
|
+
const a = S.mean(slice(Math.max(0, i - half), Math.min(n, i + half)));
|
|
45
|
+
const b = S.mean(slice(Math.max(0, i + 1 - half), Math.min(n, i + half + 1)));
|
|
46
|
+
out[i] = (a + b) / 2;
|
|
47
|
+
}
|
|
48
|
+
return out;
|
|
49
|
+
}
|
|
50
|
+
export function decompose(y, period) {
|
|
51
|
+
const n = y.length;
|
|
52
|
+
if (period < 2)
|
|
53
|
+
throw new BackendError("period must be >= 2");
|
|
54
|
+
if (n < 2 * period)
|
|
55
|
+
throw new BackendError(`not enough data: needed ${2 * period}, got ${n}`);
|
|
56
|
+
const filled = impute(y, "linear");
|
|
57
|
+
const trend = centredMovingAverage(centredMovingMedian(filled, period), period);
|
|
58
|
+
const byPhase = Array.from({ length: period }, () => []);
|
|
59
|
+
for (let i = 0; i < n; i++) {
|
|
60
|
+
const v = filled[i] - trend[i];
|
|
61
|
+
if (Number.isFinite(v))
|
|
62
|
+
byPhase[i % period].push(v);
|
|
63
|
+
}
|
|
64
|
+
const phase = byPhase.map((b) => (b.length ? S.median(b) : 0));
|
|
65
|
+
const mp = S.mean(phase);
|
|
66
|
+
for (let i = 0; i < period; i++)
|
|
67
|
+
phase[i] -= mp;
|
|
68
|
+
const seasonal = new Array(n);
|
|
69
|
+
const remainder = new Array(n);
|
|
70
|
+
for (let i = 0; i < n; i++) {
|
|
71
|
+
seasonal[i] = phase[i % period];
|
|
72
|
+
remainder[i] = Number.isFinite(y[i]) ? y[i] - trend[i] - seasonal[i] : NaN;
|
|
73
|
+
}
|
|
74
|
+
return { trend: arr(trend), seasonal, remainder, period };
|
|
75
|
+
}
|
|
76
|
+
// ---------------------------------------------------------- seasonality ---
|
|
77
|
+
export function detrend(y) {
|
|
78
|
+
const x = Float64Array.from({ length: y.length }, (_, i) => i);
|
|
79
|
+
const [slope, intercept] = S.ols(x, y);
|
|
80
|
+
const out = new Float64Array(y.length);
|
|
81
|
+
for (let i = 0; i < y.length; i++)
|
|
82
|
+
out[i] = Number.isFinite(slope) ? y[i] - (slope * i + intercept) : y[i];
|
|
83
|
+
return out;
|
|
84
|
+
}
|
|
85
|
+
export function autocorrelationPeriods(y, minPeriod, maxPeriod, threshold) {
|
|
86
|
+
const n = y.length;
|
|
87
|
+
if (n < 4 || maxPeriod < minPeriod)
|
|
88
|
+
return [];
|
|
89
|
+
const hi = Math.min(maxPeriod, n - 2);
|
|
90
|
+
const acf = [];
|
|
91
|
+
for (let lag = 0; lag <= hi + 1; lag++)
|
|
92
|
+
acf.push(S.autocorrelation(y, lag));
|
|
93
|
+
const cands = [];
|
|
94
|
+
for (let lag = Math.max(2, minPeriod); lag <= hi; lag++) {
|
|
95
|
+
if (acf[lag] > threshold && acf[lag] >= acf[lag - 1] && acf[lag] >= acf[lag + 1])
|
|
96
|
+
cands.push([lag, acf[lag]]);
|
|
97
|
+
}
|
|
98
|
+
cands.sort((a, b) => b[1] - a[1]);
|
|
99
|
+
const out = [];
|
|
100
|
+
for (const [lag] of cands) {
|
|
101
|
+
if (out.some((p) => lag % p === 0 || p % lag === 0))
|
|
102
|
+
continue;
|
|
103
|
+
out.push(lag);
|
|
104
|
+
}
|
|
105
|
+
return out;
|
|
106
|
+
}
|
|
107
|
+
export function seasonality(y, opts = {}) {
|
|
108
|
+
const n = y.length;
|
|
109
|
+
const minPeriod = opts.minPeriod ?? 4;
|
|
110
|
+
const maxPeriod = Math.max(minPeriod, opts.maxPeriod ?? Math.min(Math.floor(n / 3), 512));
|
|
111
|
+
if (n < 3 * Math.max(2, minPeriod))
|
|
112
|
+
return { periods: [], strengths: [], method: "none" };
|
|
113
|
+
const filled = detrend(impute(y, "linear"));
|
|
114
|
+
const minStrength = opts.minStrength ?? 0.3;
|
|
115
|
+
const threshold = opts.method === "autocorrelation" ? (opts.threshold ?? 0.3) : 0.3;
|
|
116
|
+
const periods = autocorrelationPeriods(filled, minPeriod, maxPeriod, threshold);
|
|
117
|
+
let scored = periods.map((p) => [p, S.autocorrelation(filled, p)]).filter(([, s]) => Number.isFinite(s) && s >= minStrength);
|
|
118
|
+
scored = scored.filter(([p, s]) => !scored.some(([q, t]) => q < p && p % q === 0 && t >= s - 0.05));
|
|
119
|
+
scored.sort((a, b) => b[1] - a[1]);
|
|
120
|
+
return { periods: scored.map((s) => s[0]), strengths: scored.map((s) => s[1]), method: "autocorrelation" };
|
|
121
|
+
}
|
|
122
|
+
// -------------------------------------------------------------- anomaly ---
|
|
123
|
+
/** Default rolling window: ~n/10 (or 2 periods), at least 7, at most 201, odd. */
|
|
124
|
+
export function defaultWindow(n, period) {
|
|
125
|
+
const base = period !== undefined && period >= 4 ? Math.max(7, 2 * period) : Math.max(7, Math.floor(n / 10));
|
|
126
|
+
const w = Math.min(base, 201, Math.max(1, n));
|
|
127
|
+
return w % 2 === 0 ? w + 1 : w;
|
|
128
|
+
}
|
|
129
|
+
export function rollingMedianMad(y, k) {
|
|
130
|
+
const n = y.length;
|
|
131
|
+
k = Math.max(1, Math.min(k, Math.max(1, n)));
|
|
132
|
+
const half = Math.floor((k - 1) / 2);
|
|
133
|
+
const global = Math.max(Number.EPSILON, S.mad(y) * S.MAD_TO_SIGMA);
|
|
134
|
+
const centre = new Float64Array(n);
|
|
135
|
+
const scale = new Float64Array(n);
|
|
136
|
+
// Typed-array sorts (no comparator) are several times faster than Array#sort here.
|
|
137
|
+
const buf = new Float64Array(k);
|
|
138
|
+
const dev = new Float64Array(k);
|
|
139
|
+
for (let i = 0; i < n; i++) {
|
|
140
|
+
let lo = Math.max(0, i - half);
|
|
141
|
+
const hi = Math.min(n, lo + k);
|
|
142
|
+
lo = Math.min(lo, Math.max(0, hi - k));
|
|
143
|
+
let m = 0;
|
|
144
|
+
for (let j = lo; j < hi; j++)
|
|
145
|
+
if (Number.isFinite(y[j]))
|
|
146
|
+
buf[m++] = y[j];
|
|
147
|
+
const win = buf.subarray(0, m).sort();
|
|
148
|
+
const med = S.quantileSorted(win, 0.5);
|
|
149
|
+
for (let j = 0; j < m; j++)
|
|
150
|
+
dev[j] = Math.abs(win[j] - med);
|
|
151
|
+
const s = S.quantileSorted(dev.subarray(0, m).sort(), 0.5) * S.MAD_TO_SIGMA;
|
|
152
|
+
centre[i] = med;
|
|
153
|
+
scale[i] = s > 0 && Number.isFinite(s) ? s : global;
|
|
154
|
+
}
|
|
155
|
+
return [centre, scale];
|
|
156
|
+
}
|
|
157
|
+
function finish(scores, lower, upper, threshold, method, period) {
|
|
158
|
+
const flags = scores.map((s) => (Number.isFinite(s) && s > threshold ? 1 : 0));
|
|
159
|
+
const indices = [];
|
|
160
|
+
flags.forEach((f, i) => f && indices.push(i));
|
|
161
|
+
return { scores, flags, lower, upper, indices, threshold, method, period };
|
|
162
|
+
}
|
|
163
|
+
function scoreAgainst(y, centre, scale, threshold, method, period) {
|
|
164
|
+
const n = y.length;
|
|
165
|
+
const scores = new Array(n);
|
|
166
|
+
const lower = new Array(n);
|
|
167
|
+
const upper = new Array(n);
|
|
168
|
+
for (let i = 0; i < n; i++) {
|
|
169
|
+
const s = Number.isFinite(scale[i]) && scale[i] > 0 ? scale[i] : Number.EPSILON;
|
|
170
|
+
lower[i] = centre[i] - threshold * s;
|
|
171
|
+
upper[i] = centre[i] + threshold * s;
|
|
172
|
+
scores[i] = Number.isFinite(y[i]) ? Math.abs(y[i] - centre[i]) / s : NaN;
|
|
173
|
+
}
|
|
174
|
+
return finish(scores, lower, upper, threshold, method, period);
|
|
175
|
+
}
|
|
176
|
+
export function anomalies(y, opts = {}) {
|
|
177
|
+
const n = y.length;
|
|
178
|
+
if (S.count(y) < 3)
|
|
179
|
+
throw new BackendError(`not enough data: needed 3, got ${S.count(y)}`);
|
|
180
|
+
const method = opts.method ?? "mad";
|
|
181
|
+
switch (method) {
|
|
182
|
+
case "auto":
|
|
183
|
+
case "mad": {
|
|
184
|
+
const threshold = S.thresholdFromSensitivity(opts.sensitivity, opts.threshold ?? 3.5);
|
|
185
|
+
const k = opts.window ?? defaultWindow(n, opts.period);
|
|
186
|
+
const [c, s] = rollingMedianMad(y, k);
|
|
187
|
+
return scoreAgainst(y, c, s, threshold, "mad", null);
|
|
188
|
+
}
|
|
189
|
+
case "zscore":
|
|
190
|
+
case "z-score": {
|
|
191
|
+
const threshold = S.thresholdFromSensitivity(opts.sensitivity, opts.threshold ?? 3);
|
|
192
|
+
const m = S.mean(y);
|
|
193
|
+
const sd = S.deviation(y);
|
|
194
|
+
return scoreAgainst(y, new Float64Array(n).fill(m), new Float64Array(n).fill(sd), threshold, "zscore", null);
|
|
195
|
+
}
|
|
196
|
+
case "iqr": {
|
|
197
|
+
const k = opts.sensitivity !== undefined ? 2.25 - 1.5 * Math.min(1, Math.max(0, opts.sensitivity)) : (opts.threshold ?? 1.5);
|
|
198
|
+
const sorted = S.sortedFinite(y);
|
|
199
|
+
const q1 = S.quantileSorted(sorted, 0.25);
|
|
200
|
+
const q3 = S.quantileSorted(sorted, 0.75);
|
|
201
|
+
const iqr = q3 - q1;
|
|
202
|
+
const lo = q1 - k * iqr;
|
|
203
|
+
const hi = q3 + k * iqr;
|
|
204
|
+
const scores = arr(y).map((v) => {
|
|
205
|
+
if (!Number.isFinite(v))
|
|
206
|
+
return NaN;
|
|
207
|
+
if (iqr === 0)
|
|
208
|
+
return v < lo || v > hi ? Infinity : 0;
|
|
209
|
+
return v > q3 ? (v - q3) / iqr : v < q1 ? (q1 - v) / iqr : 0;
|
|
210
|
+
});
|
|
211
|
+
return finish(scores, new Array(n).fill(lo), new Array(n).fill(hi), k, "iqr", null);
|
|
212
|
+
}
|
|
213
|
+
case "seasonal":
|
|
214
|
+
case "stl": {
|
|
215
|
+
const threshold = S.thresholdFromSensitivity(opts.sensitivity, opts.threshold ?? 3.5);
|
|
216
|
+
const period = opts.period ?? seasonality(y).periods[0] ?? 0;
|
|
217
|
+
if (period < 2 || n < 2 * period)
|
|
218
|
+
return anomalies(y, { ...opts, method: "mad" });
|
|
219
|
+
const d = decompose(y, period);
|
|
220
|
+
const k = opts.window ?? defaultWindow(n, period);
|
|
221
|
+
const [rc, rs] = rollingMedianMad(d.remainder, k);
|
|
222
|
+
const centre = new Float64Array(n);
|
|
223
|
+
for (let i = 0; i < n; i++)
|
|
224
|
+
centre[i] = d.trend[i] + d.seasonal[i] + rc[i];
|
|
225
|
+
return scoreAgainst(y, centre, rs, threshold, "seasonal", period);
|
|
226
|
+
}
|
|
227
|
+
case "ewma": {
|
|
228
|
+
const threshold = S.thresholdFromSensitivity(opts.sensitivity, opts.threshold ?? 3);
|
|
229
|
+
const lambda = Math.min(1, Math.max(0.01, opts.lambda ?? 0.3));
|
|
230
|
+
const sigma = Math.max(Number.EPSILON, S.mad(y) * S.MAD_TO_SIGMA);
|
|
231
|
+
const centre = new Float64Array(n);
|
|
232
|
+
const scale = new Float64Array(n);
|
|
233
|
+
let z = S.median(y);
|
|
234
|
+
for (let i = 0; i < n; i++) {
|
|
235
|
+
const t = i + 1;
|
|
236
|
+
const s = Math.max(Number.EPSILON, sigma * Math.sqrt((lambda / (2 - lambda)) * (1 - Math.pow(1 - lambda, 2 * t))));
|
|
237
|
+
centre[i] = z;
|
|
238
|
+
scale[i] = s;
|
|
239
|
+
const v = y[i];
|
|
240
|
+
if (Number.isFinite(v) && Math.abs(v - z) / s <= threshold)
|
|
241
|
+
z = lambda * v + (1 - lambda) * z;
|
|
242
|
+
}
|
|
243
|
+
return scoreAgainst(y, centre, scale, threshold, "ewma", null);
|
|
244
|
+
}
|
|
245
|
+
default:
|
|
246
|
+
throw new BackendError(`unknown anomaly method: ${method}`);
|
|
247
|
+
}
|
|
248
|
+
}
|
|
249
|
+
// ------------------------------------------------------------- forecast ---
|
|
250
|
+
function interval(point, sd, level, growth) {
|
|
251
|
+
if (level === null)
|
|
252
|
+
return [point.map(() => NaN), point.map(() => NaN)];
|
|
253
|
+
const z = S.zForLevel(level);
|
|
254
|
+
return [point.map((p, h) => p - z * sd * Math.sqrt(growth(h + 1))), point.map((p, h) => p + z * sd * Math.sqrt(growth(h + 1)))];
|
|
255
|
+
}
|
|
256
|
+
function residualSd(y, fitted) {
|
|
257
|
+
const r = [];
|
|
258
|
+
for (let i = 0; i < y.length; i++)
|
|
259
|
+
r.push(y[i] - fitted[i]);
|
|
260
|
+
const sd = S.deviation(r);
|
|
261
|
+
return Number.isFinite(sd) && sd > 0 ? sd : Number.EPSILON;
|
|
262
|
+
}
|
|
263
|
+
function resolvePeriod(y, given) {
|
|
264
|
+
if (given !== undefined)
|
|
265
|
+
return given >= 2 && y.length >= 2 * given ? given : null;
|
|
266
|
+
return seasonality(y).periods.find((p) => p >= 2 && y.length >= 3 * p) ?? null;
|
|
267
|
+
}
|
|
268
|
+
function naive(y, horizon, level, drift) {
|
|
269
|
+
const n = y.length;
|
|
270
|
+
const last = y[n - 1];
|
|
271
|
+
const slope = drift && n > 1 ? (last - y[0]) / (n - 1) : 0;
|
|
272
|
+
const fitted = new Array(n).fill(NaN);
|
|
273
|
+
for (let i = 1; i < n; i++)
|
|
274
|
+
fitted[i] = y[i - 1] + slope;
|
|
275
|
+
const sd = residualSd(y, fitted);
|
|
276
|
+
const point = Array.from({ length: horizon }, (_, h) => last + (h + 1) * slope);
|
|
277
|
+
const [lower, upper] = interval(point, sd, level, (h) => (drift ? h * (1 + h / n) : h));
|
|
278
|
+
return { point, lower, upper, fitted, level, method: drift ? "drift" : "naive", period: null };
|
|
279
|
+
}
|
|
280
|
+
function holtPass(y, alpha, beta) {
|
|
281
|
+
const n = y.length;
|
|
282
|
+
let l = y[0];
|
|
283
|
+
let b = n > 1 ? y[1] - y[0] : 0;
|
|
284
|
+
const fitted = new Array(n).fill(NaN);
|
|
285
|
+
let sse = 0;
|
|
286
|
+
for (let i = 1; i < n; i++) {
|
|
287
|
+
const f = l + b;
|
|
288
|
+
fitted[i] = f;
|
|
289
|
+
const e = y[i] - f;
|
|
290
|
+
sse += e * e;
|
|
291
|
+
const lNew = alpha * y[i] + (1 - alpha) * (l + b);
|
|
292
|
+
b = beta * (lNew - l) + (1 - beta) * b;
|
|
293
|
+
l = lNew;
|
|
294
|
+
}
|
|
295
|
+
return [fitted, l, b, sse];
|
|
296
|
+
}
|
|
297
|
+
function holt(y, horizon, level) {
|
|
298
|
+
if (y.length < 3)
|
|
299
|
+
return naive(y, horizon, level, false);
|
|
300
|
+
const grid = [0.05, 0.15, 0.3, 0.5, 0.7, 0.9];
|
|
301
|
+
let best = [Infinity, 0.3, 0.1];
|
|
302
|
+
for (const a of grid)
|
|
303
|
+
for (const b of grid) {
|
|
304
|
+
if (b > a)
|
|
305
|
+
continue;
|
|
306
|
+
const sse = holtPass(y, a, b)[3];
|
|
307
|
+
if (sse < best[0])
|
|
308
|
+
best = [sse, a, b];
|
|
309
|
+
}
|
|
310
|
+
const [, alpha, beta] = best;
|
|
311
|
+
const [fitted, l, b] = holtPass(y, alpha, beta);
|
|
312
|
+
const sd = residualSd(y, fitted);
|
|
313
|
+
const point = Array.from({ length: horizon }, (_, h) => l + (h + 1) * b);
|
|
314
|
+
const [lower, upper] = interval(point, sd, level, (h) => {
|
|
315
|
+
let s = 1;
|
|
316
|
+
for (let j = 1; j < h; j++)
|
|
317
|
+
s += Math.pow(alpha + beta * j, 2);
|
|
318
|
+
return s;
|
|
319
|
+
});
|
|
320
|
+
return { point, lower, upper, fitted, level, method: "holt", period: null };
|
|
321
|
+
}
|
|
322
|
+
function hwPass(y, m, alpha, beta, gamma, s0) {
|
|
323
|
+
const n = y.length;
|
|
324
|
+
const s = s0.slice();
|
|
325
|
+
let l = S.mean(y.subarray(0, m));
|
|
326
|
+
let b = (S.mean(y.subarray(m, Math.min(2 * m, n))) - l) / m;
|
|
327
|
+
const fitted = new Array(n).fill(NaN);
|
|
328
|
+
let sse = 0;
|
|
329
|
+
for (let i = 0; i < n; i++) {
|
|
330
|
+
const si = s[i % m];
|
|
331
|
+
const f = l + b + si;
|
|
332
|
+
if (i >= m) {
|
|
333
|
+
fitted[i] = f;
|
|
334
|
+
const e = y[i] - f;
|
|
335
|
+
sse += e * e;
|
|
336
|
+
}
|
|
337
|
+
const lNew = alpha * (y[i] - si) + (1 - alpha) * (l + b);
|
|
338
|
+
b = beta * (lNew - l) + (1 - beta) * b;
|
|
339
|
+
s[i % m] = gamma * (y[i] - lNew) + (1 - gamma) * si;
|
|
340
|
+
l = lNew;
|
|
341
|
+
}
|
|
342
|
+
return [fitted, l, b, s, sse];
|
|
343
|
+
}
|
|
344
|
+
function holtWinters(y, horizon, level, m) {
|
|
345
|
+
const n = y.length;
|
|
346
|
+
if (n < 2 * m || m < 2)
|
|
347
|
+
throw new BackendError(`not enough data: needed ${2 * m}, got ${n}`);
|
|
348
|
+
const d = decompose(y, m);
|
|
349
|
+
const s0 = d.seasonal.slice(0, m);
|
|
350
|
+
let best = [Infinity, 0.3, 0.05, 0.2];
|
|
351
|
+
for (const a of [0.1, 0.3, 0.5, 0.7])
|
|
352
|
+
for (const b of [0.01, 0.05, 0.2])
|
|
353
|
+
for (const g of [0.05, 0.2, 0.5]) {
|
|
354
|
+
const sse = hwPass(y, m, a, b, g, s0)[4];
|
|
355
|
+
if (sse < best[0])
|
|
356
|
+
best = [sse, a, b, g];
|
|
357
|
+
}
|
|
358
|
+
const [, alpha, beta, gamma] = best;
|
|
359
|
+
const [fitted, l, b, s] = hwPass(y, m, alpha, beta, gamma, s0);
|
|
360
|
+
const sd = residualSd(y, fitted);
|
|
361
|
+
const point = Array.from({ length: horizon }, (_, h) => l + (h + 1) * b + s[(n + h) % m]);
|
|
362
|
+
const [lower, upper] = interval(point, sd, level, (h) => {
|
|
363
|
+
let acc = 1;
|
|
364
|
+
for (let j = 1; j < h; j++)
|
|
365
|
+
acc += Math.pow(alpha + beta * j + (j % m === 0 ? gamma : 0), 2);
|
|
366
|
+
return acc;
|
|
367
|
+
});
|
|
368
|
+
return { point, lower, upper, fitted, level, method: "holt-winters", period: m };
|
|
369
|
+
}
|
|
370
|
+
export function forecast(y, opts = {}) {
|
|
371
|
+
const horizon = opts.horizon ?? 10;
|
|
372
|
+
const level = opts.level === undefined ? 0.95 : opts.level === null || opts.level <= 0 ? null : opts.level;
|
|
373
|
+
if (!(horizon >= 1))
|
|
374
|
+
throw new BackendError("horizon must be >= 1");
|
|
375
|
+
if (level !== null && !(level > 0 && level < 1))
|
|
376
|
+
throw new BackendError("level must be in (0, 1)");
|
|
377
|
+
if (S.count(y) < 2)
|
|
378
|
+
throw new BackendError(`not enough data: needed 2, got ${S.count(y)}`);
|
|
379
|
+
const filled = impute(y, "linear");
|
|
380
|
+
const method = opts.method ?? "auto";
|
|
381
|
+
switch (method) {
|
|
382
|
+
case "naive":
|
|
383
|
+
return naive(filled, horizon, level, false);
|
|
384
|
+
case "drift":
|
|
385
|
+
return naive(filled, horizon, level, true);
|
|
386
|
+
case "holt":
|
|
387
|
+
case "ets":
|
|
388
|
+
return holt(filled, horizon, level);
|
|
389
|
+
case "holt-winters":
|
|
390
|
+
case "hw":
|
|
391
|
+
case "mstl": {
|
|
392
|
+
const p = resolvePeriod(filled, opts.period);
|
|
393
|
+
if (p === null)
|
|
394
|
+
throw new BackendError(`no seasonal period found for ${method}`);
|
|
395
|
+
return holtWinters(filled, horizon, level, p);
|
|
396
|
+
}
|
|
397
|
+
case "auto": {
|
|
398
|
+
if (filled.length < 10)
|
|
399
|
+
return naive(filled, horizon, level, filled.length >= 3);
|
|
400
|
+
const p = resolvePeriod(filled, opts.period);
|
|
401
|
+
if (p !== null && filled.length >= 3 * p) {
|
|
402
|
+
try {
|
|
403
|
+
return holtWinters(filled, horizon, level, p);
|
|
404
|
+
}
|
|
405
|
+
catch {
|
|
406
|
+
/* fall through */
|
|
407
|
+
}
|
|
408
|
+
}
|
|
409
|
+
return holt(filled, horizon, level);
|
|
410
|
+
}
|
|
411
|
+
default:
|
|
412
|
+
throw new BackendError(`unknown forecast method: ${method}`);
|
|
413
|
+
}
|
|
414
|
+
}
|
|
415
|
+
// ---------------------------------------------------------- changepoint ---
|
|
416
|
+
export function binarySegmentation(y, minSegment, maxChangepoints, penalty, model = "linear") {
|
|
417
|
+
const n = y.length;
|
|
418
|
+
const linear = model === "linear";
|
|
419
|
+
const minSeg = Math.max(linear ? 3 : 1, minSegment);
|
|
420
|
+
if (n < 2 * minSeg)
|
|
421
|
+
return [];
|
|
422
|
+
const diffs = [];
|
|
423
|
+
for (let i = 1; i < n; i++)
|
|
424
|
+
diffs.push(y[i] - y[i - 1]);
|
|
425
|
+
const sigma = Math.max(1e-12, (S.mad(diffs) * S.MAD_TO_SIGMA) / Math.SQRT2);
|
|
426
|
+
const pen = Math.max(0, penalty) * 3 * (linear ? 2 : 1) * sigma * sigma * Math.log(n);
|
|
427
|
+
const ps = new Float64Array(n + 1);
|
|
428
|
+
const pss = new Float64Array(n + 1);
|
|
429
|
+
const px = new Float64Array(n + 1);
|
|
430
|
+
const pxx = new Float64Array(n + 1);
|
|
431
|
+
const pxy = new Float64Array(n + 1);
|
|
432
|
+
for (let i = 0; i < n; i++) {
|
|
433
|
+
ps[i + 1] = ps[i] + y[i];
|
|
434
|
+
pss[i + 1] = pss[i] + y[i] * y[i];
|
|
435
|
+
px[i + 1] = px[i] + i;
|
|
436
|
+
pxx[i + 1] = pxx[i] + i * i;
|
|
437
|
+
pxy[i + 1] = pxy[i] + i * y[i];
|
|
438
|
+
}
|
|
439
|
+
const cost = (a, b) => {
|
|
440
|
+
const len = b - a;
|
|
441
|
+
const sy = ps[b] - ps[a];
|
|
442
|
+
const syy = pss[b] - pss[a] - (sy * sy) / len;
|
|
443
|
+
if (!linear)
|
|
444
|
+
return syy;
|
|
445
|
+
const sx = px[b] - px[a];
|
|
446
|
+
const sxx = pxx[b] - pxx[a] - (sx * sx) / len;
|
|
447
|
+
const sxy = pxy[b] - pxy[a] - (sx * sy) / len;
|
|
448
|
+
return sxx <= 0 ? syy : Math.max(0, syy - (sxy * sxy) / sxx);
|
|
449
|
+
};
|
|
450
|
+
const bestSplit = (a, b) => {
|
|
451
|
+
if (b - a < 2 * minSeg)
|
|
452
|
+
return null;
|
|
453
|
+
const base = cost(a, b);
|
|
454
|
+
let best = null;
|
|
455
|
+
for (let k = a + minSeg; k <= b - minSeg; k++) {
|
|
456
|
+
const gain = base - cost(a, k) - cost(k, b);
|
|
457
|
+
if (best === null || gain > best[1])
|
|
458
|
+
best = [k, gain];
|
|
459
|
+
}
|
|
460
|
+
return best;
|
|
461
|
+
};
|
|
462
|
+
const cps = [];
|
|
463
|
+
const segments = [[0, n]];
|
|
464
|
+
while (cps.length < maxChangepoints) {
|
|
465
|
+
let cand = null;
|
|
466
|
+
segments.forEach(([a, b], si) => {
|
|
467
|
+
const s = bestSplit(a, b);
|
|
468
|
+
if (s && s[1] > pen && (cand === null || s[1] > cand[2]))
|
|
469
|
+
cand = [si, s[0], s[1]];
|
|
470
|
+
});
|
|
471
|
+
if (cand === null)
|
|
472
|
+
break;
|
|
473
|
+
const [si, k] = cand;
|
|
474
|
+
const [a, b] = segments[si];
|
|
475
|
+
segments[si] = [a, k];
|
|
476
|
+
segments.push([k, b]);
|
|
477
|
+
cps.push(k);
|
|
478
|
+
}
|
|
479
|
+
return cps.sort((a, b) => a - b);
|
|
480
|
+
}
|
|
481
|
+
export function changepoints(y, opts = {}) {
|
|
482
|
+
const minSegment = opts.minSegment ?? 5;
|
|
483
|
+
if (S.count(y) < 2 * Math.max(1, minSegment))
|
|
484
|
+
throw new BackendError(`not enough data: needed ${2 * minSegment}, got ${S.count(y)}`);
|
|
485
|
+
const method = opts.method ?? "auto";
|
|
486
|
+
if (!["auto", "binseg", "binary-segmentation", "argpcp", "normal-gamma"].includes(method))
|
|
487
|
+
throw new BackendError(`unknown changepoint method: ${method}`);
|
|
488
|
+
const filled = impute(y, "linear");
|
|
489
|
+
const model = opts.model ?? "linear";
|
|
490
|
+
if (model !== "mean" && model !== "linear")
|
|
491
|
+
throw new BackendError(`unknown changepoint model: ${model}`);
|
|
492
|
+
const indices = binarySegmentation(filled, minSegment, opts.maxChangepoints ?? 10, opts.penalty ?? 1, model).filter((i) => i > 0 && i < filled.length);
|
|
493
|
+
const segmentMeans = [];
|
|
494
|
+
let start = 0;
|
|
495
|
+
for (const c of [...indices, filled.length]) {
|
|
496
|
+
segmentMeans.push(S.mean(filled.subarray(start, c)));
|
|
497
|
+
start = c;
|
|
498
|
+
}
|
|
499
|
+
return { indices, segmentMeans, method: "binseg" };
|
|
500
|
+
}
|
|
501
|
+
// ---------------------------------------------------------------- trend ---
|
|
502
|
+
export function trend(x, y, method) {
|
|
503
|
+
if (x.length !== y.length)
|
|
504
|
+
throw new BackendError(`length mismatch: expected ${x.length}, got ${y.length}`);
|
|
505
|
+
let valid = 0;
|
|
506
|
+
for (let i = 0; i < x.length; i++)
|
|
507
|
+
if (Number.isFinite(x[i]) && Number.isFinite(y[i]))
|
|
508
|
+
valid++;
|
|
509
|
+
if (valid < 2)
|
|
510
|
+
throw new BackendError(`not enough data: needed 2, got ${valid}`);
|
|
511
|
+
let slope;
|
|
512
|
+
let intercept;
|
|
513
|
+
let name;
|
|
514
|
+
switch (method) {
|
|
515
|
+
case "ols":
|
|
516
|
+
case "linear":
|
|
517
|
+
case "auto":
|
|
518
|
+
[slope, intercept] = S.ols(x, y);
|
|
519
|
+
name = "ols";
|
|
520
|
+
break;
|
|
521
|
+
case "theil-sen":
|
|
522
|
+
case "theilsen":
|
|
523
|
+
case "robust": {
|
|
524
|
+
const CAP = 2000;
|
|
525
|
+
if (x.length > CAP) {
|
|
526
|
+
const step = x.length / CAP;
|
|
527
|
+
const xs = Float64Array.from({ length: CAP }, (_, i) => x[Math.floor(i * step)]);
|
|
528
|
+
const ys = Float64Array.from({ length: CAP }, (_, i) => y[Math.floor(i * step)]);
|
|
529
|
+
[slope, intercept] = S.theilSen(xs, ys);
|
|
530
|
+
}
|
|
531
|
+
else
|
|
532
|
+
[slope, intercept] = S.theilSen(x, y);
|
|
533
|
+
name = "theil-sen";
|
|
534
|
+
break;
|
|
535
|
+
}
|
|
536
|
+
default:
|
|
537
|
+
throw new BackendError(`unknown trend method: ${method}`);
|
|
538
|
+
}
|
|
539
|
+
const fitted = arr(x).map((xi) => (Number.isFinite(xi) ? slope * xi + intercept : NaN));
|
|
540
|
+
const ybar = S.mean(y);
|
|
541
|
+
let ssRes = 0;
|
|
542
|
+
let ssTot = 0;
|
|
543
|
+
for (let i = 0; i < y.length; i++) {
|
|
544
|
+
if (Number.isFinite(y[i]) && Number.isFinite(fitted[i])) {
|
|
545
|
+
ssRes += (y[i] - fitted[i]) ** 2;
|
|
546
|
+
ssTot += (y[i] - ybar) ** 2;
|
|
547
|
+
}
|
|
548
|
+
}
|
|
549
|
+
return { slope, intercept, fitted, r2: ssTot > 0 ? 1 - ssRes / ssTot : NaN, method: name };
|
|
550
|
+
}
|
|
551
|
+
// ------------------------------------------------------------- outliers ---
|
|
552
|
+
export function robustZ(values) {
|
|
553
|
+
const m = S.median(values);
|
|
554
|
+
let s = S.mad(values) * S.MAD_TO_SIGMA;
|
|
555
|
+
if (!(s > 0)) {
|
|
556
|
+
const dev = [];
|
|
557
|
+
for (let i = 0; i < values.length; i++)
|
|
558
|
+
if (Number.isFinite(values[i]))
|
|
559
|
+
dev.push(Math.abs(values[i] - m));
|
|
560
|
+
s = S.mean(dev) * 1.2533;
|
|
561
|
+
}
|
|
562
|
+
return arr(values).map((v) => (!Number.isFinite(v) ? NaN : s > 0 ? (v - m) / s : 0));
|
|
563
|
+
}
|
|
564
|
+
export function frequencyOutliers(counts, sensitivity, threshold) {
|
|
565
|
+
const t = S.thresholdFromSensitivity(sensitivity, threshold ?? 2.5);
|
|
566
|
+
const logs = arr(counts).map((c) => Math.log(Math.max(0, c) + 1));
|
|
567
|
+
const scores = counts.length >= 3 ? robustZ(logs) : new Array(counts.length).fill(0);
|
|
568
|
+
const rare = [];
|
|
569
|
+
const dominant = [];
|
|
570
|
+
scores.forEach((z, i) => {
|
|
571
|
+
if (z < -t)
|
|
572
|
+
rare.push(i);
|
|
573
|
+
if (z > t)
|
|
574
|
+
dominant.push(i);
|
|
575
|
+
});
|
|
576
|
+
return { scores, rare, dominant, threshold: t };
|
|
577
|
+
}
|
|
578
|
+
export function categoryOutliers(codes, values, nGroups, reducer, sensitivity, threshold) {
|
|
579
|
+
if (codes.length !== values.length)
|
|
580
|
+
throw new BackendError(`length mismatch: expected ${codes.length}, got ${values.length}`);
|
|
581
|
+
const t = S.thresholdFromSensitivity(sensitivity, threshold ?? 3);
|
|
582
|
+
const red = reducer && reducer !== "" ? reducer : "median";
|
|
583
|
+
if (!parseReducer(red))
|
|
584
|
+
throw new BackendError(`unknown reducer: ${red}`);
|
|
585
|
+
const aggregates = arr(aggregate(codes, values, nGroups, red));
|
|
586
|
+
const scores = nGroups >= 3 ? robustZ(aggregates) : new Array(nGroups).fill(0);
|
|
587
|
+
const categories = [];
|
|
588
|
+
scores.forEach((z, i) => Number.isFinite(z) && Math.abs(z) > t && categories.push(i));
|
|
589
|
+
const buckets = Array.from({ length: nGroups }, () => []);
|
|
590
|
+
for (let i = 0; i < codes.length; i++)
|
|
591
|
+
if (codes[i] >= 0 && codes[i] < nGroups)
|
|
592
|
+
buckets[codes[i]].push(values[i]);
|
|
593
|
+
const statsPer = buckets.map((b) => {
|
|
594
|
+
if (S.count(b) < 4)
|
|
595
|
+
return [NaN, NaN];
|
|
596
|
+
const m = S.median(b);
|
|
597
|
+
let s = S.mad(b) * S.MAD_TO_SIGMA;
|
|
598
|
+
if (!(s > 0))
|
|
599
|
+
s = S.mean(b.filter(Number.isFinite).map((v) => Math.abs(v - m))) * 1.2533;
|
|
600
|
+
return [m, s];
|
|
601
|
+
});
|
|
602
|
+
const withinScores = arr(codes).map((c, i) => {
|
|
603
|
+
const v = values[i];
|
|
604
|
+
if (c < 0 || c >= nGroups || !Number.isFinite(v))
|
|
605
|
+
return NaN;
|
|
606
|
+
const [m, s] = statsPer[c];
|
|
607
|
+
if (!Number.isFinite(m))
|
|
608
|
+
return NaN;
|
|
609
|
+
return s > 0 ? Math.abs(v - m) / s : 0;
|
|
610
|
+
});
|
|
611
|
+
const within = [];
|
|
612
|
+
withinScores.forEach((z, i) => Number.isFinite(z) && z > t && within.push(i));
|
|
613
|
+
return { aggregates, scores, categories, withinScores, within, threshold: t };
|
|
614
|
+
}
|
|
615
|
+
/**
|
|
616
|
+
* Cross-series outliers without DBSCAN: at every timestamp, score each series
|
|
617
|
+
* by its robust z against the median of all series; a series is outlying when
|
|
618
|
+
* its mean score exceeds the threshold derived from `sensitivity`.
|
|
619
|
+
*/
|
|
620
|
+
export function seriesOutliers(series, method, sensitivity) {
|
|
621
|
+
if (series.length === 0)
|
|
622
|
+
throw new BackendError("not enough data: needed 1 series");
|
|
623
|
+
const len = series[0].length;
|
|
624
|
+
for (const s of series)
|
|
625
|
+
if (s.length !== len)
|
|
626
|
+
throw new BackendError(`length mismatch: expected ${len}, got ${s.length}`);
|
|
627
|
+
if (!["dbscan", "mad", "auto"].includes(method))
|
|
628
|
+
throw new BackendError(`unknown series outlier method: ${method}`);
|
|
629
|
+
const sens = Math.min(0.99, Math.max(0.01, sensitivity ?? 0.5));
|
|
630
|
+
const t = 6 - 4 * sens; // same mapping as point anomalies
|
|
631
|
+
const scores = series.map(() => new Array(len).fill(0));
|
|
632
|
+
const bandMin = new Array(len).fill(NaN);
|
|
633
|
+
const bandMax = new Array(len).fill(NaN);
|
|
634
|
+
const column = [];
|
|
635
|
+
for (let i = 0; i < len; i++) {
|
|
636
|
+
column.length = 0;
|
|
637
|
+
for (const s of series)
|
|
638
|
+
column.push(s[i]);
|
|
639
|
+
const m = S.median(column);
|
|
640
|
+
let s = S.mad(column) * S.MAD_TO_SIGMA;
|
|
641
|
+
// When most series agree exactly (MAD = 0) any deviation is significant:
|
|
642
|
+
// fall back to half the mean absolute deviation rather than a normal-consistent scale.
|
|
643
|
+
if (!(s > 0))
|
|
644
|
+
s = Math.abs(S.mean(column.filter(Number.isFinite).map((v) => Math.abs(v - m)))) * 0.5;
|
|
645
|
+
if (S.count(column) >= 3) {
|
|
646
|
+
bandMin[i] = m - t * s;
|
|
647
|
+
bandMax[i] = m + t * s;
|
|
648
|
+
}
|
|
649
|
+
for (let k = 0; k < series.length; k++) {
|
|
650
|
+
const v = column[k];
|
|
651
|
+
scores[k][i] = Number.isFinite(v) && s > 0 ? Math.min(1, Math.abs(v - m) / s / t) : 0;
|
|
652
|
+
}
|
|
653
|
+
}
|
|
654
|
+
const outlying = [];
|
|
655
|
+
scores.forEach((sc, k) => {
|
|
656
|
+
// Outlying when it sits beyond the threshold for at least 10% of the timestamps.
|
|
657
|
+
const beyond = sc.filter((v) => v >= 1).length / Math.max(1, sc.length);
|
|
658
|
+
if (series.length >= 3 && beyond >= 0.1)
|
|
659
|
+
outlying.push(k);
|
|
660
|
+
});
|
|
661
|
+
return { outlying, scores, bandMin, bandMax, method: "mad" };
|
|
662
|
+
}
|
|
663
|
+
//# sourceMappingURL=insights.js.map
|