@syncfusion/ej2-calculate 35.1.37

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

@@ -0,0 +1,104 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { StatisticalSampleBase } from './statistical-sample-base';
+/**
+ * Probability density and cumulative distribution functions for common statistical distributions.
+ *
+ * Registered functions: NORMDIST, NORMSDIST, NORMINV, NORMSINV, POISSON, BINOMDIST, EXPONDIST, CONFIDENCE.
+ *
+ * @hidden
+ */
+export declare class StatisticalDistributionFormulas extends StatisticalSampleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns the normal cumulative distribution.
+     *
+     * Excel: `NORMDIST(...)`.
+     *
+     * @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('=NORMDIST(1)');
+     * ```
+     */
+    ComputeNORMDIST(...args: string[]): string | number;
+    /**
+     * Returns the standard normal cumulative distribution.
+     *
+     * Excel: `NORMSDIST(...)`.
+     *
+     * @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`.
+     */
+    ComputeNORMSDIST(...args: string[]): string | number;
+    /**
+     * Returns the inverse of the normal cumulative distribution.
+     *
+     * Excel: `NORMINV(...)`.
+     *
+     * @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`.
+     */
+    ComputeNORMINV(...args: string[]): string | number;
+    /**
+     * Returns the inverse of the standard normal cumulative distribution.
+     *
+     * Excel: `NORMSINV(...)`.
+     *
+     * @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`.
+     */
+    ComputeNORMSINV(...args: string[]): string | number;
+    /**
+     * Returns the Poisson distribution.
+     *
+     * Excel: `POISSON(...)`.
+     *
+     * @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`.
+     */
+    ComputePOISSON(...args: string[]): string | number;
+    /**
+     * Returns the individual term binomial distribution probability.
+     *
+     * Excel: `BINOMDIST(...)`.
+     *
+     * @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`.
+     */
+    ComputeBINOMDIST(...args: string[]): string | number;
+    /**
+     * Returns the exponential distribution.
+     *
+     * Excel: `EXPONDIST(...)`.
+     *
+     * @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`.
+     */
+    ComputeEXPONDIST(...args: string[]): string | number;
+    /**
+     * Returns the confidence interval for a population mean.
+     *
+     * Excel: `CONFIDENCE(...)`.
+     *
+     * @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`.
+     */
+    ComputeCONFIDENCE(...args: string[]): string | number;
+}

package/src/formulas/statistical-distribution.js

