@formant/ava 3.4.1-formant

package/lib/data/statistics/lowess.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lowess = exports.weightedLinearRegression = exports.bisquareWeightFunction = exports.tricubeWeightFunction = void 0;
+var lodash_1 = require("lodash");
+var utils_1 = require("../utils");
+var base_1 = require("./base");
+var constants_1 = require("./constants");
+var vector_1 = require("./vector");
+var tricubeWeightFunction = function (x) {
+    if (!(0, lodash_1.isNumber)(x) || Math.abs(x) >= 1)
+        return 0;
+    return Math.pow((1 - Math.pow(Math.abs(x), 3)), 3);
+};
+exports.tricubeWeightFunction = tricubeWeightFunction;
+var bisquareWeightFunction = function (x) {
+    if (!(0, lodash_1.isNumber)(x) || Math.abs(x) >= 1)
+        return 0;
+    return Math.pow((1 - Math.pow(x, 2)), 2);
+};
+exports.bisquareWeightFunction = bisquareWeightFunction;
+var weightedLinearRegression = function (x, y, w) {
+    /** dimension: 2*n */
+    var xt = [(0, utils_1.nOnes)(x.length), x];
+    /** dimension: n*2 */
+    var xMatrix = (0, vector_1.matrixTranspose)(xt);
+    /** dimension: n*1 */
+    var yMatrix = (0, vector_1.matrixTranspose)([y]);
+    /** diagonal matrix with w as the main diagonal */
+    var wMatrix = (0, vector_1.constructDiagonalMatrix)(w);
+    /**
+     * (X^(T)wX)^(-1)
+     * - 2*n, n*n, n*2 => 2*2
+     * */
+    var factor = (0, vector_1.inverseSecondOrderMatrix)((0, vector_1.multiMatrixMultiply)([xt, wMatrix, xMatrix]));
+    /**
+     * (X^(T)wX)^(-1) X^(T)wY
+     * - 2*2, 2*n, n*1 => 2*1
+     * */
+    return (0, vector_1.multiMatrixMultiply)([factor, xt, wMatrix, yMatrix]);
+};
+exports.weightedLinearRegression = weightedLinearRegression;
+/**
+ * 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.
+ * */
+var lowess = function (x, y, options) {
+    var xLength = x.length;
+    var mergeOptions = (0, lodash_1.mergeWith)(constants_1.DEFAULT_LOWESS_OPTIONS, options, function (defaultValue, inputValue) {
+        return inputValue !== null && inputValue !== void 0 ? inputValue : defaultValue;
+    });
+    // length of subset
+    var r = Math.ceil(xLength * mergeOptions.f);
+    // for each i, hi be the distance from xi to the rth nearest neighbor of xi
+    var h = x.map(function (xi) {
+        // rth smallest number among |xi - xj|, for j = 1, ..., n
+        return x.map(function (xj) { return Math.abs(xi - xj); }).sort(function (a, b) { return a - b; })[r];
+    });
+    // weight, n*n
+    var w = x.map(function (xi, i) {
+        // wk(xi) = weightFunc((xk - xi)/hi), for k = 1, ..., n
+        return x.map(function (xk) { return (0, exports.tricubeWeightFunction)((xk - xi) / h[i]); });
+    });
+    var robustCoefficient = (0, utils_1.nOnes)(xLength);
+    /** fitted values */
+    var yFit = (0, utils_1.nZeros)(xLength);
+    var _loop_1 = function (iter) {
+        for (var i = 0; i < xLength; i += 1) {
+            var robustWeight = w[i].map(function (wik, k) { return wik * robustCoefficient[k]; });
+            var beta = (0, exports.weightedLinearRegression)(x, y, robustWeight);
+            yFit[i] = beta[0][0] + beta[1][0] * x[i];
+        }
+        var residuals = (0, vector_1.vectorSubtract)(y, yFit);
+        /** median of |residuals| */
+        var s = (0, base_1.median)(residuals.map(function (res) { return Math.abs(res); }));
+        residuals.forEach(function (res, i) {
+            robustCoefficient[i] = (0, exports.bisquareWeightFunction)(res / (6 * s));
+        });
+    };
+    for (var iter = 0; iter < mergeOptions.nSteps; iter += 1) {
+        _loop_1(iter);
+    }
+    return {
+        y: yFit,
+    };
+};
+exports.lowess = lowess;

