@syncfusion/ej2-calculate 35.1.37

package/src/formulas/statistical-moments.js

@@ -0,0 +1,269 @@
+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';
+/**
+ * Distribution shape metrics: skewness, kurtosis, and moment-based descriptive statistics.
+ *
+ * Registered functions: AVEDEV, DEVSQ, HARMEAN, SKEW, KURT, STANDARDIZE.
+ *
+ * @hidden
+ */
+var StatisticalMomentsFormulas = /** @class */ (function (_super) {
+    __extends(StatisticalMomentsFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function StatisticalMomentsFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'AVEDEV', category: 'Statistical', description: 'Returns the average of the absolute deviations of data points from their mean.' },
+            { formulaName: 'DEVSQ', category: 'Statistical', description: 'Returns the sum of squares of deviations.' },
+            { formulaName: 'HARMEAN', category: 'Statistical', description: 'Returns the harmonic mean.' },
+            { formulaName: 'SKEW', category: 'Statistical', description: 'Returns the skewness of a distribution.' },
+            { formulaName: 'KURT', category: 'Statistical', description: 'Returns the kurtosis of a data set.' },
+            { formulaName: 'STANDARDIZE', category: 'Statistical', description: 'Returns a normalized value from a distribution.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns the average of the absolute deviations of data points from their mean.
+     *
+     * Excel: `AVEDEV(...)`.
+     *
+     * @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('=AVEDEV(1)');
+     * ```
+     */
+    StatisticalMomentsFormulas.prototype.ComputeAVEDEV = 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);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length === 0) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        var avg = this.mean(nums);
+        var sum = 0;
+        for (var i = 0; i < nums.length; i++) {
+            sum += Math.abs(nums[i] - avg);
+        }
+        return (sum / nums.length).toString();
+    };
+    /**
+     * Returns the sum of squares of deviations.
+     *
+     * Excel: `DEVSQ(...)`.
+     *
+     * @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`.
+     */
+    StatisticalMomentsFormulas.prototype.ComputeDEVSQ = 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);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length === 0) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        var avg = this.mean(nums);
+        var sum = 0;
+        for (var i = 0; i < nums.length; i++) {
+            var d = nums[i] - avg;
+            sum += d * d;
+        }
+        return sum.toString();
+    };
+    /**
+     * Returns the harmonic mean.
+     *
+     * Excel: `HARMEAN(...)`.
+     *
+     * @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`.
+     */
+    StatisticalMomentsFormulas.prototype.ComputeHARMEAN = 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);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length === 0) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        var sumInv = 0;
+        for (var i = 0; i < nums.length; i++) {
+            if (nums[i] <= 0) {
+                return errCollection[CommonErrors.Num];
+            }
+            sumInv += 1 / nums[i];
+        }
+        return (nums.length / sumInv).toString();
+    };
+    /**
+     * Returns the skewness of a distribution.
+     *
+     * Excel: `SKEW(...)`.
+     *
+     * @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`.
+     */
+    StatisticalMomentsFormulas.prototype.ComputeSKEW = 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);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        var n = nums.length;
+        if (n < 3) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        var avg = this.mean(nums);
+        var m2 = 0;
+        var m3 = 0;
+        for (var i = 0; i < n; i++) {
+            var d = nums[i] - avg;
+            m2 += d * d;
+            m3 += d * d * d;
+        }
+        m2 /= n;
+        m3 /= n;
+        if (m2 === 0) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        var skew = m3 / Math.pow(m2, 1.5) * Math.sqrt(n * (n - 1)) / (n - 2);
+        return skew.toString();
+    };
+    /**
+     * Returns the kurtosis of a data set.
+     *
+     * Excel: `KURT(...)`.
+     *
+     * @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`.
+     */
+    StatisticalMomentsFormulas.prototype.ComputeKURT = 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);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        var n = nums.length;
+        if (n < 4) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        var avg = this.mean(nums);
+        var m2 = 0;
+        var m4 = 0;
+        for (var i = 0; i < n; i++) {
+            var d = nums[i] - avg;
+            m2 += d * d;
+            m4 += d * d * d * d;
+        }
+        m2 /= n;
+        m4 /= n;
+        if (m2 === 0) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        var kurt = (n * (n + 1) / ((n - 1) * (n - 2) * (n - 3))) * (m4 / (m2 * m2))
+            - (3 * (n - 1) * (n - 1)) / ((n - 2) * (n - 3));
+        return kurt.toString();
+    };
+    /**
+     * Returns a normalized value from a distribution.
+     *
+     * Excel: `STANDARDIZE(...)`.
+     *
+     * @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`.
+     */
+    StatisticalMomentsFormulas.prototype.ComputeSTANDARDIZE = 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 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];
+        }
+        return ((x - mean) / std).toString();
+    };
+    return StatisticalMomentsFormulas;
+}(StatisticalSampleBase));
+export { StatisticalMomentsFormulas };

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

