@formant/ava 3.4.1-formant

package/esm/data/statistics/base.js

@@ -0,0 +1,248 @@
+/*
+ * Statistical methods used internally by ava.
+ */
+import { __read, __spreadArray } from "tslib";
+import { assert } from '../utils';
+import * as cache from './caches';
+/**
+ * Get the minimum of the array.
+ * @param value - The array to process
+ */
+export function min(value) {
+    var cachedValue = cache.get(value, 'min');
+    if (cachedValue !== undefined)
+        return cachedValue;
+    return cache.set(value, 'min', Math.min.apply(Math, __spreadArray([], __read(value), false)));
+}
+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
+ */
+export function minIndex(value) {
+    var cachedValue = cache.get(value, 'minIndex');
+    if (cachedValue !== undefined)
+        return cachedValue;
+    return cache.set(value, 'minIndex', getMinIndex(value));
+}
+/**
+ * Get the maximum of the array.
+ * @param value - The array to process
+ */
+export function max(value) {
+    var cachedValue = cache.get(value, 'max');
+    if (cachedValue !== undefined)
+        return cachedValue;
+    return cache.set(value, 'max', Math.max.apply(Math, __spreadArray([], __read(value), false)));
+}
+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
+ */
+export function maxIndex(value) {
+    var cachedValue = cache.get(value, 'maxIndex');
+    if (cachedValue !== undefined)
+        return cachedValue;
+    return cache.set(value, 'maxIndex', getMaxIndex(value));
+}
+/**
+ * Calculate the sum of the array.
+ * @param value - The array to process
+ */
+export 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));
+}
+/**
+ * Calculate the mean of the array.
+ * @param value - The array to process
+
+ */
+export function mean(value) {
+    return sum(value) / value.length;
+}
+/**
+ * Calculate the geometricMean of the array.
+ * @param value - The array to process
+ */
+export function geometricMean(value) {
+    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)));
+}
+/**
+ * Calculate the harmonic mean of the array.
+ * @param value - The array to process
+ */
+export 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));
+}
+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
+ */
+export 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;
+}
+/**
+ * Calculate the quartile of the array.
+ * @param value - The array to process
+ * @param sorted - Whether it is sorted
+ */
+export function quartile(value, sorted) {
+    if (sorted === void 0) { sorted = false; }
+    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];
+}
+/**
+ * Calculate the quantile of the array.
+ * @param value - The array to process
+ * @param percent - percent
+ * @param sorted - Whether it is sorted
+ */
+export function quantile(value, percent, sorted) {
+    if (sorted === void 0) { sorted = false; }
+    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];
+}
+/**
+ * Calculate the variance of the array.
+ * @param value - The array to process
+ */
+export 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);
+}
+/**
+ * Calculate the standard deviation of the array.
+ * @param value - The array to process
+ */
+export function standardDeviation(value) {
+    return Math.sqrt(variance(value));
+}
+/**
+ * Calculate the coefficient of variance of the array.
+ * @param value - The array to process
+ */
+export function coefficientOfVariance(value) {
+    var stdev = standardDeviation(value);
+    var arrayMean = mean(value);
+    return stdev / arrayMean;
+}
+/**
+ * Calculate the covariance of the array.
+ * @param x - variable x
+ * @param y - variable y
+ */
+export function covariance(x, y) {
+    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);
+}
+/**
+ * Calculate the pearson correlation coefficient of two value.
+ * @param x - variable x
+ * @param y - variable y
+ */
+export function pearson(x, y) {
+    var cov = covariance(x, y);
+    var dx = standardDeviation(x);
+    var dy = standardDeviation(y);
+    return cov / (dx * dy);
+}
+/**
+ * Calculate the counts of valid value in the array.
+ * @param value - The array to process
+ */
+export function valid(value) {
+    var count = 0;
+    for (var i = 0; i < value.length; i += 1) {
+        if (value[i])
+            count += 1;
+    }
+    return count;
+}
+/**
+ * Calculate the counts of missing value in the array.
+ * @param value - The array to process
+ */
+export function missing(value) {
+    return value.length - valid(value);
+}
+/**
+ * Calculate the counts of each distinct value in the array.
+ * @param value - The array to process
+ */
+export 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;
+}
+/**
+ * Calculate the counts of distinct value in the array.
+ * @param value - The array to process
+ */
+export function distinct(value) {
+    return Object.keys(valueMap(value)).length;
+}

package/esm/data/statistics/bayesian.js