package/lib/data/statistics/mannkendall-test.d.ts

@@ -0,0 +1,15 @@
+import { TrendType } from '../../insight/types';
+/**
+ * http://vsp.pnnl.gov/help/Vsample/Design_Trend_Mann_Kendall.htm
+   the Mann-Kendall (MK) test is to statistically assess if there
+   is a monotonic upward or downward trend of the variable of
+   interest over time.
+   使用 Mann-Kendall 单调趋势检验判断趋势是否有方向性（上升/下降）
+ * @param data
+ * @param alpha
+ */
+export declare function mkTest(data: number[], alpha?: number): {
+    trend: TrendType;
+    pValue: number;
+    zScore: number;
+};

package/lib/data/statistics/mannkendall-test.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mkTest = void 0;
+var tslib_1 = require("tslib");
+var lodash_1 = require("lodash");
+var common_1 = require("../../insight/utils/common");
+var __1 = require("..");
+/**
+ * http://vsp.pnnl.gov/help/Vsample/Design_Trend_Mann_Kendall.htm
+   the Mann-Kendall (MK) test is to statistically assess if there
+   is a monotonic upward or downward trend of the variable of
+   interest over time.
+   使用 Mann-Kendall 单调趋势检验判断趋势是否有方向性（上升/下降）
+ * @param data
+ * @param alpha
+ */
+function mkTest(data, alpha) {
+    if (alpha === void 0) { alpha = 0.05; }
+    var length = data === null || data === void 0 ? void 0 : data.length;
+    var S = 0;
+    for (var k = 0; k < length - 1; k += 1) {
+        for (var j = k + 1; j < length; j += 1) {
+            S += (0, common_1.sign)(data[j] - data[k]);
+        }
+    }
+    var _a = tslib_1.__read((0, common_1.unique)(data), 2), uniqArr = _a[0], uniqCount = _a[1];
+    var uniqLength = uniqArr.length;
+    var varS = (length * (length - 1) * (2 * length + 5) -
+        (uniqLength === length ? 0 : (0, lodash_1.sumBy)(uniqCount, function (c) { return c * (c - 1) * (2 * c + 5); }))) /
+        18;
+    var zScore = 0;
+    if (S > 0) {
+        zScore = (S - 1) / Math.sqrt(varS);
+    }
+    else if (S < 0) {
+        zScore = (S + 1) / Math.sqrt(varS);
+    }
+    // calculate the p_value
+    var pValue = 2 * (1 - (0, __1.cdf)(Math.abs(zScore), 0, 1));
+    var h = Math.abs(zScore) > (0, __1.normalDistributionQuantile)(1 - alpha / 2, 0, 1);
+    var trend = 'no trend';
+    if (zScore < 0 && h) {
+        trend = 'decreasing';
+    }
+    else if (zScore > 0 && h) {
+        trend = 'increasing';
+    }
+    return {
+        trend: trend,
+        pValue: pValue,
+        zScore: zScore,
+    };
+}
+exports.mkTest = mkTest;

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

@@ -0,0 +1,5 @@
+/**
+ * Returns the maximum absolute value of array
+ * @param x input array
+ * */
+export declare const maxabs: (x: number[]) => number;

package/lib/data/statistics/maxabs.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxabs = void 0;
+var tslib_1 = require("tslib");
+/**
+ * Returns the maximum absolute value of array
+ * @param x input array
+ * */
+var maxabs = function (x) {
+    var absoluteX = x.map(function (value) { return Math.abs(value); });
+    return Math.max.apply(Math, tslib_1.__spreadArray([], tslib_1.__read(absoluteX), false));
+};
+exports.maxabs = maxabs;

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