@@ -0,0 +1,368 @@
+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 { normCDF, normInv, binomialCoeff, factorial } from './formula-math-helpers';
+/**
+ * Probability density and cumulative distribution functions for common statistical distributions.
+ *
+ * Registered functions: NORMDIST, NORMSDIST, NORMINV, NORMSINV, POISSON, BINOMDIST, EXPONDIST, CONFIDENCE.
+ *
+ * @hidden
+ */
+var StatisticalDistributionFormulas = /** @class */ (function (_super) {
+    __extends(StatisticalDistributionFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function StatisticalDistributionFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'NORMDIST', category: 'Statistical', description: 'Returns the normal cumulative distribution.' },
+            { formulaName: 'NORMSDIST', category: 'Statistical', description: 'Returns the standard normal cumulative distribution.' },
+            { formulaName: 'NORMINV', category: 'Statistical', description: 'Returns the inverse of the normal cumulative distribution.' },
+            { formulaName: 'NORMSINV', category: 'Statistical', description: 'Returns the inverse of the standard normal cumulative distribution.' },
+            { formulaName: 'POISSON', category: 'Statistical', description: 'Returns the Poisson distribution.' },
+            { formulaName: 'BINOMDIST', category: 'Statistical', description: 'Returns the individual term binomial distribution probability.' },
+            { formulaName: 'EXPONDIST', category: 'Statistical', description: 'Returns the exponential distribution.' },
+            { formulaName: 'CONFIDENCE', category: 'Statistical', description: 'Returns the confidence interval for a population mean.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns the normal cumulative distribution.
+     *
+     * Excel: `NORMDIST(...)`.
+     *
+     * @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('=NORMDIST(1)');
+     * ```
+     */
+    StatisticalDistributionFormulas.prototype.ComputeNORMDIST = 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 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;
+        }
+        if (std <= 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var cumulative = true;
+        if (args.length === 4) {
+            var cumArg = this.resolveNumberArg(args[3]);
+            if (typeof cumArg === 'string') {
+                return cumArg;
+            }
+            cumulative = cumArg !== 0;
+        }
+        if (cumulative) {
+            return normCDF(x, mean, std).toString();
+        }
+        var z = (x - mean) / std;
+        return (Math.exp(-0.5 * z * z) / (std * Math.sqrt(2 * Math.PI))).toString();
+    };
+    /**
+     * Returns the standard normal cumulative distribution.
+     *
+     * Excel: `NORMSDIST(...)`.
+     *
+     * @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`.
+     */
+    StatisticalDistributionFormulas.prototype.ComputeNORMSDIST = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var z = this.resolveNumberArg(args[0]);
+        if (typeof z === 'string') {
+            return z;
+        }
+        return normCDF(z).toString();
+    };
+    /**
+     * Returns the inverse of the normal cumulative distribution.
+     *
+     * Excel: `NORMINV(...)`.
+     *
+     * @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`.
+     */
+    StatisticalDistributionFormulas.prototype.ComputeNORMINV = 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 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 = normInv(p, mean, std);
+        if (isNaN(result)) {
+            return errCollection[CommonErrors.Num];
+        }
+        return result.toString();
+    };
+    /**
+     * Returns the inverse of the standard normal cumulative distribution.
+     *
+     * Excel: `NORMSINV(...)`.
+     *
+     * @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`.
+     */
+    StatisticalDistributionFormulas.prototype.ComputeNORMSINV = 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) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var p = this.resolveNumberArg(args[0]);
+        if (typeof p === 'string') {
+            return p;
+        }
+        var result = normInv(p);
+        if (isNaN(result)) {
+            return errCollection[CommonErrors.Num];
+        }
+        return result.toString();
+    };
+    /**
+     * Returns the Poisson distribution.
+     *
+     * Excel: `POISSON(...)`.
+     *
+     * @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`.
+     */
+    StatisticalDistributionFormulas.prototype.ComputePOISSON = 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 x = this.resolveNumberArg(args[0]);
+        var mean = this.resolveNumberArg(args[1]);
+        if (typeof x === 'string') {
+            return x;
+        }
+        if (typeof mean === 'string') {
+            return mean;
+        }
+        var k = Math.floor(x);
+        if (k < 0 || mean < 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var cumulative = true;
+        if (args.length === 3) {
+            var cumArg = this.resolveNumberArg(args[2]);
+            if (typeof cumArg === 'string') {
+                return cumArg;
+            }
+            cumulative = cumArg !== 0;
+        }
+        if (!cumulative) {
+            return (Math.exp(-mean) * Math.pow(mean, k) / factorial(k)).toString();
+        }
+        var sum = 0;
+        for (var i = 0; i <= k; i++) {
+            sum += Math.exp(-mean) * Math.pow(mean, i) / factorial(i);
+        }
+        return sum.toString();
+    };
+    /**
+     * Returns the individual term binomial distribution probability.
+     *
+     * Excel: `BINOMDIST(...)`.
+     *
+     * @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`.
+     */
+    StatisticalDistributionFormulas.prototype.ComputeBINOMDIST = 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 successes = this.resolveNumberArg(args[0]);
+        var trials = this.resolveNumberArg(args[1]);
+        var prob = this.resolveNumberArg(args[2]);
+        if (typeof successes === 'string') {
+            return successes;
+        }
+        if (typeof trials === 'string') {
+            return trials;
+        }
+        if (typeof prob === 'string') {
+            return prob;
+        }
+        var s = Math.floor(successes);
+        var n = Math.floor(trials);
+        if (s < 0 || n < 0 || s > n || prob < 0 || prob > 1) {
+            return errCollection[CommonErrors.Num];
+        }
+        var cumulative = true;
+        if (args.length === 4) {
+            var cumArg = this.resolveNumberArg(args[3]);
+            if (typeof cumArg === 'string') {
+                return cumArg;
+            }
+            cumulative = cumArg !== 0;
+        }
+        var pmf = binomialCoeff(n, s) * Math.pow(prob, s) * Math.pow(1 - prob, n - s);
+        if (!cumulative) {
+            return pmf.toString();
+        }
+        var sum = 0;
+        for (var i = 0; i <= s; i++) {
+            sum += binomialCoeff(n, i) * Math.pow(prob, i) * Math.pow(1 - prob, n - i);
+        }
+        return sum.toString();
+    };
+    /**
+     * Returns the exponential distribution.
+     *
+     * Excel: `EXPONDIST(...)`.
+     *
+     * @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`.
+     */
+    StatisticalDistributionFormulas.prototype.ComputeEXPONDIST = 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 x = this.resolveNumberArg(args[0]);
+        var lambda = this.resolveNumberArg(args[1]);
+        if (typeof x === 'string') {
+            return x;
+        }
+        if (typeof lambda === 'string') {
+            return lambda;
+        }
+        if (x < 0 || lambda <= 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var cumulative = true;
+        if (args.length === 3) {
+            var cumArg = this.resolveNumberArg(args[2]);
+            if (typeof cumArg === 'string') {
+                return cumArg;
+            }
+            cumulative = cumArg !== 0;
+        }
+        if (cumulative) {
+            return (1 - Math.exp(-lambda * x)).toString();
+        }
+        return (lambda * Math.exp(-lambda * x)).toString();
+    };
+    /**
+     * Returns the confidence interval for a population mean.
+     *
+     * Excel: `CONFIDENCE(...)`.
+     *
+     * @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`.
+     */
+    StatisticalDistributionFormulas.prototype.ComputeCONFIDENCE = 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 alpha = this.resolveNumberArg(args[0]);
+        var std = this.resolveNumberArg(args[1]);
+        var size = this.resolveNumberArg(args[2]);
+        if (typeof alpha === 'string') {
+            return alpha;
+        }
+        if (typeof std === 'string') {
+            return std;
+        }
+        if (typeof size === 'string') {
+            return size;
+        }
+        if (alpha <= 0 || alpha >= 1 || std <= 0 || size < 1) {
+            return errCollection[CommonErrors.Num];
+        }
+        var z = normInv(1 - alpha / 2);
+        if (isNaN(z)) {
+            return errCollection[CommonErrors.Num];
+        }
+        return (z * std / Math.sqrt(size)).toString();
+    };
+    return StatisticalDistributionFormulas;
+}(StatisticalSampleBase));
+export { StatisticalDistributionFormulas };

