@syncfusion/ej2-calculate 35.1.37

package/src/formulas/statistical.d.ts

@@ -0,0 +1,135 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Core descriptive statistics: averages, counts, min/max, and basic range summaries.
+ *
+ * Registers 11 functions including AVERAGE, AVERAGEIF, AVERAGEA, AVERAGEIFS, COUNT, and others.
+ *
+ * @hidden
+ */
+export declare class StatisticalFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * The sum of the numbers divided by how many numbers are being averaged.
+     *
+     * Excel: `AVERAGE(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed text result or an Excel error token such as `#VALUE!`.
+     *
+     * @example
+     * ```ts
+     * engine.computeFormula('=AVERAGE(1,2,3)');
+     * ```
+     */
+    ComputeAVERAGE(...args: string[]): string;
+    /**
+     * Computes the average of the numbers in a range that meet the supplied criteria.
+     *
+     * Excel: `AVERAGEIF(...)`.
+     *
+     * @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`.
+     */
+    ComputeAVERAGEIF(...args: string[]): string | number;
+    /**
+     * Calculates the average of values in the list of arguments.Arguments can be numbers, names, arrays or references.
+     *
+     * Excel: `AVERAGEA(...)`.
+     *
+     * @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`.
+     */
+    ComputeAVERAGEA(...args: string[]): number | string;
+    private processLogicalCellValue;
+    /**
+     * Conditionally returns the average of the contents of cells for the set of ranges.
+     *
+     * Excel: `AVERAGEIFS(...)`.
+     *
+     * @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`.
+     */
+    ComputeAVERAGEIFS(...args: string[]): number | string;
+    /**
+     * Counts the numbers in the list of arguments, exclude text entries.
+     *
+     * Excel: `COUNT(...)`.
+     *
+     * @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`.
+     */
+    ComputeCOUNT(...args: string[]): number | string;
+    /**
+     * Counts the non-empty values in the list of arguments.
+     *
+     * Excel: `COUNTA(...)`.
+     *
+     * @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`.
+     */
+    ComputeCOUNTA(...args: string[]): number | string;
+    /**
+     * Counts the number of cells in a range that meet a specified condition.
+     *
+     * Excel: `COUNTIF(...)`.
+     *
+     * @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`.
+     */
+    ComputeCOUNTIF(...args: string[]): number | string;
+    /**
+     * Counts the number of times each cells in all the ranges that meet the specific conditions.
+     *
+     * Excel: `COUNTIFS(...)`.
+     *
+     * @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`.
+     */
+    ComputeCOUNTIFS(...args: string[]): number | string;
+    /**
+     * Returns the number of empty cells in a specified range of cells.
+     *
+     * Excel: `COUNTBLANK(...)`.
+     *
+     * @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`.
+     */
+    ComputeCOUNTBLANK(...args: string[]): string | number;
+    /**
+     * Returns the smaller number in set of arguments.
+     *
+     * Excel: `MIN(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed text result or an Excel error token such as `#VALUE!`.
+     */
+    ComputeMIN(...args: string[]): string;
+    /**
+     * Returns the largest number in set of arguments.
+     *
+     * Excel: `MAX(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed text result or an Excel error token such as `#VALUE!`.
+     */
+    ComputeMAX(...args: string[]): string;
+}

package/src/formulas/statistical.js