@@ -0,0 +1,3 @@
+import { PCorrTestParameter, PCorrTestOutput } from './types';
+/** Perform a Pearson product-moment correlation test between paired samples  */
+export declare const pcorrtest: (x: number[], y: number[], options?: PCorrTestParameter) => PCorrTestOutput;

package/lib/data/statistics/pcorrtest.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pcorrtest = void 0;
+var lodash_1 = require("lodash");
+var base_1 = require("./base");
+var constants_1 = require("./constants");
+var quantile_1 = require("./quantile");
+/** Perform a Pearson product-moment correlation test between paired samples  */
+var pcorrtest = function (x, y, options) {
+    if (x.length !== y.length) {
+        // eslint-disable-next-line no-console
+        console.error('invalid arguments: First and second arguments must be arrays having the same length');
+        return {
+            pcorr: null,
+            rejected: false,
+        };
+    }
+    var _a = (0, lodash_1.mergeWith)(constants_1.DEFAULT_PCORRTEST_OPTIONS, options, function (defaultValue, inputValue) {
+        return inputValue !== null && inputValue !== void 0 ? inputValue : defaultValue;
+    }), alpha = _a.alpha, alternative = _a.alternative, rho = _a.rho;
+    /** pearson correlation coefficient */
+    var pcorr = (0, base_1.pearson)(x, y);
+    /** statistic to be tested */
+    var statistic;
+    var threshold;
+    /** whether to reject null hypothesis */
+    var rejected = false;
+    if (rho !== 0) {
+        /**
+         * - if rho is provided, it needs to be corrected by Fisher's z transform so that it satisfies the normal distribution
+         * - https://en.wikipedia.org/wiki/Fisher_transformation
+         *  */
+        var z = 0.5 * Math.log((1 + pcorr) / (1 - pcorr));
+        /** mean of z */
+        var meanZ = 0.5 * Math.log((1 + rho) / (1 - rho));
+        /** standard error of z */
+        var sigmaZ = 1 / Math.sqrt(x.length - 3);
+        statistic = (z - meanZ) / sigmaZ;
+        if (alternative === 'greater') {
+            threshold = (0, quantile_1.normalDistributionQuantile)(1 - alpha);
+            if (statistic >= threshold)
+                rejected = true;
+        }
+        else if (alternative === 'less') {
+            threshold = (0, quantile_1.normalDistributionQuantile)(alpha);
+            if (statistic <= threshold)
+                rejected = true;
+        }
+        else {
+            threshold = (0, quantile_1.normalDistributionQuantile)(1 - alpha / 2);
+            if (Math.abs(statistic) >= threshold)
+                rejected = true;
+        }
+    }
+    else {
+        // obey the t distribution under the null hypothesis, t~t(n-2)
+        var degree = x.length - 2;
+        statistic = (pcorr * Math.sqrt(degree)) / Math.sqrt(1 - Math.pow(pcorr, 2));
+        if (alternative === 'greater') {
+            threshold = (0, quantile_1.tDistributionQuantile)(1 - alpha, degree);
+            if (statistic >= threshold)
+                rejected = true;
+        }
+        else if (alternative === 'less') {
+            threshold = (0, quantile_1.tDistributionQuantile)(alpha, degree);
+            if (statistic <= threshold)
+                rejected = true;
+        }
+        else {
+            threshold = (0, quantile_1.tDistributionQuantile)(1 - alpha / 2, degree);
+            if (Math.abs(statistic) >= threshold)
+                rejected = true;
+        }
+    }
+    return {
+        rejected: rejected,
+        pcorr: pcorr,
+    };
+};
+exports.pcorrtest = pcorrtest;

package/lib/data/statistics/pettitt-test.d.ts