package/src/formulas/statistical-ecma.d.ts

@@ -0,0 +1,95 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { StatisticalSampleBase } from './statistical-sample-base';
+/**
+ * ECMA-376 statistical distribution and hypothesis-test functions (beta, t, F, frequency).
+ *
+ * Registered functions: BETADIST, BETAINV, TDIST, TINV, TTEST, FTEST, FREQUENCY.
+ *
+ * @hidden
+ */
+export declare class StatisticalEcmaFormulas extends StatisticalSampleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns the beta cumulative distribution function.
+     *
+     * Excel: `BETADIST(...)`.
+     *
+     * @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('=BETADIST(1)');
+     * ```
+     */
+    ComputeBETADIST(...args: string[]): string | number;
+    /**
+     * Returns the inverse of the beta cumulative distribution function.
+     *
+     * Excel: `BETAINV(...)`.
+     *
+     * @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`.
+     */
+    ComputeBETAINV(...args: string[]): string | number;
+    /**
+     * Returns the Student t-distribution.
+     *
+     * Excel: `TDIST(...)`.
+     *
+     * @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`.
+     */
+    ComputeTDIST(...args: string[]): string | number;
+    /**
+     * Returns the inverse of the Student t-distribution.
+     *
+     * Excel: `TINV(...)`.
+     *
+     * @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`.
+     */
+    ComputeTINV(...args: string[]): string | number;
+    /**
+     * Returns the probability associated with a Student t-test.
+     *
+     * Excel: `TTEST(...)`.
+     *
+     * @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`.
+     */
+    ComputeTTEST(...args: string[]): string | number;
+    /**
+     * Returns the result of an F-test.
+     *
+     * Excel: `FTEST(...)`.
+     *
+     * @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`.
+     */
+    ComputeFTEST(...args: string[]): string | number;
+    private sampleVar;
+    /**
+     * Returns a frequency distribution as a vertical array (first bin when spill unavailable).
+     *
+     * Excel: `FREQUENCY(...)`.
+     *
+     * @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`.
+     */
+    ComputeFREQUENCY(...args: string[]): string | number;
+}