@@ -0,0 +1,56 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { StatisticalSampleBase } from './statistical-sample-base';
+/**
+ * Percentile, quartile, and rank position functions for ordered data sets.
+ *
+ * Registered functions: PERCENTILE, PERCENTRANK, QUARTILE.
+ *
+ * @hidden
+ */
+export declare class StatisticalPercentileFormulas extends StatisticalSampleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    private sortedSample;
+    private percentile;
+    /**
+     * Returns the k-th percentile of values in a range.
+     *
+     * Excel: `PERCENTILE(...)`.
+     *
+     * @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('=PERCENTILE(1)');
+     * ```
+     */
+    ComputePERCENTILE(...args: string[]): string | number;
+    /**
+     * Returns the percentage rank of a value in a data set.
+     *
+     * Excel: `PERCENTRANK(...)`.
+     *
+     * @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`.
+     */
+    ComputePERCENTRANK(...args: string[]): string | number;
+    /**
+     * Returns the quartile of a data set.
+     *
+     * Excel: `QUARTILE(...)`.
+     *
+     * @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`.
+     */
+    ComputeQUARTILE(...args: string[]): string | number;
+}

package/src/formulas/statistical-percentile.js

@@ -0,0 +1,195 @@
+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';
+/**
+ * Percentile, quartile, and rank position functions for ordered data sets.
+ *
+ * Registered functions: PERCENTILE, PERCENTRANK, QUARTILE.
+ *
+ * @hidden
+ */
+var StatisticalPercentileFormulas = /** @class */ (function (_super) {
+    __extends(StatisticalPercentileFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function StatisticalPercentileFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'PERCENTILE', category: 'Statistical', description: 'Returns the k-th percentile of values in a range.' },
+            { formulaName: 'PERCENTRANK', category: 'Statistical', description: 'Returns the percentage rank of a value in a data set.' },
+            { formulaName: 'QUARTILE', category: 'Statistical', description: 'Returns the quartile of a data set.' }
+        ];
+        return _this;
+    }
+    StatisticalPercentileFormulas.prototype.sortedSample = function (args) {
+        if (isNullOrUndefined(args) || (args.length === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        var nums = this.collectSample(args);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        return nums.slice().sort(function (a, b) { return a - b; });
+    };
+    StatisticalPercentileFormulas.prototype.percentile = function (sorted, k) {
+        var errCollection = this.parent.getErrorStrings();
+        if (k < 0 || k > 1) {
+            return errCollection[CommonErrors.Num];
+        }
+        if (sorted.length === 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var n = sorted.length;
+        var pos = k * (n - 1);
+        var lower = Math.floor(pos);
+        var frac = pos - lower;
+        if (lower >= n - 1) {
+            return sorted[n - 1];
+        }
+        return sorted[lower] + frac * (sorted[lower + 1] - sorted[lower]);
+    };
+    /**
+     * Returns the k-th percentile of values in a range.
+     *
+     * Excel: `PERCENTILE(...)`.
+     *
+     * @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('=PERCENTILE(1)');
+     * ```
+     */
+    StatisticalPercentileFormulas.prototype.ComputePERCENTILE = 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 k = this.resolveNumberArg(args[1]);
+        if (typeof k === 'string') {
+            return k;
+        }
+        var sorted = this.sortedSample([args[0]]);
+        if (typeof sorted === 'string') {
+            return sorted;
+        }
+        var result = this.percentile(sorted, k);
+        return typeof result === 'string' ? result : result.toString();
+    };
+    /**
+     * Returns the percentage rank of a value in a data set.
+     *
+     * Excel: `PERCENTRANK(...)`.
+     *
+     * @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`.
+     */
+    StatisticalPercentileFormulas.prototype.ComputePERCENTRANK = 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]);
+        if (typeof x === 'string') {
+            return x;
+        }
+        var sorted = this.sortedSample([args[1]]);
+        if (typeof sorted === 'string') {
+            return sorted;
+        }
+        if (sorted.length === 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var lower = 0;
+        var upper = 1;
+        if (args.length === 3) {
+            var sig = this.resolveNumberArg(args[2]);
+            if (typeof sig === 'string') {
+                return sig;
+            }
+            lower = sig;
+            upper = 1 - sig;
+        }
+        if (x < sorted[0]) {
+            return lower.toString();
+        }
+        if (x > sorted[sorted.length - 1]) {
+            return upper.toString();
+        }
+        var rank = 0;
+        for (var i = 0; i < sorted.length; i++) {
+            if (sorted[i] === x) {
+                rank = i / (sorted.length - 1 || 1);
+                break;
+            }
+            if (sorted[i] > x) {
+                var frac = (x - sorted[i - 1]) / (sorted[i] - sorted[i - 1]);
+                rank = (i - 1 + frac) / (sorted.length - 1);
+                break;
+            }
+        }
+        return rank.toString();
+    };
+    /**
+     * Returns the quartile of a data set.
+     *
+     * Excel: `QUARTILE(...)`.
+     *
+     * @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`.
+     */
+    StatisticalPercentileFormulas.prototype.ComputeQUARTILE = 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) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var quart = this.resolveNumberArg(args[1]);
+        if (typeof quart === 'string') {
+            return quart;
+        }
+        var q = Math.floor(quart);
+        if (q < 0 || q > 4) {
+            return errCollection[CommonErrors.Num];
+        }
+        var kMap = { 0: 0, 1: 0.25, 2: 0.5, 3: 0.75, 4: 1 };
+        var sorted = this.sortedSample([args[0]]);
+        if (typeof sorted === 'string') {
+            return sorted;
+        }
+        var result = this.percentile(sorted, kMap[q]);
+        return typeof result === 'string' ? result : result.toString();
+    };
+    return StatisticalPercentileFormulas;
+}(StatisticalSampleBase));
+export { StatisticalPercentileFormulas };