@@ -0,0 +1,9 @@
+import { ChangePointItem } from './types';
+/**
+ * Pettitt's (1979) method is a rank-based nonparametric test for abrupt changes in a time series.
+ * */
+export declare function pettittTest(data: number[]): ChangePointItem;
+/**
+ * p-value calc in Pettitt
+ */
+export declare function calcPValue(data: number[], index: number): number;

package/lib/data/statistics/pettitt-test.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calcPValue = exports.pettittTest = void 0;
+var lodash_1 = require("lodash");
+var common_1 = require("../../insight/utils/common");
+/**
+ * Pettitt's (1979) method is a rank-based nonparametric test for abrupt changes in a time series.
+ * */
+function pettittTest(data) {
+    var n = data === null || data === void 0 ? void 0 : data.length;
+    var rankArr = (0, common_1.rank)(data);
+    var Umax = 0;
+    var UmaxIndex = -1;
+    for (var k = 0; k < n; k += 1) {
+        var U = Math.abs(2 * (0, lodash_1.sumBy)(rankArr.slice(0, k)) - k * (n + 1));
+        if (U > Umax) {
+            Umax = U;
+            UmaxIndex = k;
+        }
+    }
+    var pvalue = 2 * Math.exp((-6 * Math.pow(Umax, 2)) / (Math.pow(n, 2) + Math.pow(n, 3)));
+    return {
+        index: UmaxIndex,
+        significance: 1 - pvalue,
+    };
+}
+exports.pettittTest = pettittTest;
+/**
+ * p-value calc in Pettitt
+ */
+function calcPValue(data, index) {
+    var n = data === null || data === void 0 ? void 0 : data.length;
+    var rankArr = (0, common_1.rank)(data);
+    var U = Math.abs(2 * (0, lodash_1.sumBy)(rankArr.slice(0, index)) - index * (n + 1));
+    var pvalue = 2 * Math.exp((-6 * Math.pow(U, 2)) / (Math.pow(n, 2) + Math.pow(n, 3)));
+    return pvalue;
+}
+exports.calcPValue = calcPValue;

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

@@ -0,0 +1,16 @@
+/**
+ * Normal distribution quantile function
+ * - Reference to equation 26.2.23 in https://personal.math.ubc.ca/~cbm/aands/abramowitz_and_stegun.pdf
+ * - If F(x) is the cumulative distribution function of a normal distribution N(mu, sigma), F(x) = p, quantile(p, mu, sigma) = x.
+ * - The value range of p is [0, 1]. If p > 1 or p < 0, return NaN.
+ * @param p input value
+ * @param mu mean
+ * @param sigma standard deviation
+ * */
+export declare const normalDistributionQuantile: (p: number, mu?: number, sigma?: number) => number;
+/**
+ * student's t distribution quantile function
+ * @param p probability
+ * @param v degree of freedom
+ */
+export declare const tDistributionQuantile: (p: number, d?: number) => number;

