@syncfusion/ej2-calculate 35.1.37

package/src/formulas/statistical-distribution-extended.js

@@ -0,0 +1,668 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { FormulasErrorsStrings, CommonErrors } from '../common/index';
+import { isNullOrUndefined } from '@syncfusion/ej2-base';
+import { StatisticalSampleBase } from './statistical-sample-base';
+import { binomialCoeff, gamma, normCDF, chiSquareCDF, chiSquareInv, fCDF, fInv, logNormCDF, logNormInv, lowerRegularizedGamma } from './formula-math-helpers';
+/**
+ * Extended distribution library covering additional continuous and discrete probability models.
+ *
+ * Registers 15 functions including CRITBINOM, NEGBINOMDIST, HYPGEOMDIST, WEIBULL, LOGNORMDIST, and others.
+ *
+ * @hidden
+ */
+var StatisticalDistributionExtendedFormulas = /** @class */ (function (_super) {
+    __extends(StatisticalDistributionExtendedFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function StatisticalDistributionExtendedFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'CRITBINOM', category: 'Statistical', description: 'Returns the smallest value for which the cumulative binomial distribution is less than or equal to a criterion value.' },
+            { formulaName: 'NEGBINOMDIST', category: 'Statistical', description: 'Returns the negative binomial distribution.' },
+            { formulaName: 'HYPGEOMDIST', category: 'Statistical', description: 'Returns the hypergeometric distribution.' },
+            { formulaName: 'WEIBULL', category: 'Statistical', description: 'Returns the Weibull distribution.' },
+            { formulaName: 'LOGNORMDIST', category: 'Statistical', description: 'Returns the cumulative log-normal distribution.' },
+            { formulaName: 'LOGINV', category: 'Statistical', description: 'Returns the inverse of the log-normal cumulative distribution.' },
+            { formulaName: 'GAMMADIST', category: 'Statistical', description: 'Returns the gamma distribution.' },
+            { formulaName: 'GAMMAINV', category: 'Statistical', description: 'Returns the inverse of the gamma cumulative distribution.' },
+            { formulaName: 'CHIDIST', category: 'Statistical', description: 'Returns the one-tailed probability of the chi-squared distribution.' },
+            { formulaName: 'CHIINV', category: 'Statistical', description: 'Returns the inverse of the one-tailed probability of the chi-squared distribution.' },
+            { formulaName: 'CHITEST', category: 'Statistical', description: 'Returns the test for independence.' },
+            { formulaName: 'FDIST', category: 'Statistical', description: 'Returns the F probability distribution.' },
+            { formulaName: 'FINV', category: 'Statistical', description: 'Returns the inverse of the F probability distribution.' },
+            { formulaName: 'ZTEST', category: 'Statistical', description: 'Returns the one-tailed probability-value of a z-test.' },
+            { formulaName: 'PROB', category: 'Statistical', description: 'Returns the probability that values in a range are between two limits.' }
+        ];
+        return _this;
+    }
+    StatisticalDistributionExtendedFormulas.prototype.parseCumulative = function (args, index) {
+        if (args.length <= index) {
+            return true;
+        }
+        var cum = this.resolveNumberArg(args[index]);
+        if (typeof cum === 'string') {
+            return cum;
+        }
+        return cum !== 0;
+    };
+    /**
+     * Returns the smallest value for which the cumulative binomial distribution is less than or equal to a criterion value.
+     *
+     * Excel: `CRITBINOM(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     *
+     * @example
+     * ```ts
+     * engine.computeFormula('=CRITBINOM(1)');
+     * ```
+     */
+    StatisticalDistributionExtendedFormulas.prototype.ComputeCRITBINOM = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length !== 3) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var trials = this.resolveNumberArg(args[0]);
+        var prob = this.resolveNumberArg(args[1]);
+        var alpha = this.resolveNumberArg(args[2]);
+        if (typeof trials === 'string') {
+            return trials;
+        }
+        if (typeof prob === 'string') {
+            return prob;
+        }
+        if (typeof alpha === 'string') {
+            return alpha;
+        }
+        var n = Math.floor(trials);
+        var p = prob;
+        if (n < 0 || p < 0 || p > 1 || alpha < 0 || alpha > 1) {
+            return errCollection[CommonErrors.Num];
+        }
+        var cum = 0;
+        for (var k = 0; k <= n; k++) {
+            cum += binomialCoeff(n, k) * Math.pow(p, k) * Math.pow(1 - p, n - k);
+            if (cum >= alpha) {
+                return k.toString();
+            }
+        }
+        return n.toString();
+    };
+    /**
+     * Returns the negative binomial distribution.
+     *
+     * Excel: `NEGBINOMDIST(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    StatisticalDistributionExtendedFormulas.prototype.ComputeNEGBINOMDIST = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length !== 3) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var failures = this.resolveNumberArg(args[0]);
+        var successes = this.resolveNumberArg(args[1]);
+        var prob = this.resolveNumberArg(args[2]);
+        if (typeof failures === 'string') {
+            return failures;
+        }
+        if (typeof successes === 'string') {
+            return successes;
+        }
+        if (typeof prob === 'string') {
+            return prob;
+        }
+        var f = Math.floor(failures);
+        var s = Math.floor(successes);
+        if (f < 0 || s < 1 || prob <= 0 || prob > 1) {
+            return errCollection[CommonErrors.Num];
+        }
+        var result = binomialCoeff(f + s - 1, s - 1) * Math.pow(prob, s) * Math.pow(1 - prob, f);
+        return result.toString();
+    };
+    /**
+     * Returns the hypergeometric distribution.
+     *
+     * Excel: `HYPGEOMDIST(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    StatisticalDistributionExtendedFormulas.prototype.ComputeHYPGEOMDIST = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length < 4 || args.length > 5) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var sampleS = this.resolveNumberArg(args[0]);
+        var numSample = this.resolveNumberArg(args[1]);
+        var popS = this.resolveNumberArg(args[2]);
+        var numPop = this.resolveNumberArg(args[3]);
+        if (typeof sampleS === 'string') {
+            return sampleS;
+        }
+        if (typeof numSample === 'string') {
+            return numSample;
+        }
+        if (typeof popS === 'string') {
+            return popS;
+        }
+        if (typeof numPop === 'string') {
+            return numPop;
+        }
+        var x = Math.floor(sampleS);
+        var n = Math.floor(numSample);
+        var M = Math.floor(popS);
+        var N = Math.floor(numPop);
+        if (x < 0 || x > n || n > N || M > N) {
+            return errCollection[CommonErrors.Num];
+        }
+        var cumulative = this.parseCumulative(args, 4);
+        if (typeof cumulative === 'string') {
+            return cumulative;
+        }
+        var pmf = (binomialCoeff(M, x) * binomialCoeff(N - M, n - x)) / binomialCoeff(N, n);
+        if (!cumulative) {
+            return pmf.toString();
+        }
+        var sum = 0;
+        for (var i = 0; i <= x; i++) {
+            sum += (binomialCoeff(M, i) * binomialCoeff(N - M, n - i)) / binomialCoeff(N, n);
+        }
+        return sum.toString();
+    };
+    /**
+     * Returns the Weibull distribution.
+     *
+     * Excel: `WEIBULL(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    StatisticalDistributionExtendedFormulas.prototype.ComputeWEIBULL = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length < 3 || args.length > 4) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var x = this.resolveNumberArg(args[0]);
+        var alpha = this.resolveNumberArg(args[1]);
+        var beta = this.resolveNumberArg(args[2]);
+        if (typeof x === 'string') {
+            return x;
+        }
+        if (typeof alpha === 'string') {
+            return alpha;
+        }
+        if (typeof beta === 'string') {
+            return beta;
+        }
+        if (x < 0 || alpha <= 0 || beta <= 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var cumulative = this.parseCumulative(args, 3);
+        if (typeof cumulative === 'string') {
+            return cumulative;
+        }
+        if (cumulative) {
+            return (1 - Math.exp(-Math.pow(x / beta, alpha))).toString();
+        }
+        return ((alpha / Math.pow(beta, alpha)) * Math.pow(x, alpha - 1) * Math.exp(-Math.pow(x / beta, alpha))).toString();
+    };
+    /**
+     * Returns the cumulative log-normal distribution.
+     *
+     * Excel: `LOGNORMDIST(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    StatisticalDistributionExtendedFormulas.prototype.ComputeLOGNORMDIST = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 3) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var x = this.resolveNumberArg(args[0]);
+        var mean = this.resolveNumberArg(args[1]);
+        var std = this.resolveNumberArg(args[2]);
+        if (typeof x === 'string') {
+            return x;
+        }
+        if (typeof mean === 'string') {
+            return mean;
+        }
+        if (typeof std === 'string') {
+            return std;
+        }
+        var result = logNormCDF(x, mean, std);
+        if (isNaN(result)) {
+            return this.parent.getErrorStrings()[CommonErrors.Num];
+        }
+        return result.toString();
+    };
+    /**
+     * Returns the inverse of the log-normal cumulative distribution.
+     *
+     * Excel: `LOGINV(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    StatisticalDistributionExtendedFormulas.prototype.ComputeLOGINV = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 3) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var p = this.resolveNumberArg(args[0]);
+        var mean = this.resolveNumberArg(args[1]);
+        var std = this.resolveNumberArg(args[2]);
+        if (typeof p === 'string') {
+            return p;
+        }
+        if (typeof mean === 'string') {
+            return mean;
+        }
+        if (typeof std === 'string') {
+            return std;
+        }
+        var result = logNormInv(p, mean, std);
+        if (isNaN(result)) {
+            return this.parent.getErrorStrings()[CommonErrors.Num];
+        }
+        return result.toString();
+    };
+    /**
+     * Returns the gamma distribution.
+     *
+     * Excel: `GAMMADIST(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    StatisticalDistributionExtendedFormulas.prototype.ComputeGAMMADIST = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length < 3 || args.length > 4) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var x = this.resolveNumberArg(args[0]);
+        var alpha = this.resolveNumberArg(args[1]);
+        var beta = this.resolveNumberArg(args[2]);
+        if (typeof x === 'string') {
+            return x;
+        }
+        if (typeof alpha === 'string') {
+            return alpha;
+        }
+        if (typeof beta === 'string') {
+            return beta;
+        }
+        if (x < 0 || alpha <= 0 || beta <= 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var cumulative = this.parseCumulative(args, 3);
+        if (typeof cumulative === 'string') {
+            return cumulative;
+        }
+        var scaled = x / beta;
+        if (cumulative) {
+            return lowerRegularizedGamma(alpha, scaled).toString();
+        }
+        return (Math.pow(scaled, alpha - 1) * Math.exp(-scaled) / (beta * gamma(alpha))).toString();
+    };
+    /**
+     * Returns the inverse of the gamma cumulative distribution.
+     *
+     * Excel: `GAMMAINV(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    StatisticalDistributionExtendedFormulas.prototype.ComputeGAMMAINV = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length !== 3) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var p = this.resolveNumberArg(args[0]);
+        var alpha = this.resolveNumberArg(args[1]);
+        var beta = this.resolveNumberArg(args[2]);
+        if (typeof p === 'string') {
+            return p;
+        }
+        if (typeof alpha === 'string') {
+            return alpha;
+        }
+        if (typeof beta === 'string') {
+            return beta;
+        }
+        if (p <= 0 || p >= 1 || alpha <= 0 || beta <= 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var lo = 0;
+        var hi = alpha * beta * 20 + 1;
+        for (var i = 0; i < 100; i++) {
+            var mid = (lo + hi) / 2;
+            if (lowerRegularizedGamma(alpha, mid / beta) < p) {
+                lo = mid;
+            }
+            else {
+                hi = mid;
+            }
+        }
+        return ((lo + hi) / 2).toString();
+    };
+    /**
+     * Returns the one-tailed probability of the chi-squared distribution.
+     *
+     * Excel: `CHIDIST(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    StatisticalDistributionExtendedFormulas.prototype.ComputeCHIDIST = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var x = this.resolveNumberArg(args[0]);
+        var df = this.resolveNumberArg(args[1]);
+        if (typeof x === 'string') {
+            return x;
+        }
+        if (typeof df === 'string') {
+            return df;
+        }
+        return (1 - chiSquareCDF(x, df)).toString();
+    };
+    /**
+     * Returns the inverse of the one-tailed probability of the chi-squared distribution.
+     *
+     * Excel: `CHIINV(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    StatisticalDistributionExtendedFormulas.prototype.ComputeCHIINV = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var p = this.resolveNumberArg(args[0]);
+        var df = this.resolveNumberArg(args[1]);
+        if (typeof p === 'string') {
+            return p;
+        }
+        if (typeof df === 'string') {
+            return df;
+        }
+        var result = chiSquareInv(1 - p, df);
+        if (isNaN(result)) {
+            return this.parent.getErrorStrings()[CommonErrors.Num];
+        }
+        return result.toString();
+    };
+    /**
+     * Returns the test for independence.
+     *
+     * Excel: `CHITEST(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    StatisticalDistributionExtendedFormulas.prototype.ComputeCHITEST = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.chiSquareTest(args);
+    };
+    StatisticalDistributionExtendedFormulas.prototype.chiSquareTest = function (args) {
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length !== 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var actual = this.collectSample([args[0]], false);
+        var expected = this.collectSample([args[1]], false);
+        if (typeof actual === 'string') {
+            return actual;
+        }
+        if (typeof expected === 'string') {
+            return expected;
+        }
+        if (actual.length !== expected.length || actual.length === 0) {
+            return errCollection[CommonErrors.NA];
+        }
+        var chi2 = 0;
+        for (var i = 0; i < actual.length; i++) {
+            if (expected[i] === 0) {
+                return errCollection[CommonErrors.DivZero];
+            }
+            var d = actual[i] - expected[i];
+            chi2 += (d * d) / expected[i];
+        }
+        var df = actual.length - 1;
+        return (1 - chiSquareCDF(chi2, df)).toString();
+    };
+    /**
+     * Returns the F probability distribution.
+     *
+     * Excel: `FDIST(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    StatisticalDistributionExtendedFormulas.prototype.ComputeFDIST = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 3) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var x = this.resolveNumberArg(args[0]);
+        var d1 = this.resolveNumberArg(args[1]);
+        var d2 = this.resolveNumberArg(args[2]);
+        if (typeof x === 'string') {
+            return x;
+        }
+        if (typeof d1 === 'string') {
+            return d1;
+        }
+        if (typeof d2 === 'string') {
+            return d2;
+        }
+        return (1 - fCDF(x, d1, d2)).toString();
+    };
+    /**
+     * Returns the inverse of the F probability distribution.
+     *
+     * Excel: `FINV(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    StatisticalDistributionExtendedFormulas.prototype.ComputeFINV = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 3) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var p = this.resolveNumberArg(args[0]);
+        var d1 = this.resolveNumberArg(args[1]);
+        var d2 = this.resolveNumberArg(args[2]);
+        if (typeof p === 'string') {
+            return p;
+        }
+        if (typeof d1 === 'string') {
+            return d1;
+        }
+        if (typeof d2 === 'string') {
+            return d2;
+        }
+        var result = fInv(1 - p, d1, d2);
+        if (isNaN(result)) {
+            return this.parent.getErrorStrings()[CommonErrors.Num];
+        }
+        return result.toString();
+    };
+    /**
+     * Returns the one-tailed probability-value of a z-test.
+     *
+     * Excel: `ZTEST(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    StatisticalDistributionExtendedFormulas.prototype.ComputeZTEST = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length < 2 || args.length > 3) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var nums = this.collectSample([args[0]], false);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length < 2) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        var x = this.resolveNumberArg(args[1]);
+        if (typeof x === 'string') {
+            return x;
+        }
+        var avg = this.mean(nums);
+        var sumSq = 0;
+        for (var i = 0; i < nums.length; i++) {
+            var d = nums[i] - avg;
+            sumSq += d * d;
+        }
+        var std = Math.sqrt(sumSq / (nums.length - 1));
+        if (std === 0) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        var sigma = std / Math.sqrt(nums.length);
+        if (args.length === 3) {
+            var s = this.resolveNumberArg(args[2]);
+            if (typeof s === 'string') {
+                return s;
+            }
+            sigma = s / Math.sqrt(nums.length);
+        }
+        var z = (avg - x) / sigma;
+        return (1 - normCDF(z)).toString();
+    };
+    /**
+     * Returns the probability that values in a range are between two limits.
+     *
+     * Excel: `PROB(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    StatisticalDistributionExtendedFormulas.prototype.ComputePROB = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length < 3 || args.length > 4) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var nums = this.collectSample([args[0]], false);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        var low = this.resolveNumberArg(args[1]);
+        var high = this.resolveNumberArg(args[2]);
+        if (typeof low === 'string') {
+            return low;
+        }
+        if (typeof high === 'string') {
+            return high;
+        }
+        if (nums.length === 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var total = 0;
+        var inRange = 0;
+        for (var i = 0; i < nums.length; i++) {
+            total += 1;
+            if (nums[i] >= low && nums[i] <= high) {
+                inRange += 1;
+            }
+        }
+        return (inRange / total).toString();
+    };
+    return StatisticalDistributionExtendedFormulas;
+}(StatisticalSampleBase));
+export { StatisticalDistributionExtendedFormulas };