@@ -0,0 +1,542 @@
+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';
+/**
+ * Core descriptive statistics: averages, counts, min/max, and basic range summaries.
+ *
+ * Registers 11 functions including AVERAGE, AVERAGEIF, AVERAGEA, AVERAGEIFS, COUNT, and others.
+ *
+ * @hidden
+ */
+var StatisticalFormulas = /** @class */ (function (_super) {
+    __extends(StatisticalFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function StatisticalFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'AVERAGE', category: 'Statistical', description: 'The sum of the numbers divided by how many numbers are being averaged.' },
+            { formulaName: 'AVERAGEIF', category: 'Statistical', description: 'Computes the average of the numbers in a range that meet the supplied criteria.' },
+            { formulaName: 'AVERAGEA', category: 'Statistical', description: 'Calculates the average of values in the list of arguments.Arguments can be numbers, names, arrays or references.' },
+            { formulaName: 'AVERAGEIFS', category: 'Statistical', description: 'Conditionally returns the average of the contents of cells for the set of ranges.' },
+            { formulaName: 'COUNT', category: 'Statistical', description: 'Counts the numbers in the list of arguments, exclude text entries.' },
+            { formulaName: 'COUNTA', category: 'Statistical', description: 'Counts the non-empty values in the list of arguments.' },
+            { formulaName: 'COUNTIF', category: 'Statistical', description: 'Counts the number of cells in a range that meet a specified condition.' },
+            { formulaName: 'COUNTIFS', category: 'Statistical', description: 'Counts the number of times each cells in all the ranges that meet the specific conditions.' },
+            { formulaName: 'COUNTBLANK', category: 'Statistical', description: 'Returns the number of empty cells in a specified range of cells.' },
+            { formulaName: 'MIN', category: 'Statistical', description: 'Returns the smaller number in set of arguments.' },
+            { formulaName: 'MAX', category: 'Statistical', description: 'Returns the largest number in set of arguments.' }
+        ];
+        return _this;
+    }
+    /**
+     * The sum of the numbers divided by how many numbers are being averaged.
+     *
+     * Excel: `AVERAGE(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed text result or an Excel error token such as `#VALUE!`.
+     *
+     * @example
+     * ```ts
+     * engine.computeFormula('=AVERAGE(1,2,3)');
+     * ```
+     */
+    StatisticalFormulas.prototype.ComputeAVERAGE = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var isSubtotalFormula = false;
+        if (args.length) {
+            var lastArgument = args[args.length - 1];
+            if (lastArgument === 'isSubtotal') {
+                isSubtotalFormula = true;
+                args.pop();
+            }
+        }
+        if (isNullOrUndefined(args) || (args.length === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        var argArr = args;
+        for (var i = 0; i < argArr.length; i++) {
+            if (argArr[i].indexOf(':') > -1) {
+                if (argArr[i].indexOf(this.parent.tic) > -1) {
+                    return this.parent.getErrorStrings()[CommonErrors.Value];
+                }
+            }
+        }
+        return this.parent.calculateAvg(argArr, isSubtotalFormula);
+    };
+    /**
+     * Computes the average of the numbers in a range that meet the supplied criteria.
+     *
+     * Excel: `AVERAGEIF(...)`.
+     *
+     * @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`.
+     */
+    StatisticalFormulas.prototype.ComputeAVERAGEIF = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var argList = args;
+        if (argList[0].indexOf(':') < 0 && !this.parent.isCellReference(argList[0])) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.ImproperFormula];
+        }
+        var resultVal = this.parent.computeSumIfAndAvgIf(args, true);
+        if (resultVal[1] === 0 || resultVal[0].toString() === 'NaN') {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.Div];
+        }
+        if (typeof resultVal === 'string' && (this.parent.formulaErrorStrings.indexOf(resultVal)
+            || this.parent.getErrorStrings().indexOf(resultVal))) {
+            return resultVal;
+        }
+        return this.parent.parseFloat(resultVal[0]) / this.parent.parseFloat(resultVal[1]);
+    };
+    /**
+     * Calculates the average of values in the list of arguments.Arguments can be numbers, names, arrays or references.
+     *
+     * Excel: `AVERAGEA(...)`.
+     *
+     * @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`.
+     */
+    StatisticalFormulas.prototype.ComputeAVERAGEA = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || (args.length === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var argArrs = args;
+        var cellCol;
+        var result = 0;
+        var cellValue;
+        var value;
+        var length = 0;
+        var parseValue;
+        for (var k = 0; k < argArrs.length; k++) {
+            if (this.parent.isCellReference(argArrs[k])) {
+                if (argArrs[k].indexOf(':') > -1) {
+                    cellCol = this.parent.getCellCollection(argArrs[k].split(this.parent.tic).join(''));
+                    for (var j = 0; j < cellCol.length; j++) {
+                        cellValue = this.parent.getValueFromArg(cellCol[j]);
+                        cellValue = this.processLogicalCellValue(cellValue);
+                        if (this.parent.getErrorStrings().indexOf(cellValue) > -1) {
+                            return cellValue;
+                        }
+                        else if (isNullOrUndefined(cellValue) || cellValue === '') {
+                            continue;
+                        }
+                        parseValue = this.parent.parseFloat(cellValue);
+                        cellValue = !isNaN(parseValue) ? parseValue : 0;
+                        result += cellValue;
+                        length = length + 1;
+                    }
+                }
+                else {
+                    cellValue = this.parent.getValueFromArg(argArrs[k]);
+                    cellValue = this.processLogicalCellValue(cellValue);
+                    if (this.parent.getErrorStrings().indexOf(cellValue) > -1) {
+                        return cellValue;
+                    }
+                    else if (isNullOrUndefined(cellValue) || cellValue === '') {
+                        continue;
+                    }
+                    parseValue = this.parent.parseFloat(cellValue);
+                    cellValue = !isNaN(parseValue) ? parseValue : 0;
+                    result += cellValue;
+                    length = length + 1;
+                }
+            }
+            else {
+                if (argArrs[k].indexOf(this.parent.tic) > -1) {
+                    if (isNaN(this.parent.parseFloat(argArrs[k].split(this.parent.tic).join(''))) ||
+                        argArrs[k].split(this.parent.tic).join('').trim() === '') {
+                        return this.parent.getErrorStrings()[CommonErrors.Value];
+                    }
+                }
+                argArrs[k] = this.processLogicalCellValue(argArrs[k]);
+                value = this.parent.getValueFromArg(argArrs[k].split(this.parent.tic).join(''));
+                if (this.parent.getErrorStrings().indexOf(value) > -1) {
+                    return value;
+                }
+                result += this.parent.parseFloat(value);
+                length = length + 1;
+            }
+        }
+        if (length === 0) {
+            return this.parent.getErrorStrings()[CommonErrors.DivZero];
+        }
+        return result / length;
+    };
+    StatisticalFormulas.prototype.processLogicalCellValue = function (cellValue) {
+        var value = cellValue;
+        if (value.toUpperCase() === this.parent.trueValue) {
+            value = '1';
+        }
+        else if (value.toUpperCase() === this.parent.falseValue) {
+            value = '0';
+        }
+        return value;
+    };
+    /**
+     * Conditionally returns the average of the contents of cells for the set of ranges.
+     *
+     * Excel: `AVERAGEIFS(...)`.
+     *
+     * @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`.
+     */
+    StatisticalFormulas.prototype.ComputeAVERAGEIFS = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var sum = this.calculateIFS(args, this.parent.trueValue);
+        return sum;
+    };
+    /**
+     * Counts the numbers in the list of arguments, exclude text entries.
+     *
+     * Excel: `COUNT(...)`.
+     *
+     * @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`.
+     */
+    StatisticalFormulas.prototype.ComputeCOUNT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var isSubtotalFormula = false;
+        if (args.length && args[args.length - 1] === 'isSubtotal') {
+            isSubtotalFormula = true;
+            args.pop();
+        }
+        if (isNullOrUndefined(args) || (args.length === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var argArr = args;
+        var argVal;
+        var cellColl;
+        var result = 0;
+        var cellValue;
+        var value;
+        for (var i = 0; i < argArr.length; i++) {
+            argVal = argArr[i];
+            if (this.parent.isCellReference(argVal)) {
+                if (argVal.indexOf(':') > -1) {
+                    cellColl = this.parent.getCellCollection(argVal.split(this.parent.tic).join(''));
+                    for (var j = 0; j < cellColl.length; j++) {
+                        cellValue = !isSubtotalFormula ? this.parent.getValueFromArg(cellColl[j]) :
+                            this.parent.getValueFromArg(cellColl[j], null, null, true);
+                        if (isSubtotalFormula && cellValue.includes('SUBTOTAL(')) {
+                            continue;
+                        }
+                        if (!isNaN(this.parent.parseFloat(cellValue))) {
+                            if (argVal.length > 0 && cellValue.trim() !== '') {
+                                result++;
+                            }
+                        }
+                    }
+                }
+                else {
+                    cellValue = !isSubtotalFormula ? this.parent.getValueFromArg(argVal) :
+                        this.parent.getValueFromArg(argVal, null, null, true);
+                    if (isSubtotalFormula && cellValue.includes('SUBTOTAL(')) {
+                        continue;
+                    }
+                    if (!isNaN(this.parent.parseFloat(cellValue))) {
+                        if (argVal.length > 0 && cellValue.trim() !== '') {
+                            result++;
+                        }
+                    }
+                }
+            }
+            else {
+                value = this.parent.getValueFromArg(argVal).split(this.parent.tic).join('');
+                if (argVal.length === 0 && value.trim() === '') {
+                    result++;
+                }
+                else if (!isNaN(this.parent.parseFloat(value)) || argVal === this.parent.trueValue || argVal === this.parent.falseValue) {
+                    if (argVal.length > 0 && argVal.trim() !== '' && value.trim() !== '') {
+                        result++;
+                    }
+                }
+            }
+        }
+        return result;
+    };
+    /**
+     * Counts the non-empty values in the list of arguments.
+     *
+     * Excel: `COUNTA(...)`.
+     *
+     * @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`.
+     */
+    StatisticalFormulas.prototype.ComputeCOUNTA = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var isSubtotalFormula = false;
+        if (args.length) {
+            var lastArgument = args[args.length - 1];
+            if (lastArgument === 'isSubtotal') {
+                isSubtotalFormula = true;
+                args.pop();
+            }
+        }
+        if (isNullOrUndefined(args) || (args.length === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var argArr = args;
+        var cellColl;
+        var result = 0;
+        var cellValue;
+        var value;
+        for (var i = 0; i < argArr.length; i++) {
+            if (this.parent.isCellReference(argArr[i])) {
+                if (argArr[i].indexOf(':') > -1) {
+                    cellColl = this.parent.getCellCollection(argArr[i].split(this.parent.tic).join(''));
+                    for (var j = 0; j < cellColl.length; j++) {
+                        cellValue = !isSubtotalFormula ? this.parent.getValueFromArg(cellColl[j]) :
+                            this.parent.getValueFromArg(cellColl[j], null, null, true);
+                        if (isSubtotalFormula && cellValue.includes('SUBTOTAL(')) {
+                            continue;
+                        }
+                        if (cellValue.length > 0) {
+                            result++;
+                        }
+                    }
+                }
+                else {
+                    cellValue = !isSubtotalFormula ? this.parent.getValueFromArg(argArr[i]) :
+                        this.parent.getValueFromArg(argArr[i], null, null, true);
+                    if (isSubtotalFormula && cellValue.includes('SUBTOTAL(')) {
+                        continue;
+                    }
+                    if (cellValue.length > 0) {
+                        result++;
+                    }
+                }
+            }
+            else {
+                value = this.parent.getValueFromArg(argArr[i]).split(this.parent.tic).join('');
+                if (value.length > 0) {
+                    result++;
+                }
+                else if (value.length === 0 && value.trim() === '') {
+                    result++;
+                }
+            }
+        }
+        return result;
+    };
+    /**
+     * Counts the number of cells in a range that meet a specified condition.
+     *
+     * Excel: `COUNTIF(...)`.
+     *
+     * @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`.
+     */
+    StatisticalFormulas.prototype.ComputeCOUNTIF = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var argArr = args;
+        if (isNullOrUndefined(args) || args[0] === '' || argArr.length !== 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        if (argArr[0].indexOf(':') < 0 && !this.parent.isCellReference(argArr[0])) {
+            return this.parent.getErrorStrings()[CommonErrors.Name];
+        }
+        var cellColl;
+        var result = 0;
+        var cellValue;
+        var stack = [];
+        var op = 'equal';
+        if (argArr[1] === '') {
+            return 0;
+        }
+        var isStringVal = argArr[1].startsWith(this.parent.tic) && argArr[1].endsWith(this.parent.tic);
+        var condition = this.parent.getANDComputedValue(argArr[1]);
+        var isAsterisk = condition.includes('*');
+        var isAsteriskOnly = condition === '*' || condition === '<>*';
+        var criteriaValue = isAsterisk && !isAsteriskOnly ? condition.replace(/\*/g, '').trim() : condition;
+        var isCellReferenceValue = false;
+        if (!isStringVal && this.parent.isCellReference(criteriaValue)) {
+            criteriaValue = this.parent.getValueFromArg(criteriaValue);
+            isCellReferenceValue = true;
+        }
+        if (isAsterisk && !isAsteriskOnly) {
+            var asteriskIndex = condition.indexOf('*');
+            if (condition[0] === '*') {
+                criteriaValue = '*' + criteriaValue;
+            }
+            if (condition[condition.length - 1] === '*') {
+                criteriaValue += '*';
+            }
+            if (asteriskIndex > 0 && asteriskIndex < condition.length - 1) {
+                criteriaValue = condition.substring(0, asteriskIndex) + '*' + condition.substring(asteriskIndex + 1);
+            }
+        }
+        condition = criteriaValue;
+        if (condition.startsWith('<=')) {
+            op = 'lessEq';
+            condition = condition.substring(2);
+        }
+        else if (condition.startsWith('>=')) {
+            op = 'greaterEq';
+            condition = condition.substring(2);
+        }
+        else if (condition.startsWith('<>')) {
+            op = 'notEq';
+            condition = condition.substring(2);
+        }
+        else if (condition.startsWith('<')) {
+            op = 'less';
+            condition = condition.substring(1);
+        }
+        else if (condition.startsWith('>')) {
+            op = 'greater';
+            condition = condition.substring(1);
+        }
+        else if (condition.startsWith('=')) {
+            op = 'equal';
+            condition = condition.substring(1);
+        }
+        var isWildCardCondition = condition.indexOf('*') > -1 || condition.indexOf('?') > -1;
+        if ((!isStringVal && this.parent.isCellReference(condition) && !isCellReferenceValue) || condition.includes(this.parent.arithMarker)
+            || (condition.includes(this.parent.getParseDecimalSeparator()) && !isWildCardCondition)) {
+            condition = this.parent.getValueFromArg(condition);
+        }
+        if (this.parent.isCellReference(argArr[0])) {
+            cellColl = this.parent.getCellCollection(argArr[0].split(this.parent.tic).join(''));
+            for (var j = 0; j < cellColl.length; j++) {
+                cellValue = this.parent.getValueFromArg(cellColl[j]);
+                if (isWildCardCondition) {
+                    cellValue = this.parent.findWildCardValue(condition.toLowerCase(), cellValue.toLowerCase());
+                }
+                stack.push(cellValue);
+                stack.push(condition);
+                if (this.parent.processLogical(stack, op) === this.parent.trueValue) {
+                    result++;
+                }
+            }
+        }
+        return result;
+    };
+    /**
+     * Counts the number of times each cells in all the ranges that meet the specific conditions.
+     *
+     * Excel: `COUNTIFS(...)`.
+     *
+     * @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`.
+     */
+    StatisticalFormulas.prototype.ComputeCOUNTIFS = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var sum = this.parent.computeCountIfsFormulas(args);
+        return sum;
+    };
+    /**
+     * Returns the number of empty cells in a specified range of cells.
+     *
+     * Excel: `COUNTBLANK(...)`.
+     *
+     * @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`.
+     */
+    StatisticalFormulas.prototype.ComputeCOUNTBLANK = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var result = 0;
+        if (args.length !== 1 || isNullOrUndefined(args) || !this.parent.isCellReference(args[0])) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        else if (args[0] === '') {
+            return this.parent.getErrorStrings()[CommonErrors.Value];
+        }
+        else {
+            var cellRange = this.parent.getCellCollection(args[0]);
+            for (var i = 0; i < cellRange.length; i++) {
+                if (this.parent.getValueFromArg(cellRange[i]) === '') {
+                    result++;
+                }
+            }
+        }
+        return result;
+    };
+    /**
+     * Returns the smaller number in set of arguments.
+     *
+     * Excel: `MIN(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed text result or an Excel error token such as `#VALUE!`.
+     */
+    StatisticalFormulas.prototype.ComputeMIN = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.parent.computeMinMax(args, 'min');
+    };
+    /**
+     * Returns the largest number in set of arguments.
+     *
+     * Excel: `MAX(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed text result or an Excel error token such as `#VALUE!`.
+     */
+    StatisticalFormulas.prototype.ComputeMAX = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.parent.computeMinMax(args, 'max');
+    };
+    return StatisticalFormulas;
+}(FormulaModuleBase));
+export { StatisticalFormulas };