package/lib/data/statistics/quantile.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tDistributionQuantile = exports.normalDistributionQuantile = void 0;
+/**
+ * Normal distribution quantile function
+ * - Reference to equation 26.2.23 in https://personal.math.ubc.ca/~cbm/aands/abramowitz_and_stegun.pdf
+ * - If F(x) is the cumulative distribution function of a normal distribution N(mu, sigma), F(x) = p, quantile(p, mu, sigma) = x.
+ * - The value range of p is [0, 1]. If p > 1 or p < 0, return NaN.
+ * @param p input value
+ * @param mu mean
+ * @param sigma standard deviation
+ * */
+var normalDistributionQuantile = function (p, mu, sigma) {
+    if (mu === void 0) { mu = 0; }
+    if (sigma === void 0) { sigma = 1; }
+    if (p > 1 || p < 0 || sigma < 0)
+        return NaN;
+    // formula requires that p is no more than 0.5
+    var adjustedP = p <= 0.5 ? p : 1 - p;
+    var t = Math.sqrt(-2 * Math.log(adjustedP));
+    /**
+     * Q(qXp) + F(qXp) = 1
+     * - use approximate elementary functional algorithm, error less than 4.5e-4
+     * @todo add document explaining the derivation process
+     * */
+    var qXp = t - (2.515517 + 0.802853 * t + 0.010328 * Math.pow(t, 2)) / (1 + 1.432788 * t + 0.189269 * Math.pow(t, 2) + 0.001308 * Math.pow(t, 3));
+    // quantile of standard normal distribution
+    var normalXp = p <= 0.5 ? -1 * qXp : qXp;
+    // transfer to quantile of normal distribution N(mu, sigma)
+    var Xp = sigma * normalXp + mu;
+    return Xp;
+};
+exports.normalDistributionQuantile = normalDistributionQuantile;
+/**
+ * student's t distribution quantile function
+ * @param p probability
+ * @param v degree of freedom
+ */
+var tDistributionQuantile = function (p, d) {
+    if (d === void 0) { d = 1; }
+    if (p > 1 || p < 0 || d <= 0)
+        return NaN;
+    // when the degree of freedom is 1, the t distribution is the same as a standard Cauchy distribution
+    // reference to equation 35 in http://www.homepages.ucl.ac.uk/~ucahwts/lgsnotes/JCF_Student.pdf
+    if (d === 1)
+        return -Math.cos(Math.PI * p) / Math.sin(Math.PI * p);
+    // reference to equation 36 in http://www.homepages.ucl.ac.uk/~ucahwts/lgsnotes/JCF_Student.pdf
+    if (d === 2)
+        return (2 * p - 1) / Math.sqrt(2 * p * (1 - p));
+    // Q(x) = p, Q(x) + F(x) = 1, F(x) is standard normal distribution CDF
+    var prop = p > 0.5 ? p : 1 - p;
+    var x = (0, exports.normalDistributionQuantile)(prop);
+    var g1 = (Math.pow(x, 3) + x) / 4;
+    var g2 = (5 * Math.pow(x, 5) + 16 * Math.pow(x, 3) + 3 * x) / 96;
+    var g3 = (3 * Math.pow(x, 7) + 19 * Math.pow(x, 5) + 17 * Math.pow(x, 3) - 15 * x) / 384;
+    var g4 = (79 * Math.pow(x, 9) + 776 * Math.pow(x, 7) + 1482 * Math.pow(x, 5) - 1920 * Math.pow(x, 3) - 945 * x) / 92160;
+    // Cornish–Fisher expansions
+    // reference to equation 26.7.5 in https://personal.math.ubc.ca/~cbm/aands/abramowitz_and_stegun.pdf
+    return (p > 0.5 ? 1 : -1) * (x + g1 / d + g2 / Math.pow(d, 2) + g3 / Math.pow(d, 3) + g4 / Math.pow(d, 4));
+};
+exports.tDistributionQuantile = tDistributionQuantile;

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

@@ -0,0 +1,70 @@
+/**
+ * function options of LOWESS method
+ */
+export type LowessOptions = {
+    /**
+     * Proportion of points for local regression which influence smoothing at each value; default: 2/3
+     * */
+    f?: number;
+    /**
+     * Number of iterations for local regression (fewer iterations translates to faster function execution; default: 3)
+     * */
+    nSteps?: number;
+    /**
+     * Nonnegative parameter which may be used to reduce the number of computations.
+     * Perform a local regression at intervals of delta data points.
+     * */
+    delta?: number;
+};
+/**
+ * LOWESS output
+ */
+export type LowessOutput = {
+    /** Fitted values */
+    y: number[];
+};
+export type PCorrTestParameter = {
+    /**
+     * Significance level (default: 0.05).
+     */
+    alpha?: number;
+    /**
+     * Alternative hypothesis (`two-sided`, `less`, or `greater`; default: 'two-sided').
+     */
+    alternative?: 'two-sided' | 'less' | 'greater';
+    /**
+     * Correlation under H0 (default: 0.0).
+     * To test whether the correlation coefficient is equal to some other value than 0.
+     */
+    rho?: number;
+};
+export type PCorrTestOutput = {
+    /**
+     * whether to reject null hypothesis
+     * */
+    rejected: boolean;
+    /**
+     * pearson correlation coefficient
+     * */
+    pcorr: number;
+    /**
+     * used significance level
+     * */
+    alpha?: number;
+    /**
+     * statistic to be tested
+     * */
+    statistic?: number;
+    /**
+     * used alternative hypothesis (`two-sided`, `less` or `greater`).
+     * */
+    alternative?: string;
+    /**
+     * assumed correlation under H0 (equal to the supplied `rho` option).
+     * */
+    nullValue?: number;
+};
+export type ChangePointItem = {
+    index: number;
+    significance: number;
+};

