@formant/ava 3.4.1-formant

package/lib/data/statistics/IQR.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IQR = void 0;
+var compare_1 = require("../../insight/algorithms/base/compare");
+function getQuartilePercentValue(array, percent) {
+    var product = percent * array.length;
+    var ceil = Math.ceil(product);
+    if (ceil === product) {
+        if (ceil === 0) {
+            return array[0];
+        }
+        if (ceil === array.length) {
+            return array[array.length - 1];
+        }
+        return (array[ceil - 1] + array[ceil]) / 2;
+    }
+    return array[ceil - 1];
+}
+/**
+ *
+ * @param data
+ * @param params
+ * @returns
+ */
+function IQR(data, params) {
+    var k = (params === null || params === void 0 ? void 0 : params.k) || 1.5;
+    var sorted = data.slice().sort(compare_1.ascending);
+    var q25 = getQuartilePercentValue(sorted, 0.25);
+    var q75 = getQuartilePercentValue(sorted, 0.75);
+    var iqr = q75 - q25;
+    var outliers = {
+        upper: {
+            threshold: 0,
+            indexes: [],
+        },
+        lower: {
+            threshold: 0,
+            indexes: [],
+        },
+    };
+    outliers.lower.threshold = q25 - k * iqr;
+    outliers.upper.threshold = q75 + k * iqr;
+    data.forEach(function (item, index) {
+        if (item <= outliers.lower.threshold) {
+            outliers.lower.indexes.push(index);
+        }
+        else if (item >= outliers.upper.threshold) {
+            outliers.upper.indexes.push(index);
+        }
+    });
+    return outliers;
+}
+exports.IQR = IQR;

package/lib/data/statistics/base.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Get the minimum of the array.
+ * @param value - The array to process
+ */
+export declare function min(value: number[]): number;
+/**
+ * Get the minimum index of the array.
+ * @param value - The array to process
+ */
+export declare function minIndex(value: number[]): number;
+/**
+ * Get the maximum of the array.
+ * @param value - The array to process
+ */
+export declare function max(value: number[]): number;
+/**
+ * Get the maximum index of the array.
+ * @param value - The array to process
+ */
+export declare function maxIndex(value: number[]): number;
+/**
+ * Calculate the sum of the array.
+ * @param value - The array to process
+ */
+export declare function sum(value: number[]): number;
+/**
+ * Calculate the mean of the array.
+ * @param value - The array to process
+
+ */
+export declare function mean(value: number[]): number;
+/**
+ * Calculate the geometricMean of the array.
+ * @param value - The array to process
+ */
+export declare function geometricMean(value: number[]): number;
+/**
+ * Calculate the harmonic mean of the array.
+ * @param value - The array to process
+ */
+export declare function harmonicMean(value: number[]): number;
+/**
+ * Calculate the median of the array.
+ * @param value - The array to process
+ */
+export declare function median(value: number[], sorted?: boolean): number;
+/**
+ * Calculate the quartile of the array.
+ * @param value - The array to process
+ * @param sorted - Whether it is sorted
+ */
+export declare function quartile(value: number[], sorted?: boolean): [number, number, number];
+/**
+ * Calculate the quantile of the array.
+ * @param value - The array to process
+ * @param percent - percent
+ * @param sorted - Whether it is sorted
+ */
+export declare function quantile(value: number[], percent: number, sorted?: boolean): number;
+/**
+ * Calculate the variance of the array.
+ * @param value - The array to process
+ */
+export declare function variance(value: number[]): number;
+/**
+ * Calculate the standard deviation of the array.
+ * @param value - The array to process
+ */
+export declare function standardDeviation(value: number[]): number;
+/**
+ * Calculate the coefficient of variance of the array.
+ * @param value - The array to process
+ */
+export declare function coefficientOfVariance(value: number[]): number;
+/**
+ * Calculate the covariance of the array.
+ * @param x - variable x
+ * @param y - variable y
+ */
+export declare function covariance(x: number[], y: number[]): number;
+/**
+ * Calculate the pearson correlation coefficient of two value.
+ * @param x - variable x
+ * @param y - variable y
+ */
+export declare function pearson(x: number[], y: number[]): number;
+/**
+ * Calculate the counts of valid value in the array.
+ * @param value - The array to process
+ */
+export declare function valid(value: unknown[]): number;
+/**
+ * Calculate the counts of missing value in the array.
+ * @param value - The array to process
+ */
+export declare function missing(value: unknown[]): number;
+/**
+ * Calculate the counts of each distinct value in the array.
+ * @param value - The array to process
+ */
+export declare function valueMap(value: unknown[]): Record<string, number>;
+/**
+ * Calculate the counts of distinct value in the array.
+ * @param value - The array to process
+ */
+export declare function distinct(value: unknown[]): number;