@@ -0,0 +1,25 @@
+import BayesianChangePoint from 'bayesian-changepoint';
+import { calcPValue } from './pettitt-test';
+function breakpointVerifier(next, prev) {
+    if (Math.abs(next.data - prev.data) >= 1) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Bayesian Online Changepoint Detection
+ */
+export function bayesian(series) {
+    if (series === void 0) { series = []; }
+    var detection = new BayesianChangePoint({
+        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 - calcPValue(series, breakPoint.index),
+    }); });
+    return result;
+}

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

@@ -0,0 +1,19 @@
+import { sumBy, sum, mean } from 'lodash';
+import { maxabs } from '..';
+import { calcPValue } from './window';
+/**
+ * Buishad U statistics test
+ */
+export function buishandUTest(data) {
+    var n = data === null || data === void 0 ? void 0 : data.length;
+    var meanValue = mean(data);
+    var Sk = data.map(function (_, index) { return sum(data.slice(0, index + 1)) - meanValue * (index + 1); });
+    var U = sumBy(Sk.slice(0, n - 1), function (item) { return Math.pow(item, 2); }) / (n * (n + 1));
+    var Smax = maxabs(Sk);
+    var maxIndex = Sk.findIndex(function (item) { return item === Smax; });
+    return {
+        uValue: U,
+        index: maxIndex,
+        significance: 1 - calcPValue(data, maxIndex),
+    };
+}

package/esm/data/statistics/caches.js

@@ -0,0 +1,28 @@
+/**
+ * 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
+ */
+export function set(target, key, value) {
+    if (!CACHES.get(target)) {
+        CACHES.set(target, new Map());
+    }
+    CACHES.get(target).set(key, value);
+    return value;
+}
+/**
+ * Get the cached value for target and key.
+ * @param target - target
+ * @param key - key
+ */
+export function get(target, key) {
+    var cache = CACHES.get(target);
+    if (!cache)
+        return undefined;
+    return cache.get(key);
+}

package/esm/data/statistics/cdf.js

@@ -0,0 +1,25 @@
+import { isNil } from '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
+ * */
+export 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 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;
+};

package/esm/data/statistics/constants.js

@@ -0,0 +1,12 @@
+/** default options in LOWESS */
+export var DEFAULT_LOWESS_OPTIONS = {
+    f: 2 / 3,
+    nSteps: 3,
+    delta: null,
+};
+/** default options in LOWESS */
+export var DEFAULT_PCORRTEST_OPTIONS = {
+    alpha: 0.05,
+    alternative: 'two-sided',
+    rho: 0,
+};

package/esm/data/statistics/index.js

@@ -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/esm/data/statistics/lowess.js

@@ -0,0 +1,80 @@
+import { isNumber, mergeWith } from 'lodash';
+import { nOnes, nZeros } from '../utils';
+import { median } from './base';
+import { DEFAULT_LOWESS_OPTIONS } from './constants';
+import { constructDiagonalMatrix, inverseSecondOrderMatrix, matrixTranspose, multiMatrixMultiply, vectorSubtract, } from './vector';
+export var tricubeWeightFunction = function (x) {
+    if (!isNumber(x) || Math.abs(x) >= 1)
+        return 0;
+    return Math.pow((1 - Math.pow(Math.abs(x), 3)), 3);
+};
+export var bisquareWeightFunction = function (x) {
+    if (!isNumber(x) || Math.abs(x) >= 1)
+        return 0;
+    return Math.pow((1 - Math.pow(x, 2)), 2);
+};
+export var weightedLinearRegression = function (x, y, w) {
+    /** dimension: 2*n */
+    var xt = [nOnes(x.length), x];
+    /** dimension: n*2 */
+    var xMatrix = matrixTranspose(xt);
+    /** dimension: n*1 */
+    var yMatrix = matrixTranspose([y]);
+    /** diagonal matrix with w as the main diagonal */
+    var wMatrix = constructDiagonalMatrix(w);
+    /**
+     * (X^(T)wX)^(-1)
+     * - 2*n, n*n, n*2 => 2*2
+     * */
+    var factor = inverseSecondOrderMatrix(multiMatrixMultiply([xt, wMatrix, xMatrix]));
+    /**
+     * (X^(T)wX)^(-1) X^(T)wY
+     * - 2*2, 2*n, n*1 => 2*1
+     * */
+    return multiMatrixMultiply([factor, xt, wMatrix, yMatrix]);
+};
+/**
+ * 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 var lowess = function (x, y, options) {
+    var xLength = x.length;
+    var mergeOptions = mergeWith(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 tricubeWeightFunction((xk - xi) / h[i]); });
+    });
+    var robustCoefficient = nOnes(xLength);
+    /** fitted values */
+    var yFit = 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 = weightedLinearRegression(x, y, robustWeight);
+            yFit[i] = beta[0][0] + beta[1][0] * x[i];
+        }
+        var residuals = vectorSubtract(y, yFit);
+        /** median of |residuals| */
+        var s = median(residuals.map(function (res) { return Math.abs(res); }));
+        residuals.forEach(function (res, i) {
+            robustCoefficient[i] = bisquareWeightFunction(res / (6 * s));
+        });
+    };
+    for (var iter = 0; iter < mergeOptions.nSteps; iter += 1) {
+        _loop_1(iter);
+    }
+    return {
+        y: yFit,
+    };
+};

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