package/lib/data/statistics/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,15 @@
+/** operation of vector or matrix */
+export declare const vectorAdd: (x: number[], y: number[]) => number[];
+export declare const vectorSubtract: (x: number[], y: number[]) => number[];
+export declare const vectorInnerProduct: (x: number[], y: number[]) => number;
+export declare const matrixTranspose: (x: number[][]) => any[];
+export declare const matrixMultiply: (x: number[][], y: number[][]) => number[][];
+export declare const multiMatrixMultiply: (matrixSet: number[][][]) => number[][];
+/**
+ * Constructs a diagonal matrix where the values of the main diagonal are the values of the given vector
+ */
+export declare const constructDiagonalMatrix: (diagonalVector: number[]) => any[][];
+/**
+ * Calculate the inverse matrix for second order matrix
+ * */
+export declare const inverseSecondOrderMatrix: (matrix: number[][]) => number[][];

package/lib/data/statistics/vector.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inverseSecondOrderMatrix = exports.constructDiagonalMatrix = exports.multiMatrixMultiply = exports.matrixMultiply = exports.matrixTranspose = exports.vectorInnerProduct = exports.vectorSubtract = exports.vectorAdd = void 0;
+/** operation of vector or matrix */
+var vectorAdd = function (x, y) {
+    if (x.length !== y.length)
+        return null;
+    return x.map(function (xi, i) { return xi + y[i]; });
+};
+exports.vectorAdd = vectorAdd;
+var vectorSubtract = function (x, y) {
+    if (x.length !== y.length)
+        return null;
+    return x.map(function (xi, i) { return xi - y[i]; });
+};
+exports.vectorSubtract = vectorSubtract;
+var vectorInnerProduct = function (x, y) {
+    if (x.length !== y.length)
+        return null;
+    var result = 0;
+    x.forEach(function (xi, i) {
+        result += xi * y[i];
+    });
+    return result;
+};
+exports.vectorInnerProduct = vectorInnerProduct;
+var matrixTranspose = function (x) {
+    var result = [];
+    var _loop_1 = function (j) {
+        result.push(x.map(function (xi) { return xi[j]; }));
+    };
+    for (var j = 0; j < x[0].length; j += 1) {
+        _loop_1(j);
+    }
+    return result;
+};
+exports.matrixTranspose = matrixTranspose;
+var matrixMultiply = function (x, y) {
+    var _a;
+    if (((_a = x[0]) === null || _a === void 0 ? void 0 : _a.length) !== y.length)
+        return null;
+    var result = [];
+    var yT = (0, exports.matrixTranspose)(y);
+    x.forEach(function (xi) { return result.push(yT.map(function (yj) { return (0, exports.vectorInnerProduct)(xi, yj); })); });
+    return result;
+};
+exports.matrixMultiply = matrixMultiply;
+var multiMatrixMultiply = function (matrixSet) {
+    var result = matrixSet[0];
+    for (var i = 1; i < matrixSet.length; i += 1) {
+        result = (0, exports.matrixMultiply)(result, matrixSet[i]);
+    }
+    return result;
+};
+exports.multiMatrixMultiply = multiMatrixMultiply;
+/**
+ * Constructs a diagonal matrix where the values of the main diagonal are the values of the given vector
+ */
+var constructDiagonalMatrix = function (diagonalVector) {
+    return diagonalVector.map(function (diagonalValue, i) {
+        // ith row
+        var row = Array(diagonalVector.length).fill(0);
+        row[i] = diagonalValue;
+        return row;
+    });
+};
+exports.constructDiagonalMatrix = constructDiagonalMatrix;
+/**
+ * Calculate the inverse matrix for second order matrix
+ * */
+var inverseSecondOrderMatrix = function (matrix) {
+    var determinant = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
+    return [
+        [matrix[1][1] / determinant, -matrix[0][1] / determinant],
+        [-matrix[1][0] / determinant, matrix[0][0] / determinant],
+    ];
+};
+exports.inverseSecondOrderMatrix = inverseSecondOrderMatrix;

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