package/lib/data/statistics/base.js

@@ -0,0 +1,271 @@
+"use strict";
+/*
+ * Statistical methods used internally by ava.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distinct = exports.valueMap = exports.missing = exports.valid = exports.pearson = exports.covariance = exports.coefficientOfVariance = exports.standardDeviation = exports.variance = exports.quantile = exports.quartile = exports.median = exports.harmonicMean = exports.geometricMean = exports.mean = exports.sum = exports.maxIndex = exports.max = exports.minIndex = exports.min = void 0;
+var tslib_1 = require("tslib");
+var utils_1 = require("../utils");
+var cache = tslib_1.__importStar(require("./caches"));
+/**
+ * Get the minimum of the array.
+ * @param value - The array to process
+ */
+function min(value) {
+    var cachedValue = cache.get(value, 'min');
+    if (cachedValue !== undefined)
+        return cachedValue;
+    return cache.set(value, 'min', Math.min.apply(Math, tslib_1.__spreadArray([], tslib_1.__read(value), false)));
+}
+exports.min = min;
+function getMinIndex(value) {
+    var min = value[0];
+    var idx = 0;
+    for (var i = 0; i < value.length; i += 1) {
+        if (value[i] < min) {
+            idx = i;
+            min = value[i];
+        }
+    }
+    return idx;
+}
+/**
+ * Get the minimum index of the array.
+ * @param value - The array to process
+ */
+function minIndex(value) {
+    var cachedValue = cache.get(value, 'minIndex');
+    if (cachedValue !== undefined)
+        return cachedValue;
+    return cache.set(value, 'minIndex', getMinIndex(value));
+}
+exports.minIndex = minIndex;
+/**
+ * Get the maximum of the array.
+ * @param value - The array to process
+ */
+function max(value) {
+    var cachedValue = cache.get(value, 'max');
+    if (cachedValue !== undefined)
+        return cachedValue;
+    return cache.set(value, 'max', Math.max.apply(Math, tslib_1.__spreadArray([], tslib_1.__read(value), false)));
+}
+exports.max = max;
+function getMaxIndex(value) {
+    var max = value[0];
+    var idx = 0;
+    for (var i = 0; i < value.length; i += 1) {
+        if (value[i] > max) {
+            idx = i;
+            max = value[i];
+        }
+    }
+    return idx;
+}
+/**
+ * Get the maximum index of the array.
+ * @param value - The array to process
+ */
+function maxIndex(value) {
+    var cachedValue = cache.get(value, 'maxIndex');
+    if (cachedValue !== undefined)
+        return cachedValue;
+    return cache.set(value, 'maxIndex', getMaxIndex(value));
+}
+exports.maxIndex = maxIndex;
+/**
+ * Calculate the sum of the array.
+ * @param value - The array to process
+ */
+function sum(value) {
+    var cachedValue = cache.get(value, 'sum');
+    if (cachedValue !== undefined)
+        return cachedValue;
+    return cache.set(value, 'sum', value.reduce(function (prev, current) { return current + prev; }, 0));
+}
+exports.sum = sum;
+/**
+ * Calculate the mean of the array.
+ * @param value - The array to process
+
+ */
+function mean(value) {
+    return sum(value) / value.length;
+}
+exports.mean = mean;
+/**
+ * Calculate the geometricMean of the array.
+ * @param value - The array to process
+ */
+function geometricMean(value) {
+    (0, utils_1.assert)(value.some(function (item) { return item > 0; }), 'Each item in value must greater than 0.');
+    var cachedValue = cache.get(value, 'geometricMean');
+    if (cachedValue !== undefined)
+        return cachedValue;
+    return cache.set(value, 'geometricMean', Math.pow(value.reduce(function (prev, curr) { return prev * curr; }, 1), (1 / value.length)));
+}
+exports.geometricMean = geometricMean;
+/**
+ * Calculate the harmonic mean of the array.
+ * @param value - The array to process
+ */
+function harmonicMean(value) {
+    var base = Math.pow(2, 16);
+    var cachedValue = cache.get(value, 'harmonicMean');
+    if (cachedValue !== undefined)
+        return cachedValue;
+    return cache.set(value, 'harmonicMean', (base * value.length) / value.reduce(function (prev, curr) { return base / curr + prev; }, 0));
+}
+exports.harmonicMean = harmonicMean;
+function sort(value) {
+    return value.sort(function (l, r) { return (l > r ? 1 : -1); });
+}
+/**
+ * Calculate the median of the array.
+ * @param value - The array to process
+ */
+function median(value, sorted) {
+    if (sorted === void 0) { sorted = false; }
+    var length = value.length;
+    var newArray = sorted ? value : sort(value);
+    if (length % 2 === 1)
+        return newArray[(length - 1) / 2];
+    return (newArray[length / 2 - 1] + newArray[length / 2]) / 2;
+}
+exports.median = median;
+/**
+ * Calculate the quartile of the array.
+ * @param value - The array to process
+ * @param sorted - Whether it is sorted
+ */
+function quartile(value, sorted) {
+    if (sorted === void 0) { sorted = false; }
+    (0, utils_1.assert)(value.length >= 3, 'The length of value cannot be less than 3.');
+    var length = value.length;
+    var newArray = sorted ? value : sort(value);
+    var Q2 = median(newArray, true);
+    var Q1;
+    var Q3;
+    if (length % 2 === 1) {
+        Q1 = median(newArray.slice(0, (length - 1) / 2), true);
+        Q3 = median(newArray.slice((length + 1) / 2), true);
+    }
+    else {
+        Q1 = median(newArray.slice(0, length / 2), true);
+        Q3 = median(newArray.slice(length / 2), true);
+    }
+    return [Q1, Q2, Q3];
+}
+exports.quartile = quartile;
+/**
+ * Calculate the quantile of the array.
+ * @param value - The array to process
+ * @param percent - percent
+ * @param sorted - Whether it is sorted
+ */
+function quantile(value, percent, sorted) {
+    if (sorted === void 0) { sorted = false; }
+    (0, utils_1.assert)(percent > 0 && percent < 100, 'The percent cannot be between (0, 100).');
+    var newArray = sorted ? value : sort(value);
+    var index = Math.ceil((value.length * percent) / 100) - 1;
+    return newArray[index];
+}
+exports.quantile = quantile;
+/**
+ * Calculate the variance of the array.
+ * @param value - The array to process
+ */
+function variance(value) {
+    var m = mean(value);
+    var cachedValue = cache.get(value, 'variance');
+    if (cachedValue !== undefined)
+        return cachedValue;
+    return cache.set(value, 'variance', value.reduce(function (prev, curr) { return prev + Math.pow((curr - m), 2); }, 0) / value.length);
+}
+exports.variance = variance;
+/**
+ * Calculate the standard deviation of the array.
+ * @param value - The array to process
+ */
+function standardDeviation(value) {
+    return Math.sqrt(variance(value));
+}
+exports.standardDeviation = standardDeviation;
+/**
+ * Calculate the coefficient of variance of the array.
+ * @param value - The array to process
+ */
+function coefficientOfVariance(value) {
+    var stdev = standardDeviation(value);
+    var arrayMean = mean(value);
+    return stdev / arrayMean;
+}
+exports.coefficientOfVariance = coefficientOfVariance;
+/**
+ * Calculate the covariance of the array.
+ * @param x - variable x
+ * @param y - variable y
+ */
+function covariance(x, y) {
+    (0, utils_1.assert)(x.length === y.length, 'The x and y must has same length.');
+    var exy = mean(x.map(function (item, i) { return item * y[i]; }));
+    return exy - mean(x) * mean(y);
+}
+exports.covariance = covariance;
+/**
+ * Calculate the pearson correlation coefficient of two value.
+ * @param x - variable x
+ * @param y - variable y
+ */
+function pearson(x, y) {
+    var cov = covariance(x, y);
+    var dx = standardDeviation(x);
+    var dy = standardDeviation(y);
+    return cov / (dx * dy);
+}
+exports.pearson = pearson;
+/**
+ * Calculate the counts of valid value in the array.
+ * @param value - The array to process
+ */
+function valid(value) {
+    var count = 0;
+    for (var i = 0; i < value.length; i += 1) {
+        if (value[i])
+            count += 1;
+    }
+    return count;
+}
+exports.valid = valid;
+/**
+ * Calculate the counts of missing value in the array.
+ * @param value - The array to process
+ */
+function missing(value) {
+    return value.length - valid(value);
+}
+exports.missing = missing;
+/**
+ * Calculate the counts of each distinct value in the array.
+ * @param value - The array to process
+ */
+function valueMap(value) {
+    var data = {};
+    value.forEach(function (v) {
+        var vStr = "".concat(v);
+        if (data[vStr])
+            data[vStr] += 1;
+        else
+            data[vStr] = 1;
+    });
+    return data;
+}
+exports.valueMap = valueMap;
+/**
+ * Calculate the counts of distinct value in the array.
+ * @param value - The array to process
+ */
+function distinct(value) {
+    return Object.keys(valueMap(value)).length;
+}
+exports.distinct = distinct;

