@syncfusion/ej2-calculate 35.1.37

package/src/formulas/statistical-dispersion.js

@@ -0,0 +1,337 @@
+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 { FormulaModuleBase } from './formula-module-base';
+/**
+ * Variability measures: variance, standard deviation, and average deviation for samples and populations.
+ *
+ * Registered functions: STDEV, STDEVP, VAR, VARP, MODE, RANK, MAXA, MINA.
+ *
+ * @hidden
+ */
+var StatisticalDispersionFormulas = /** @class */ (function (_super) {
+    __extends(StatisticalDispersionFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function StatisticalDispersionFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'STDEV', category: 'Statistical', description: 'Estimates standard deviation based on a sample.' },
+            { formulaName: 'STDEVP', category: 'Statistical', description: 'Calculates standard deviation based on the entire population.' },
+            { formulaName: 'VAR', category: 'Statistical', description: 'Estimates variance based on a sample.' },
+            { formulaName: 'VARP', category: 'Statistical', description: 'Calculates variance based on the entire population.' },
+            { formulaName: 'MODE', category: 'Statistical', description: 'Returns the most common value in a data set.' },
+            { formulaName: 'RANK', category: 'Statistical', description: 'Returns the rank of a number in a list of numbers.' },
+            { formulaName: 'MAXA', category: 'Statistical', description: 'Returns the maximum value in a list of arguments, including text and logicals.' },
+            { formulaName: 'MINA', category: 'Statistical', description: 'Returns the minimum value in a list of arguments, including text and logicals.' }
+        ];
+        return _this;
+    }
+    StatisticalDispersionFormulas.prototype.collectSample = function (args, includeTextAsZero) {
+        var errCollection = this.parent.getErrorStrings();
+        var nums = [];
+        for (var i = 0; i < args.length; i++) {
+            var arg = args[i];
+            if (arg === '') {
+                continue;
+            }
+            if (this.parent.isCellReference(arg) && arg.indexOf(':') > -1) {
+                var cells = this.parent.getCellCollection(arg);
+                var list = Array.isArray(cells) ? cells : [cells];
+                for (var c = 0; c < list.length; c++) {
+                    var val = this.parent.getValueFromArg(list[c]);
+                    if (errCollection.indexOf(val) > -1) {
+                        return val;
+                    }
+                    if (val === '') {
+                        continue;
+                    }
+                    var upper = val.toUpperCase();
+                    if (upper === this.parent.trueValue) {
+                        nums.push(1);
+                    }
+                    else if (upper === this.parent.falseValue) {
+                        nums.push(0);
+                    }
+                    else if (this.parent.isNumber(val)) {
+                        nums.push(this.parent.parseFloat(val));
+                    }
+                    else if (includeTextAsZero) {
+                        nums.push(0);
+                    }
+                }
+            }
+            else {
+                var val = this.parent.getValueFromArg(arg);
+                if (errCollection.indexOf(val) > -1) {
+                    return val;
+                }
+                var upper = val.toUpperCase();
+                if (upper === this.parent.trueValue) {
+                    nums.push(1);
+                }
+                else if (upper === this.parent.falseValue) {
+                    nums.push(0);
+                }
+                else if (val === '') {
+                    continue;
+                }
+                else if (this.parent.isNumber(this.parent.removeTics(val))) {
+                    nums.push(this.parent.parseFloat(this.parent.removeTics(val)));
+                }
+                else if (includeTextAsZero) {
+                    nums.push(0);
+                }
+                else {
+                    return errCollection[CommonErrors.Value];
+                }
+            }
+        }
+        return nums;
+    };
+    StatisticalDispersionFormulas.prototype.variance = function (nums, population) {
+        var mean = nums.reduce(function (a, b) { return a + b; }, 0) / nums.length;
+        var sumSq = 0;
+        for (var i = 0; i < nums.length; i++) {
+            var d = nums[i] - mean;
+            sumSq += d * d;
+        }
+        var denom = population ? nums.length : nums.length - 1;
+        return sumSq / denom;
+    };
+    /**
+     * Estimates standard deviation based on a sample.
+     *
+     * Excel: `STDEV(...)`.
+     *
+     * @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('=STDEV(1)');
+     * ```
+     */
+    StatisticalDispersionFormulas.prototype.ComputeSTDEV = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.stdevVar(args, false, false);
+    };
+    /**
+     * Calculates standard deviation based on the entire population.
+     *
+     * Excel: `STDEVP(...)`.
+     *
+     * @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`.
+     */
+    StatisticalDispersionFormulas.prototype.ComputeSTDEVP = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.stdevVar(args, true, false);
+    };
+    /**
+     * Estimates variance based on a sample.
+     *
+     * Excel: `VAR(...)`.
+     *
+     * @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`.
+     */
+    StatisticalDispersionFormulas.prototype.ComputeVAR = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.stdevVar(args, false, true);
+    };
+    /**
+     * Calculates variance based on the entire population.
+     *
+     * Excel: `VARP(...)`.
+     *
+     * @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`.
+     */
+    StatisticalDispersionFormulas.prototype.ComputeVARP = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.stdevVar(args, true, true);
+    };
+    StatisticalDispersionFormulas.prototype.stdevVar = function (args, population, asVar) {
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || (args.length === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        var nums = this.collectSample(args, false);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length < (population ? 1 : 2)) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        var v = this.variance(nums, population);
+        return (asVar ? v : Math.sqrt(v)).toString();
+    };
+    /**
+     * Returns the most common value in a data set.
+     *
+     * Excel: `MODE(...)`.
+     *
+     * @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`.
+     */
+    StatisticalDispersionFormulas.prototype.ComputeMODE = 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 === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        var nums = this.collectSample(args, false);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length === 0) {
+            return errCollection[CommonErrors.Value];
+        }
+        var counts = new Map();
+        var best = nums[0];
+        var bestCount = 0;
+        for (var i = 0; i < nums.length; i++) {
+            var n = nums[i];
+            var c = (counts.get(n) || 0) + 1;
+            counts.set(n, c);
+            if (c > bestCount) {
+                bestCount = c;
+                best = n;
+            }
+        }
+        if (bestCount < 2) {
+            return errCollection[CommonErrors.NA];
+        }
+        return best.toString();
+    };
+    /**
+     * Returns the rank of a number in a list of numbers.
+     *
+     * Excel: `RANK(...)`.
+     *
+     * @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`.
+     */
+    StatisticalDispersionFormulas.prototype.ComputeRANK = 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 number = this.resolveNumberArg(args[0]);
+        if (typeof number === 'string') {
+            return number;
+        }
+        var nums = this.collectSample([args[1]], false);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        var order = 0;
+        if (args.length === 3 && args[2] !== '') {
+            var o = this.resolveNumberArg(args[2]);
+            if (typeof o === 'string') {
+                return o;
+            }
+            order = o;
+        }
+        var sorted = nums.slice().sort(function (a, b) { return order ? a - b : b - a; });
+        var idx = sorted.indexOf(number);
+        if (idx < 0) {
+            return errCollection[CommonErrors.NA];
+        }
+        return (idx + 1).toString();
+    };
+    /**
+     * Returns the maximum value in a list of arguments, including text and logicals.
+     *
+     * Excel: `MAXA(...)`.
+     *
+     * @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`.
+     */
+    StatisticalDispersionFormulas.prototype.ComputeMAXA = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.minMaxA(args, true);
+    };
+    /**
+     * Returns the minimum value in a list of arguments, including text and logicals.
+     *
+     * Excel: `MINA(...)`.
+     *
+     * @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`.
+     */
+    StatisticalDispersionFormulas.prototype.ComputeMINA = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.minMaxA(args, false);
+    };
+    StatisticalDispersionFormulas.prototype.minMaxA = function (args, isMax) {
+        if (isNullOrUndefined(args) || (args.length === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        var nums = this.collectSample(args, true);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length === 0) {
+            return '0';
+        }
+        var result = nums[0];
+        for (var i = 1; i < nums.length; i++) {
+            if (isMax ? nums[i] > result : nums[i] < result) {
+                result = nums[i];
+            }
+        }
+        return result.toString();
+    };
+    return StatisticalDispersionFormulas;
+}(FormulaModuleBase));
+export { StatisticalDispersionFormulas };

package/src/formulas/statistical-distribution-extended.d.ts

@@ -0,0 +1,176 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { StatisticalSampleBase } from './statistical-sample-base';
+/**
+ * Extended distribution library covering additional continuous and discrete probability models.
+ *
+ * Registers 15 functions including CRITBINOM, NEGBINOMDIST, HYPGEOMDIST, WEIBULL, LOGNORMDIST, and others.
+ *
+ * @hidden
+ */
+export declare class StatisticalDistributionExtendedFormulas extends StatisticalSampleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    private parseCumulative;
+    /**
+     * 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)');
+     * ```
+     */
+    ComputeCRITBINOM(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeNEGBINOMDIST(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeHYPGEOMDIST(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeWEIBULL(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeLOGNORMDIST(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeLOGINV(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeGAMMADIST(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeGAMMAINV(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeCHIDIST(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeCHIINV(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeCHITEST(...args: string[]): string | number;
+    private chiSquareTest;
+    /**
+     * 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`.
+     */
+    ComputeFDIST(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeFINV(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeZTEST(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputePROB(...args: string[]): string | number;
+}