@@ -0,0 +1,12 @@
+import { ChangePointItem } from './types';
+/**
+ * Window-based change point detection
+ */
+export declare function windowBasedMean(data: number[], params?: {
+    windowSize?: number;
+    significanceLimit?: number;
+}): ChangePointItem[];
+/**
+ * Window-based change point test
+ */
+export declare function calcPValue(data: number[], index: number, window?: number): number;

package/lib/data/statistics/window.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calcPValue = exports.windowBasedMean = void 0;
+var lodash_1 = require("lodash");
+var constant_1 = require("../../insight/constant");
+var util_1 = require("../../insight/insights/util");
+var DEFAULT_WINDOW_SIZE = 4;
+/**
+ * Window-based change point detection
+ */
+function windowBasedMean(data, params) {
+    var len = data === null || data === void 0 ? void 0 : data.length;
+    var K = (params === null || params === void 0 ? void 0 : params.windowSize) || DEFAULT_WINDOW_SIZE;
+    if (len <= 2 * K + 3)
+        return [];
+    var significanceLimit = (params === null || params === void 0 ? void 0 : params.significanceLimit) || constant_1.SIGNIFICANCE_BENCHMARK;
+    var diff = Array(len).fill(0);
+    for (var i = K; i <= len - K; i += 1) {
+        var meanLeft = (0, lodash_1.mean)(data.slice(i - K, i));
+        var meanRight = (0, lodash_1.mean)(data.slice(i, i + K));
+        diff[i] = Math.abs(meanLeft - meanRight);
+    }
+    var differences = diff.slice(K, len - K + 1);
+    var sorted = differences.sort(function (a, b) { return b - a; });
+    var result = [];
+    var _loop_1 = function (i) {
+        var difference = sorted[i];
+        var index = diff.findIndex(function (item) { return item === difference; });
+        var significance = 1 - (0, util_1.calculatePValue)(differences, difference);
+        if (significance >= significanceLimit) {
+            result.push({
+                index: index,
+                significance: significance,
+            });
+        }
+    };
+    for (var i = 0; i < sorted.length; i += 1) {
+        _loop_1(i);
+    }
+    return result;
+}
+exports.windowBasedMean = windowBasedMean;
+/**
+ * Window-based change point test
+ */
+function calcPValue(data, index, window) {
+    var len = data === null || data === void 0 ? void 0 : data.length;
+    var K = window || DEFAULT_WINDOW_SIZE;
+    if (len <= 2 * K + 3)
+        return 0;
+    var diff = Array(len).fill(0);
+    for (var i = K; i <= len - K; i += 1) {
+        var meanLeft = (0, lodash_1.mean)(data.slice(i - K, i));
+        var meanRight = (0, lodash_1.mean)(data.slice(i, i + K));
+        diff[i] = Math.abs(meanLeft - meanRight);
+    }
+    var p = (0, util_1.calculatePValue)(diff.slice(K, len - K + 1), diff[index]);
+    return p;
+}
+exports.calcPValue = calcPValue;

package/lib/data/types.d.ts

@@ -0,0 +1,2 @@
+export * from './analysis/types';
+export * from './dataset/types';

package/lib/data/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./analysis/types"), exports);
+tslib_1.__exportStar(require("./dataset/types"), exports);