@@ -0,0 +1,50 @@
+import { __read } from "tslib";
+import { sumBy } from 'lodash';
+import { sign, unique } from '../../insight/utils/common';
+import { normalDistributionQuantile, cdf } from '..';
+/**
+ * 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 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 += sign(data[j] - data[k]);
+        }
+    }
+    var _a = __read(unique(data), 2), uniqArr = _a[0], uniqCount = _a[1];
+    var uniqLength = uniqArr.length;
+    var varS = (length * (length - 1) * (2 * length + 5) -
+        (uniqLength === length ? 0 : 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 - cdf(Math.abs(zScore), 0, 1));
+    var h = Math.abs(zScore) > 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,
+    };
+}

package/esm/data/statistics/maxabs.js

@@ -0,0 +1,9 @@
+import { __read, __spreadArray } from "tslib";
+/**
+ * Returns the maximum absolute value of array
+ * @param x input array
+ * */
+export var maxabs = function (x) {
+    var absoluteX = x.map(function (value) { return Math.abs(value); });
+    return Math.max.apply(Math, __spreadArray([], __read(absoluteX), false));
+};

package/esm/data/statistics/pcorrtest.js

@@ -0,0 +1,76 @@
+import { mergeWith } from 'lodash';
+import { pearson } from './base';
+import { DEFAULT_PCORRTEST_OPTIONS } from './constants';
+import { normalDistributionQuantile, tDistributionQuantile } from './quantile';
+/** Perform a Pearson product-moment correlation test between paired samples  */
+export 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 = mergeWith(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 = 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 = normalDistributionQuantile(1 - alpha);
+            if (statistic >= threshold)
+                rejected = true;
+        }
+        else if (alternative === 'less') {
+            threshold = normalDistributionQuantile(alpha);
+            if (statistic <= threshold)
+                rejected = true;
+        }
+        else {
+            threshold = 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 = tDistributionQuantile(1 - alpha, degree);
+            if (statistic >= threshold)
+                rejected = true;
+        }
+        else if (alternative === 'less') {
+            threshold = tDistributionQuantile(alpha, degree);
+            if (statistic <= threshold)
+                rejected = true;
+        }
+        else {
+            threshold = tDistributionQuantile(1 - alpha / 2, degree);
+            if (Math.abs(statistic) >= threshold)
+                rejected = true;
+        }
+    }
+    return {
+        rejected: rejected,
+        pcorr: pcorr,
+    };
+};

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

@@ -0,0 +1,33 @@
+import { sumBy } from 'lodash';
+import { rank } from '../../insight/utils/common';
+/**
+ * Pettitt's (1979) method is a rank-based nonparametric test for abrupt changes in a time series.
+ * */
+export function pettittTest(data) {
+    var n = data === null || data === void 0 ? void 0 : data.length;
+    var rankArr = rank(data);
+    var Umax = 0;
+    var UmaxIndex = -1;
+    for (var k = 0; k < n; k += 1) {
+        var U = Math.abs(2 * 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,
+    };
+}
+/**
+ * p-value calc in Pettitt
+ */
+export function calcPValue(data, index) {
+    var n = data === null || data === void 0 ? void 0 : data.length;
+    var rankArr = rank(data);
+    var U = Math.abs(2 * 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;
+}

package/esm/data/statistics/quantile.js

@@ -0,0 +1,56 @@
+/**
+ * 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 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;
+};
+/**
+ * student's t distribution quantile function
+ * @param p probability
+ * @param v degree of freedom
+ */
+export 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 = 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));
+};

package/esm/data/statistics/types.js

@@ -0,0 +1 @@
+export {};