lakutata/src/lib/helpers/Statistics.cjs

An IoC-based universal application framework.

"use strict";

Object.defineProperty(exports, Symbol.toStringTag, {
    value: "Module"
});

const t = require("../../../vendor/Package.16.cjs");

class Statistics {
    static {
        this.epsilon = t.epsilon;
    }
    static min(e) {
        return t.min(e);
    }
    static max(e) {
        return t.max(e);
    }
    static sum(e) {
        return t.sum(e);
    }
    static quantile(e, a) {
        return t.quantile(e, a);
    }
    static product(e) {
        return t.product(e);
    }
    static mean(e) {
        return t.mean(e);
    }
    static average(e) {
        return t.mean(e);
    }
    static addToMean(e, a, r) {
        return t.addToMean(e, a, r);
    }
    static addToAverage(e, a, r) {
        return t.addToMean(e, a, r);
    }
    static mode(e) {
        return t.mode(e);
    }
    static median(e) {
        return t.median(e);
    }
    static harmonicMean(e) {
        return t.harmonicMean(e);
    }
    static geometricMean(e) {
        return t.geometricMean(e);
    }
    static rootMeanSquare(e) {
        return t.rootMeanSquare(e);
    }
    static sampleSkewness(e) {
        return t.sampleSkewness(e);
    }
    static variance(e) {
        return t.variance(e);
    }
    static sampleVariance(e) {
        return t.sampleVariance(e);
    }
    static standardDeviation(e) {
        return t.standardDeviation(e);
    }
    static sampleStandardDeviation(e) {
        return t.sampleStandardDeviation(e);
    }
    static medianAbsoluteDeviation(e) {
        return t.medianAbsoluteDeviation(e);
    }
    static interquartileRange(e) {
        return t.interquartileRange(e);
    }
    static sumNthPowerDeviations(e, a) {
        return t.sumNthPowerDeviations(e, a);
    }
    static zScore(e, a, r) {
        return t.zScore(e, a, r);
    }
    static correlation(e, a) {
        return t.sampleCorrelation(e, a);
    }
    static sampleCovariance(e, a) {
        return t.sampleCovariance(e, a);
    }
    static rSquared(e) {
        return t.rSquared(e, this.linearRegressionLine(this.linearRegression(e)));
    }
    static linearRegression(e) {
        return t.linearRegression(e);
    }
    static linearRegressionLine(e) {
        return t.linearRegressionLine(e);
    }
    static shuffle(e) {
        return t.shuffle(e);
    }
    static sampleWithReplacement(e, a) {
        return t.sampleWithReplacement(e, a);
    }
    static sample(e, a) {
        return t.sample(e, a, Math.random);
    }
    static randomPickOne(t) {
        return this.sample(t, 1)[0];
    }
    static randomPickMany(t, e) {
        return this.sample(t, e);
    }
    static bernoulliDistribution(e) {
        return t.bernoulliDistribution(e);
    }
    static binomialDistribution(e, a) {
        return t.binomialDistribution(e, a);
    }
    static poissonDistribution(e) {
        return t.poissonDistribution(e);
    }
    static tTest(e, a) {
        return t.tTest(e, a);
    }
    static tTestTwoSample(e, a, r = 0) {
        return t.tTestTwoSample(e, a, r);
    }
    static chunk(e, a) {
        return t.chunk(e, a);
    }
    static factorial(e) {
        return t.factorial(e);
    }
    static gamma(e) {
        return t.gamma(e);
    }
    static approxEqual(e, a, r) {
        return t.approxEqual(e, a, r);
    }
    static bisect(e, a, r, i, n) {
        return t.bisect(e, a, r, i, n);
    }
    static coefficientOfVariation(e) {
        return t.coefficientOfVariation(e);
    }
    static combinationsReplacement(e, a) {
        return t.combinationsReplacement(e, a);
    }
    static combinations(e, a) {
        return t.combinations(e, a);
    }
    static combineMeans(e, a, r, i) {
        return t.combineMeans(e, a, r, i);
    }
    static combineVariances(e, a, r, i, n, s) {
        return t.combineVariances(e, a, r, i, n, s);
    }
    static cumulativeStdLogisticProbability(e) {
        return t.cumulativeStdLogisticProbability(e);
    }
    static extent(e) {
        return t.extent(e);
    }
    static gammaln(e) {
        return t.gammaln(e);
    }
    static jenks(e, a) {
        return t.jenks(e, a);
    }
    static logAverage(e) {
        return t.logAverage(e);
    }
    static logit(e) {
        return t.logit(e);
    }
    static probit(e) {
        return t.probit(e);
    }
    static quantileRank(e, a) {
        return t.quantileRank(e, a);
    }
    static quickselect(e, a, r, i) {
        const n = [ ...e ];
        t.quickselect(n, a, r, i);
        return n;
    }
    static subtractFromMean(e, a, r) {
        return t.subtractFromMean(e, a, r);
    }
    static subtractFromAverage(e, a, r) {
        return t.subtractFromMean(e, a, r);
    }
}

exports.Statistics = Statistics;