@syncfusion/ej2-calculate 35.1.37

package/src/formulas/statistical-advanced.js

@@ -0,0 +1,756 @@
+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 { isNumber } from '../common/number-date';
+import { isCellReference } from '../common/cell-ref';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Extended statistical summaries including ranked averages, modes, and specialized aggregates.
+ *
+ * Registered functions: SMALL, LARGE, MEDIAN, SLOPE, INTERCEPT, RSQ, GEOMEAN.
+ *
+ * @hidden
+ */
+var StatisticalAdvancedFormulas = /** @class */ (function (_super) {
+    __extends(StatisticalAdvancedFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function StatisticalAdvancedFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'SMALL', category: 'Statistical', description: 'Returns the k-th smallest value in a given array.' },
+            { formulaName: 'LARGE', category: 'Statistical', description: 'Returns the k-th largest value in a given array.' },
+            { formulaName: 'MEDIAN', category: 'Statistical', description: 'Returns the median of the given set of numbers.' },
+            { formulaName: 'SLOPE', category: 'Statistical', description: 'Returns the slope of the line from linear regression of the data points.' },
+            { formulaName: 'INTERCEPT', category: 'Statistical', description: 'Calculates the point of the Y-intercept line via linear regression.' },
+            { formulaName: 'RSQ', category: 'Statistical', description: 'Returns the square of the Pearson product moment correlation coefficient based on data points in known_ys and known_xs.' },
+            { formulaName: 'GEOMEAN', category: 'Statistical', description: 'Returns the geometric mean of an array or range of positive data.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns the median of the given set of numbers.
+     *
+     * Excel: `MEDIAN(...)`.
+     *
+     * @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('=MEDIAN(1)');
+     * ```
+     */
+    StatisticalAdvancedFormulas.prototype.ComputeMEDIAN = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var value1;
+        var num = [];
+        if (isNullOrUndefined(args) || args[0] === '' && args.length === 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        for (var i = 0; i < args.length; i++) {
+            if (this.parent.isCellReference(args[i])) {
+                if (args[i].indexOf(':') > -1) {
+                    var cellCollection = this.parent.getCellCollection(args[i]);
+                    for (var a = 0; a < cellCollection.length; a++) {
+                        var cellValue = this.parent.getValueFromArg(cellCollection[a]);
+                        if (this.parent.getErrorStrings().indexOf(cellValue) > -1) {
+                            return cellValue;
+                        }
+                        else if (cellValue.trim() !== '') {
+                            num.push(this.parent.parseFloat(cellValue));
+                        }
+                    }
+                }
+                else {
+                    var cellVal = this.parent.getValueFromArg(args[i]);
+                    if (this.parent.getErrorStrings().indexOf(cellVal) > -1) {
+                        return cellVal;
+                    }
+                    else if (cellVal.trim() !== '') {
+                        num.push(this.parent.parseFloat(cellVal));
+                    }
+                }
+            }
+            else if (args[i] === '' || args[i] === this.parent.falseValue && !this.parent.isCellReference(args[i])) {
+                num.push(0);
+            }
+            else if (args[i] === this.parent.trueValue && !this.parent.isCellReference(args[i])) {
+                num.push(1);
+            }
+            else if (args[i].indexOf(this.parent.tic) > -1 && isNaN(parseFloat(args[i].split(this.parent.tic).join('')))) {
+                return this.parent.getErrorStrings()[CommonErrors.Value];
+            }
+            else {
+                var cValue = this.parent.getValueFromArg(args[i]).split(this.parent.tic).join('');
+                if (this.parent.getErrorStrings().indexOf(cValue) > -1) {
+                    return cValue;
+                }
+                else {
+                    num.push(this.parent.parseFloat(cValue));
+                }
+            }
+        }
+        num = num.sort(function (n1, n2) { return n1 - n2; });
+        var len = num.length;
+        for (var j = 0; j < len; j++) {
+            if (isNaN(num[j])) {
+                num.splice(j, 1);
+                len = num.length;
+                j--;
+                if (num.length === 0) {
+                    break;
+                }
+            }
+        }
+        if (num.length % 2 !== 0 && !isNaN(num[parseInt((num.length / 2).toString(), 10)])) {
+            value1 = num[parseInt((num.length / 2).toString(), 10)];
+        }
+        else if (!isNaN(num[num.length / 2]) && !isNaN(num[num.length / 2 - 1])) {
+            value1 = (num[num.length / 2] + num[num.length / 2 - 1]) / 2;
+        }
+        else {
+            return this.parent.getErrorStrings()[CommonErrors.Num];
+        }
+        return value1;
+    };
+    /**
+     * Returns the k-th smallest value in a given array.
+     *
+     * Excel: `SMALL(...)`.
+     *
+     * @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`.
+     */
+    StatisticalAdvancedFormulas.prototype.ComputeSMALL = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var value;
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length === 1 || args[0] === '') {
+            if ((args[0] === '') && (args[1] === '')) {
+                return errCollection[CommonErrors.Num];
+            }
+            else {
+                return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+            }
+        }
+        else if (args.length > 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var cellCollection = [];
+        var valueCollection = [];
+        var numArr = [];
+        if (!isNullOrUndefined(args[0])) {
+            var originalValue = void 0;
+            if (this.parent.isCellReference(args[0])) {
+                cellCollection = this.parent.getCellCollection(args[0]);
+                for (var i = 0; i < cellCollection.length; i++) {
+                    originalValue = this.parent.getValueFromArg(cellCollection[i]);
+                    if (errCollection.indexOf(originalValue) > -1) {
+                        return originalValue;
+                    }
+                    valueCollection.push(originalValue);
+                }
+            }
+            else {
+                originalValue = this.parent.getValueFromArg(args[0]).split(this.parent.tic).join('');
+                if (errCollection.indexOf(originalValue) > -1) {
+                    return originalValue;
+                }
+                valueCollection.push(originalValue);
+            }
+            for (var i = 0; i < valueCollection.length; i++) {
+                if (valueCollection[i] !== '' && !isNaN(this.parent.parseFloat(valueCollection[i]))) {
+                    numArr.push(this.parent.parseFloat(valueCollection[i]));
+                }
+            }
+            if (numArr.length === 0) {
+                if (isNullOrUndefined(valueCollection[0]) || args[0].indexOf(this.parent.tic) > -1) {
+                    return errCollection[CommonErrors.Value];
+                }
+            }
+        }
+        numArr = numArr.sort(function (n1, n2) { return n1 - n2; });
+        var smallIndex;
+        if (!isNullOrUndefined(args[1])) {
+            if (this.parent.isCellReference(args[1])) {
+                smallIndex = this.parent.getValueFromArg(args[1]);
+                if (smallIndex === '') {
+                    return errCollection[CommonErrors.Num];
+                }
+                else if (smallIndex.trim() === '') {
+                    return errCollection[CommonErrors.Value];
+                }
+                if (smallIndex.toUpperCase() === this.parent.trueValue) {
+                    smallIndex = '1';
+                }
+                else if (smallIndex.toUpperCase() === this.parent.falseValue) {
+                    smallIndex = '0';
+                }
+            }
+            else {
+                smallIndex = this.parent.getValueFromArg(args[1]).split(this.parent.tic).join('');
+            }
+            if (errCollection.indexOf(smallIndex) > -1) {
+                return smallIndex;
+            }
+            else if (smallIndex.trim() === '') {
+                return args[1].length > 0 ? errCollection[CommonErrors.Value] : errCollection[CommonErrors.Num];
+            }
+            else if (isNaN(this.parent.parseFloat(smallIndex))) {
+                if (args[1].toUpperCase() === this.parent.trueValue) {
+                    smallIndex = '1';
+                }
+                else if (args[1].toUpperCase() === this.parent.falseValue) {
+                    smallIndex = '0';
+                }
+                else {
+                    return errCollection[CommonErrors.Value];
+                }
+            }
+        }
+        var finalIndex = (Number(smallIndex) < 1 ? 0 : Math.floor(Number(smallIndex)));
+        if (isNullOrUndefined(numArr[finalIndex - 1]) && !isNaN(Number(finalIndex))) {
+            return errCollection[CommonErrors.Num];
+        }
+        else {
+            value = numArr[finalIndex - 1];
+        }
+        return value;
+    };
+    /**
+     * Returns the k-th largest value in a given array.
+     *
+     * Excel: `LARGE(...)`.
+     *
+     * @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`.
+     */
+    StatisticalAdvancedFormulas.prototype.ComputeLARGE = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var value;
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length === 1 || args[0] === '') {
+            if ((args[0] === '') && (args[1] === '')) {
+                return errCollection[CommonErrors.Num];
+            }
+            else {
+                return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+            }
+        }
+        else if (args.length > 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var cellCollection = [];
+        var valueCollection = [];
+        var numArr = [];
+        if (!isNullOrUndefined(args[0])) {
+            var originalValue = void 0;
+            if (this.parent.isCellReference(args[0])) {
+                cellCollection = this.parent.getCellCollection(args[0]);
+                for (var i = 0; i < cellCollection.length; i++) {
+                    originalValue = this.parent.getValueFromArg(cellCollection[i]);
+                    if (errCollection.indexOf(originalValue) > -1) {
+                        return originalValue;
+                    }
+                    valueCollection.push(originalValue);
+                }
+            }
+            else {
+                originalValue = this.parent.getValueFromArg(args[0]).split(this.parent.tic).join('');
+                if (errCollection.indexOf(originalValue) > -1) {
+                    return originalValue;
+                }
+                valueCollection.push(originalValue);
+            }
+            for (var i = 0; i < valueCollection.length; i++) {
+                if (valueCollection[i] !== '' && !isNaN(this.parent.parseFloat(valueCollection[i]))) {
+                    numArr.push(this.parent.parseFloat(valueCollection[i]));
+                }
+            }
+            if (numArr.length === 0) {
+                if (isNullOrUndefined(valueCollection[0]) || args[0].indexOf(this.parent.tic) > -1) {
+                    return errCollection[CommonErrors.Value];
+                }
+            }
+        }
+        numArr = numArr.sort(function (n1, n2) { return n2 - n1; });
+        var largeIndex;
+        if (!isNullOrUndefined(args[1])) {
+            if (this.parent.isCellReference(args[1])) {
+                largeIndex = this.parent.getValueFromArg(args[1]);
+                if (largeIndex === '') {
+                    return errCollection[CommonErrors.Num];
+                }
+                else if (largeIndex.trim() === '') {
+                    return errCollection[CommonErrors.Value];
+                }
+                if (largeIndex.toUpperCase() === this.parent.trueValue) {
+                    largeIndex = '1';
+                }
+                else if (largeIndex.toUpperCase() === this.parent.falseValue) {
+                    largeIndex = '0';
+                }
+            }
+            else {
+                largeIndex = this.parent.getValueFromArg(args[1]).split(this.parent.tic).join('');
+            }
+            if (errCollection.indexOf(largeIndex) > -1) {
+                return largeIndex;
+            }
+            else if (largeIndex.trim() === '') {
+                return args[1].length > 0 ? errCollection[CommonErrors.Value] : errCollection[CommonErrors.Num];
+            }
+            else if (isNaN(this.parent.parseFloat(largeIndex))) {
+                if (args[1].toUpperCase() === this.parent.trueValue) {
+                    largeIndex = '1';
+                }
+                else if (args[1].toUpperCase() === this.parent.falseValue) {
+                    largeIndex = '0';
+                }
+                else {
+                    return errCollection[CommonErrors.Value];
+                }
+            }
+        }
+        var finalIndex = (Number(largeIndex) < 1 ? 0 : Math.ceil(Number(largeIndex)));
+        if (isNullOrUndefined(numArr[finalIndex - 1]) && !isNaN(Number(finalIndex))) {
+            return errCollection[CommonErrors.Num];
+        }
+        else {
+            value = numArr[finalIndex - 1];
+        }
+        return value;
+    };
+    /**
+     * Returns the slope of the line from linear regression of the data points.
+     *
+     * Excel: `SLOPE(...)`.
+     *
+     * @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`.
+     */
+    StatisticalAdvancedFormulas.prototype.ComputeSLOPE = function () {
+        var _this = this;
+        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].trim() === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        else if (args.length !== 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        else if (args[0] === '' || args[1] === '') {
+            return errCollection[CommonErrors.Value];
+        }
+        var cellCollection = function (actuaValue) {
+            if (actuaValue.indexOf(_this.parent.tic) === -1) {
+                actuaValue = _this.parent.getCellCollection(actuaValue.split(_this.parent.tic).join(''));
+            }
+            else {
+                actuaValue = undefined;
+            }
+            return actuaValue;
+        };
+        var yPoints = cellCollection(args[0].trim());
+        var xPoints = cellCollection(args[1].trim());
+        if (isNullOrUndefined(yPoints) || isNullOrUndefined(xPoints) || (yPoints.length < 2 && xPoints.length < 2)) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        else if (yPoints.length !== xPoints.length) {
+            return errCollection[CommonErrors.NA];
+        }
+        var dataCollection = function (actuaValue) {
+            actuaValue = _this.getDataCollection(actuaValue);
+            for (var b = 0; b < actuaValue.length; b++) {
+                if (errCollection.indexOf(actuaValue[b]) > -1) {
+                    return actuaValue[b].toString();
+                }
+            }
+            return actuaValue;
+        };
+        yPoints = dataCollection(yPoints);
+        if (errCollection.indexOf(yPoints.toString()) > -1) {
+            return yPoints.toString();
+        }
+        xPoints = dataCollection(xPoints);
+        if (errCollection.indexOf(xPoints.toString()) > -1) {
+            return xPoints.toString();
+        }
+        var sumXY = 0;
+        var sumX2 = 0;
+        var sumX = 0;
+        var sumY = 0;
+        var length = 0;
+        for (var i = 0, len = xPoints.length; i < len; ++i) {
+            if ((xPoints[i] !== '' && Number(xPoints[i]).toString() !== 'NaN') &&
+                (yPoints[i] !== '' && Number(yPoints[i]).toString() !== 'NaN')) {
+                sumXY += Number(xPoints[i]) * Number(yPoints[i]);
+                sumX += Number(xPoints[i]);
+                sumY += Number(yPoints[i]);
+                sumX2 += Number(xPoints[i]) * Number(xPoints[i]);
+                length++;
+            }
+        }
+        var value = ((sumXY - (sumX * sumY) / length) / (sumX2 - (sumX * sumX) / length)).toString();
+        if (value === 'NaN') {
+            return errCollection[CommonErrors.DivZero];
+        }
+        return value;
+    };
+    /**
+     * Calculates the point of the Y-intercept line via linear regression.
+     *
+     * Excel: `INTERCEPT(...)`.
+     *
+     * @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`.
+     */
+    StatisticalAdvancedFormulas.prototype.ComputeINTERCEPT = function () {
+        var _this = this;
+        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].trim() === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        else if (args.length !== 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        else if (args[0] === '' || args[1] === '') {
+            return errCollection[CommonErrors.Value];
+        }
+        var cellCollection = function (actuaValue) {
+            if (actuaValue.indexOf(_this.parent.tic) === -1) {
+                actuaValue = _this.parent.getCellCollection(actuaValue.split(_this.parent.tic).join(''));
+            }
+            else {
+                actuaValue = undefined;
+            }
+            return actuaValue;
+        };
+        var yValues = cellCollection(args[0].trim());
+        var xValues = cellCollection(args[1].trim());
+        if (isNullOrUndefined(yValues) || isNullOrUndefined(xValues) || (yValues.length < 2 && xValues.length < 2)) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        else if (yValues.length !== xValues.length) {
+            return errCollection[CommonErrors.NA];
+        }
+        var dataCollection = function (actuaValue) {
+            actuaValue = _this.getDataCollection(actuaValue);
+            for (var b = 0; b < actuaValue.length; b++) {
+                if (errCollection.indexOf(actuaValue[b]) > -1) {
+                    return actuaValue[b];
+                }
+            }
+            return actuaValue;
+        };
+        yValues = dataCollection(yValues);
+        if (errCollection.indexOf(yValues.toString()) > -1) {
+            return yValues.toString();
+        }
+        xValues = dataCollection(xValues);
+        if (errCollection.indexOf(xValues.toString()) > -1) {
+            return xValues.toString();
+        }
+        var sumY = 0;
+        var sumX = 0;
+        var length = 0;
+        var sumXY = 0;
+        var sumX2 = 0;
+        var diff;
+        var calculation = function (isSum) {
+            for (var i = 0, len = xValues.length; i < len; ++i) {
+                if ((yValues[i] !== '' && Number(yValues[i]).toString() !== 'NaN') &&
+                    (xValues[i] !== '' && Number(xValues[i]).toString() !== 'NaN')) {
+                    if (isSum) {
+                        sumY += Number(yValues[i]);
+                        sumX += Number(xValues[i]);
+                        length++;
+                    }
+                    else {
+                        diff = Number(xValues[i]) - sumX;
+                        sumXY += diff * (Number(yValues[i]) - sumY);
+                        sumX2 += diff * diff;
+                    }
+                }
+            }
+        };
+        calculation(true);
+        sumY = sumY / length;
+        sumX = sumX / length;
+        calculation(false);
+        var value = (sumY - sumXY / sumX2 * sumX).toString();
+        if (value === 'NaN') {
+            return errCollection[CommonErrors.DivZero];
+        }
+        return value;
+    };
+    /**
+     * Returns the geometric mean of an array or range of positive data.
+     *
+     * Excel: `GEOMEAN(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    StatisticalAdvancedFormulas.prototype.ComputeGEOMEAN = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var argArr = args;
+        var sum = 1;
+        var count = 0;
+        var cellVal = 0;
+        var cellStr = 0;
+        var dev;
+        var r;
+        var s;
+        var cell;
+        if (args.length === 0) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        if (argArr.length === 1 && argArr[0] === '') {
+            return sum.toString();
+        }
+        var isBoolean;
+        for (r = 0; r < argArr.length; r++) {
+            if (argArr[r].indexOf(':') > -1) {
+                if (argArr[0] === this.parent.tic) {
+                    return this.parent.getErrorStrings()[CommonErrors.Value];
+                }
+                cell = this.parent.getCellCollection(argArr[r].split(this.parent.tic).join(''));
+                for (s = 0; s < cell.length; s++) {
+                    cellVal = this.parent.getValueFromArg(cell[s]);
+                    cellStr = cellVal.split(this.parent.tic).join('');
+                    isBoolean = cellStr === this.parent.trueValue || cellStr === this.parent.falseValue;
+                    dev = this.parent.parseFloat(cellVal);
+                    if (dev <= 0) {
+                        return this.parent.getErrorStrings()[CommonErrors.Num];
+                    }
+                    if (isBoolean || this.parent.getErrorStrings().indexOf(cellVal) > -1) {
+                        continue;
+                    }
+                    else if (!isNaN(dev)) {
+                        count++;
+                        sum = sum * dev;
+                    }
+                }
+            }
+            else {
+                cellVal = this.parent.getValueFromArg(argArr[r]);
+                if (this.parent.getErrorStrings().indexOf(cellVal) > -1) {
+                    return cellVal;
+                }
+                var cellStr_1 = cellVal.split(this.parent.tic).join('');
+                if (cellVal.indexOf('"') > -1 && isNaN(this.parent.parseFloat(cellStr_1))) {
+                    return this.parent.getErrorStrings()[CommonErrors.Value];
+                }
+                argArr[r] = argArr[r].startsWith('n') ? argArr[r].slice(1) : argArr[r];
+                if ((cellVal === '' && argArr[r] === '')) {
+                    return this.parent.getErrorStrings()[CommonErrors.Num];
+                }
+                if ((cellStr_1 === 'TRUE' || cellStr_1 === 'FALSE') && this.parent.isCellReference(argArr[r])) {
+                    continue;
+                }
+                if (cellVal.length > 0) {
+                    cellVal = cellVal.indexOf('"') > -1 ? cellStr_1 : cellVal;
+                    cellVal = (cellVal.split(this.parent.tic).join('') === 'TRUE') ? '1' :
+                        (cellVal.split(this.parent.tic).join('') === 'FALSE') ? '0' : cellVal;
+                    if (!this.parent.isCellReference(argArr[r])) {
+                        if (isNaN(this.parent.parseFloat(cellVal))) {
+                            return this.parent.getErrorStrings()[CommonErrors.Value];
+                        }
+                    }
+                    dev = this.parent.parseFloat(cellVal);
+                    if (dev <= 0) {
+                        return this.parent.getErrorStrings()[CommonErrors.Num];
+                    }
+                    else if (!isNaN(dev)) {
+                        count++;
+                        sum = sum * dev;
+                    }
+                }
+            }
+        }
+        if (count > 0) {
+            sum = Math.pow(sum, 1 / count);
+        }
+        return sum.toString();
+    };
+    /**
+     * Returns the square of the Pearson product moment correlation coefficient based on data points in known_ys and known_xs.
+     *
+     * Excel: `RSQ(...)`.
+     *
+     * @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`.
+     */
+    StatisticalAdvancedFormulas.prototype.ComputeRSQ = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var validCount = 0;
+        var argArr = args;
+        if (argArr.length !== 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        if (argArr[0] === '' || argArr[1] === '') {
+            return this.parent.getErrorStrings()[CommonErrors.Value];
+        }
+        if (argArr[0].includes('"') || argArr[1].includes('"')) {
+            return this.parent.getErrorStrings()[CommonErrors.NA];
+        }
+        if ((argArr[0].indexOf(':') === -1 && isCellReference(argArr[0])) && (argArr[1].indexOf(':') === -1 && isCellReference(argArr[1]))) {
+            return this.parent.getErrorStrings()[CommonErrors.DivZero];
+        }
+        var yValuesRange = this.parent.getCellCollection(argArr[0]);
+        var xValuesRange = this.parent.getCellCollection(argArr[1]);
+        if ((yValuesRange.length !== xValuesRange.length)) {
+            return this.parent.getErrorStrings()[CommonErrors.NA];
+        }
+        var xValues = this.getDataCollection(xValuesRange);
+        for (var a = 0; a < xValues.length; a++) {
+            if (this.parent.getErrorStrings().indexOf(xValues[a]) > -1) {
+                return xValues[a];
+            }
+        }
+        var yValues = this.getDataCollection(yValuesRange);
+        for (var b = 0; b < yValues.length; b++) {
+            if (this.parent.getErrorStrings().indexOf(yValues[b]) > -1) {
+                return yValues[b];
+            }
+        }
+        var xValue;
+        var yValue;
+        for (var i = 0; i < xValues.length; i++) {
+            xValue = Number(xValues[i]);
+            yValue = Number(yValues[i]);
+            if (isNumber(xValue) && isNumber(yValue)) {
+                validCount++;
+            }
+        }
+        if (validCount <= 1) {
+            return this.parent.getErrorStrings()[CommonErrors.DivZero];
+        }
+        if (validCount === 2) {
+            return 1;
+        }
+        var meanArray = this.getMeanArray(xValues, yValues);
+        var meanX = meanArray[0];
+        var meanY = meanArray[1];
+        var correlation = this.getCorrelation(xValues, yValues, meanX, meanY);
+        return Math.pow(correlation, 2);
+    };
+    /**
+     * @hidden
+     * @param {string[]} xValues - specify the x values
+     * @param {string[]} yValues - specify the y values
+     * @param {number} meanX - specify the mean of x values
+     * @param {number} meanY - specify the mean of y values
+     * @returns {number} - Returns correlation value
+     */
+    /**
+     * @hidden
+     * @param {string[]} xValues - specify the x values
+     * @param {string[]} yValues - specify the y values
+     * @param {number} meanX - specify the mean of x values
+     * @param {number} meanY - specify the mean of y values
+     * @returns {number} - Returns correlation value
+     */
+    StatisticalAdvancedFormulas.prototype.getCorrelation = function (xValues, yValues, meanX, meanY) {
+        var numerator = 0;
+        var denominatorX = 0;
+        var denominatorY = 0;
+        var diffY;
+        var diffX;
+        for (var i = 0; i < xValues.length; i++) {
+            if (isNumber(xValues[i]) && isNumber(yValues[i])) {
+                diffX = Number(xValues[i]) - meanX;
+                diffY = Number(yValues[i]) - meanY;
+                numerator += diffX * diffY;
+                denominatorX += Math.pow(diffX, 2);
+                denominatorY += Math.pow(diffY, 2);
+            }
+        }
+        var correlation = numerator / Math.sqrt(denominatorX * denominatorY);
+        return correlation;
+    };
+    /**
+     * @hidden
+     * @param {string[]} xValues - specify the x values
+     * @param {string[]} yValues - specify the y values
+     * @returns {number[]} meanX - returns array of mean values of x and y values
+     */
+    /**
+     * @hidden
+     * @param {string[]} xValues - specify the x values
+     * @param {string[]} yValues - specify the y values
+     * @returns {number[]} meanX - returns array of mean values of x and y values
+     */
+    StatisticalAdvancedFormulas.prototype.getMeanArray = function (xValues, yValues) {
+        var count = 0;
+        var sumX = 0;
+        var sumY = 0;
+        var meanX = 0;
+        var meanY = 0;
+        for (var i = 0; i < xValues.length; i++) {
+            if (isNumber(xValues[i]) && isNumber(yValues[i])) {
+                sumX += Number(xValues[i]);
+                sumY += Number(yValues[i]);
+                count++;
+            }
+        }
+        meanX = sumX / count;
+        meanY = sumY / count;
+        return [meanX, meanY];
+    };
+    StatisticalAdvancedFormulas.prototype.getDataCollection = function (cells) {
+        var cellsData = [];
+        for (var i = 0, len = cells.length; i < len; i++) {
+            cellsData.push(this.parent.getValueFromArg(cells[i]));
+        }
+        return cellsData;
+    };
+    return StatisticalAdvancedFormulas;
+}(FormulaModuleBase));
+export { StatisticalAdvancedFormulas };