package/src/formulas/statistical-sample-base.d.ts

@@ -0,0 +1,14 @@
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Shared sample collection for statistical formula modules.
+ *
+ * @hidden
+ */
+export declare class StatisticalSampleBase extends FormulaModuleBase {
+    protected collectSample(args: string[], includeTextAsZero?: boolean): number[] | string;
+    protected collectPair(args: string[]): {
+        x: number[];
+        y: number[];
+    } | string;
+    protected mean(nums: number[]): number;
+}

package/src/formulas/statistical-sample-base.js

@@ -0,0 +1,124 @@
+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 { FormulaModuleBase } from './formula-module-base';
+/**
+ * Shared sample collection for statistical formula modules.
+ *
+ * @hidden
+ */
+var StatisticalSampleBase = /** @class */ (function (_super) {
+    __extends(StatisticalSampleBase, _super);
+    function StatisticalSampleBase() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    StatisticalSampleBase.prototype.collectSample = function (args, includeTextAsZero) {
+        if (includeTextAsZero === void 0) { includeTextAsZero = false; }
+        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;
+    };
+    StatisticalSampleBase.prototype.collectPair = function (args) {
+        var errCollection = this.parent.getErrorStrings();
+        if (args.length !== 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var xCells = this.parent.getCellCollection(args[0]);
+        var yCells = this.parent.getCellCollection(args[1]);
+        var xList = Array.isArray(xCells) ? xCells : [xCells];
+        var yList = Array.isArray(yCells) ? yCells : [yCells];
+        if (xList.length !== yList.length) {
+            return errCollection[CommonErrors.NA];
+        }
+        var x = [];
+        var y = [];
+        for (var i = 0; i < xList.length; i++) {
+            var xv = this.parent.getValueFromArg(xList[i]);
+            var yv = this.parent.getValueFromArg(yList[i]);
+            if (errCollection.indexOf(xv) > -1) {
+                return xv;
+            }
+            if (errCollection.indexOf(yv) > -1) {
+                return yv;
+            }
+            if (xv !== '' && yv !== '' && this.parent.isNumber(xv) && this.parent.isNumber(yv)) {
+                x.push(this.parent.parseFloat(xv));
+                y.push(this.parent.parseFloat(yv));
+            }
+        }
+        return { x: x, y: y };
+    };
+    StatisticalSampleBase.prototype.mean = function (nums) {
+        return nums.reduce(function (a, b) { return a + b; }, 0) / nums.length;
+    };
+    return StatisticalSampleBase;
+}(FormulaModuleBase));
+export { StatisticalSampleBase };