package/lib/data/statistics/bayesian.d.ts

@@ -0,0 +1,5 @@
+import type { ChangePointItem } from './types';
+/**
+ * Bayesian Online Changepoint Detection
+ */
+export declare function bayesian(series?: number[]): ChangePointItem[];

package/lib/data/statistics/bayesian.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bayesian = void 0;
+var tslib_1 = require("tslib");
+var bayesian_changepoint_1 = tslib_1.__importDefault(require("bayesian-changepoint"));
+var pettitt_test_1 = require("./pettitt-test");
+function breakpointVerifier(next, prev) {
+    if (Math.abs(next.data - prev.data) >= 1) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Bayesian Online Changepoint Detection
+ */
+function bayesian(series) {
+    if (series === void 0) { series = []; }
+    var detection = new bayesian_changepoint_1.default({
+        breakpointVerifier: breakpointVerifier,
+        chunkSize: series.length,
+        iteratee: function (t) { return t; },
+    });
+    detection.exec(series);
+    var result = detection.breakPoints().map(function (breakPoint) { return ({
+        index: breakPoint.index,
+        significance: 1 - (0, pettitt_test_1.calcPValue)(series, breakPoint.index),
+    }); });
+    return result;
+}
+exports.bayesian = bayesian;

package/lib/data/statistics/buishand-u.d.ts

@@ -0,0 +1,7 @@
+import type { ChangePointItem } from './types';
+/**
+ * Buishad U statistics test
+ */
+export declare function buishandUTest(data: number[]): ChangePointItem & {
+    uValue: number;
+};

package/lib/data/statistics/buishand-u.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buishandUTest = void 0;
+var lodash_1 = require("lodash");
+var __1 = require("..");
+var window_1 = require("./window");
+/**
+ * Buishad U statistics test
+ */
+function buishandUTest(data) {
+    var n = data === null || data === void 0 ? void 0 : data.length;
+    var meanValue = (0, lodash_1.mean)(data);
+    var Sk = data.map(function (_, index) { return (0, lodash_1.sum)(data.slice(0, index + 1)) - meanValue * (index + 1); });
+    var U = (0, lodash_1.sumBy)(Sk.slice(0, n - 1), function (item) { return Math.pow(item, 2); }) / (n * (n + 1));
+    var Smax = (0, __1.maxabs)(Sk);
+    var maxIndex = Sk.findIndex(function (item) { return item === Smax; });
+    return {
+        uValue: U,
+        index: maxIndex,
+        significance: 1 - (0, window_1.calcPValue)(data, maxIndex),
+    };
+}
+exports.buishandUTest = buishandUTest;

package/lib/data/statistics/caches.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Cache the value for target and key.
+ * @param target - target
+ * @param key - key
+ * @param value - value
+ */
+export declare function set<T>(target: any[], key: string, value: T): T;
+/**
+ * Get the cached value for target and key.
+ * @param target - target
+ * @param key - key
+ */
+export declare function get<T>(target: any[], key: string): T | undefined;

package/lib/data/statistics/caches.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get = exports.set = void 0;
+/**
+ * Cache some statistics results to improve performance.
+ */
+var CACHES = new WeakMap();
+/**
+ * Cache the value for target and key.
+ * @param target - target
+ * @param key - key
+ * @param value - value
+ */
+function set(target, key, value) {
+    if (!CACHES.get(target)) {
+        CACHES.set(target, new Map());
+    }
+    CACHES.get(target).set(key, value);
+    return value;
+}
+exports.set = set;
+/**
+ * Get the cached value for target and key.
+ * @param target - target
+ * @param key - key
+ */
+function get(target, key) {
+    var cache = CACHES.get(target);
+    if (!cache)
+        return undefined;
+    return cache.get(key);
+}
+exports.get = get;

package/lib/data/statistics/cdf.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Evaluates the cumulative distribution function (CDF) for a normal distribution at a value x
+ * - Reference to equation 26.2.17 in https://personal.math.ubc.ca/~cbm/aands/abramowitz_and_stegun.pdf
+ * @param mu mean
+ * @param sigma standard deviation
+ * */
+export declare const cdf: (x: number, mu?: number, sigma?: number) => number;

package/lib/data/statistics/cdf.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cdf = void 0;
+var lodash_1 = require("lodash");
+/**
+ * Evaluates the cumulative distribution function (CDF) for a normal distribution at a value x
+ * - Reference to equation 26.2.17 in https://personal.math.ubc.ca/~cbm/aands/abramowitz_and_stegun.pdf
+ * @param mu mean
+ * @param sigma standard deviation
+ * */
+var cdf = function (x, mu, sigma) {
+    if (mu === void 0) { mu = 0; }
+    if (sigma === void 0) { sigma = 1; }
+    if (sigma < 0 || [x, mu, sigma].some(function (value) { return (0, lodash_1.isNil)(value); }))
+        return NaN;
+    // transfer to standard normal distribution
+    var normalX = Math.abs((x - mu) / sigma);
+    /** probability density function of the standard normal distribution */
+    var Zx = (1 / Math.sqrt(2 * Math.PI)) * Math.exp((-1 * Math.pow(normalX, 2)) / 2);
+    /**
+     * - use approximate elementary functional algorithm, error less than 4.5e-4
+     * @todo add document explaining the derivation process
+     * */
+    var t = 1 / (1 + 0.33267 * normalX);
+    // error less than 1e-5
+    var Px = 1 - Zx * (0.4361836 * t - 0.1201676 * Math.pow(t, 2) + 0.937298 * Math.pow(t, 3));
+    return x > mu ? Px : 1 - Px;
+};
+exports.cdf = cdf;

package/lib/data/statistics/constants.d.ts

@@ -0,0 +1,5 @@
+import { LowessOptions, PCorrTestParameter } from './types';
+/** default options in LOWESS */
+export declare const DEFAULT_LOWESS_OPTIONS: LowessOptions;
+/** default options in LOWESS */
+export declare const DEFAULT_PCORRTEST_OPTIONS: PCorrTestParameter;

package/lib/data/statistics/constants.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PCORRTEST_OPTIONS = exports.DEFAULT_LOWESS_OPTIONS = void 0;
+/** default options in LOWESS */
+exports.DEFAULT_LOWESS_OPTIONS = {
+    f: 2 / 3,
+    nSteps: 3,
+    delta: null,
+};
+/** default options in LOWESS */
+exports.DEFAULT_PCORRTEST_OPTIONS = {
+    alpha: 0.05,
+    alternative: 'two-sided',
+    rho: 0,
+};

package/lib/data/statistics/index.d.ts

@@ -0,0 +1,7 @@
+export * from './base';
+export { cdf } from './cdf';
+export { maxabs } from './maxabs';
+export * from './quantile';
+export * from './lowess';
+export * from './vector';
+export { pcorrtest } from './pcorrtest';

package/lib/data/statistics/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pcorrtest = exports.maxabs = exports.cdf = void 0;
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./base"), exports);
+var cdf_1 = require("./cdf");
+Object.defineProperty(exports, "cdf", { enumerable: true, get: function () { return cdf_1.cdf; } });
+var maxabs_1 = require("./maxabs");
+Object.defineProperty(exports, "maxabs", { enumerable: true, get: function () { return maxabs_1.maxabs; } });
+tslib_1.__exportStar(require("./quantile"), exports);
+tslib_1.__exportStar(require("./lowess"), exports);
+tslib_1.__exportStar(require("./vector"), exports);
+var pcorrtest_1 = require("./pcorrtest");
+Object.defineProperty(exports, "pcorrtest", { enumerable: true, get: function () { return pcorrtest_1.pcorrtest; } });

package/lib/data/statistics/lowess.d.ts

@@ -0,0 +1,10 @@
+import { LowessOptions, LowessOutput } from './types';
+export declare const tricubeWeightFunction: (x: number) => number;
+export declare const bisquareWeightFunction: (x: number) => number;
+export declare const weightedLinearRegression: (x: number[], y: number[], w: number[]) => number[][];
+/**
+ * Locally weighted regression
+ * - General idea: perform weighted linear regression on localized subsets of the data point by point to calculate fitted value.
+ * - Reference: William S. Cleveland. Robust Locally Weighted Regression and Smoothing Scatterplots. Journal of the American Statistical Association. 1979. Vol. 74(368):829-836.
+ * */
+export declare const lowess: (x: number[], y: number[], options?: LowessOptions) => LowessOutput;