@syncfusion/ej2-calculate 35.1.37

package/src/formulas/math-aggregate.d.ts

@@ -0,0 +1,74 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Aggregation functions that summarize ranges of numeric values (sums, counts, products, and conditional totals).
+ *
+ * Registered functions: SUM, SUMIF, SUMIFS, SUMPRODUCT, PRODUCT.
+ *
+ * @hidden
+ */
+export declare class MathAggregateFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Sums individual values, cell references or ranges.
+     *
+     * Excel: `SUM(...)`.
+     *
+     * @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('=SUM(A1:A3)');
+     * ```
+     */
+    ComputeSUM(...args: string[]): string | number;
+    /**
+     * It will sum up cells that meet the given criteria.
+     *
+     * Excel: `SUMIF(...)`.
+     *
+     * @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`.
+     */
+    ComputeSUMIF(...args: string[]): string | number;
+    /**
+     * Sums the cells specified by a given set of conditionsor criteria.
+     *
+     * Excel: `SUMIFS(...)`.
+     *
+     * @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`.
+     */
+    ComputeSUMIFS(...args: string[]): string | number;
+    /**
+     * Returns sum of the product of given ranges of arrays.
+     *
+     * Excel: `SUMPRODUCT(...)`.
+     *
+     * @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`.
+     */
+    ComputeSUMPRODUCT(...args: string[]): string | number;
+    /**
+     * Multiplies all the numbers given as arguments and returns the product.
+     *
+     * Excel: `PRODUCT(...)`.
+     *
+     * @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`.
+     */
+    ComputePRODUCT(...args: string[]): string | number;
+}

package/src/formulas/math-aggregate.js

@@ -0,0 +1,376 @@
+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 { FormulaModuleBase } from './formula-module-base';
+/**
+ * Aggregation functions that summarize ranges of numeric values (sums, counts, products, and conditional totals).
+ *
+ * Registered functions: SUM, SUMIF, SUMIFS, SUMPRODUCT, PRODUCT.
+ *
+ * @hidden
+ */
+var MathAggregateFormulas = /** @class */ (function (_super) {
+    __extends(MathAggregateFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function MathAggregateFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'SUM', category: 'Math & Trig', description: 'Sums individual values, cell references or ranges.' },
+            { formulaName: 'SUMIF', category: 'Math & Trig', description: 'It will sum up cells that meet the given criteria.' },
+            { formulaName: 'SUMIFS', category: 'Math & Trig', description: 'Sums the cells specified by a given set of conditionsor criteria.' },
+            { formulaName: 'SUMPRODUCT', category: 'Math & Trig', description: 'Returns sum of the product of given ranges of arrays.' },
+            { formulaName: 'PRODUCT', category: 'Math & Trig', description: 'Multiplies all the numbers given as arguments and returns the product.' }
+        ];
+        return _this;
+    }
+    /**
+     * Sums individual values, cell references or ranges.
+     *
+     * Excel: `SUM(...)`.
+     *
+     * @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('=SUM(A1:A3)');
+     * ```
+     */
+    MathAggregateFormulas.prototype.ComputeSUM = 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 sum = 0;
+        var val;
+        var orgValue;
+        var maxDecimalLength = 0;
+        if (!isNullOrUndefined(args)) {
+            var argArr = args;
+            var setMaxDecimalLength = function (val) {
+                if (val.toString().indexOf('.') > -1) {
+                    maxDecimalLength = Math.max(maxDecimalLength, val.split('.')[1].length);
+                }
+            };
+            for (var i = 0; i < argArr.length; i++) {
+                var argValue = argArr[i].toString();
+                if (argValue.indexOf(':') > -1 && this.parent.isCellReference(argValue)) {
+                    var cellCollection = this.parent.getCellCollection(argValue.split(this.parent.tic).join(''));
+                    for (var j = 0; j < cellCollection.length; j++) {
+                        val = !isSubtotalFormula ? this.parent.getValueFromArg(cellCollection[j]) :
+                            this.parent.getValueFromArg(cellCollection[j], null, null, true);
+                        if (isSubtotalFormula && val.includes('SUBTOTAL(')) {
+                            continue;
+                        }
+                        if (this.parent.getErrorStrings().indexOf(val) > -1) {
+                            return val;
+                        }
+                        if (isNullOrUndefined(val[0]) || isNaN(this.parent.parseFloat(val))) {
+                            continue;
+                        }
+                        setMaxDecimalLength(val);
+                        sum = sum + this.parent.parseFloat(val);
+                    }
+                }
+                else {
+                    if (argArr[i].indexOf(this.parent.tic) > -1) {
+                        if (isNaN(this.parent.parseFloat(argArr[i].split(this.parent.tic).join(''))) ||
+                            argArr[i].split(this.parent.tic).join('').trim() === '') {
+                            return this.parent.getErrorStrings()[CommonErrors.Value];
+                        }
+                    }
+                    if (argArr[i].split(this.parent.tic).join('') === this.parent.trueValue) {
+                        argArr[i] = '1';
+                    }
+                    if (argArr[i].split(this.parent.tic).join('') === this.parent.falseValue) {
+                        argArr[i] = '0';
+                    }
+                    orgValue = !isSubtotalFormula ? this.parent.getValueFromArg(argArr[i].split(this.parent.tic).join('')) :
+                        this.parent.getValueFromArg(argArr[i].split(this.parent.tic).join(''), null, null, true);
+                    if (isSubtotalFormula && orgValue.includes('SUBTOTAL(')) {
+                        continue;
+                    }
+                    if (this.parent.getErrorStrings().indexOf(orgValue) > -1) {
+                        return orgValue;
+                    }
+                    if (isNullOrUndefined(orgValue) || isNaN(this.parent.parseFloat(orgValue))) {
+                        continue;
+                    }
+                    if (orgValue.length > 0) {
+                        setMaxDecimalLength(orgValue);
+                        sum = sum + this.parent.parseFloat(orgValue + '');
+                    }
+                }
+            }
+        }
+        return sum.toString().indexOf('.') > -1 ? sum.toFixed(maxDecimalLength) : sum;
+    };
+    /**
+     * It will sum up cells that meet the given criteria.
+     *
+     * Excel: `SUMIF(...)`.
+     *
+     * @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`.
+     */
+    MathAggregateFormulas.prototype.ComputeSUMIF = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var argArr = args;
+        if (argArr[0].indexOf(':') < 0 && !this.parent.isCellReference(argArr[0]) ||
+            (argArr[2] && argArr[2].indexOf(':') < 0 && !this.parent.isCellReference(argArr[2]))) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.ImproperFormula];
+        }
+        if (argArr.length > 3 || argArr.length < 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var result = this.parent.computeSumIfAndAvgIf(args, false);
+        if (typeof result === 'string' && (this.parent.formulaErrorStrings.indexOf(result)
+            || this.parent.getErrorStrings().indexOf(result))) {
+            return result;
+        }
+        return result[0];
+    };
+    /**
+     * Sums the cells specified by a given set of conditionsor criteria.
+     *
+     * Excel: `SUMIFS(...)`.
+     *
+     * @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`.
+     */
+    MathAggregateFormulas.prototype.ComputeSUMIFS = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var sum = this.calculateIFS(args);
+        return sum;
+    };
+    /**
+     * Returns sum of the product of given ranges of arrays.
+     *
+     * Excel: `SUMPRODUCT(...)`.
+     *
+     * @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`.
+     */
+    MathAggregateFormulas.prototype.ComputeSUMPRODUCT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var _a, _b;
+        if (isNullOrUndefined(args) || (args.length === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        var sum = 0;
+        var count = 0;
+        var index;
+        var mulValues = null;
+        var ranges = args;
+        var len = [];
+        for (var i = 0; i < ranges.length; i++) {
+            var cells = this.parent.getCellCollection(ranges[i]);
+            if (cells[0] === '#REF!') {
+                return this.parent.getErrorStrings()[CommonErrors.Name];
+            }
+            len.push(cells.length);
+        }
+        for (var j = 0; j < len.length; j++) {
+            if (len[j] && len[j + 1] && len[j] !== len[j + 1]) {
+                return this.parent.getErrorStrings()[CommonErrors.Value];
+            }
+        }
+        for (var k = 0; k < ranges.length; ++k) {
+            var range = ranges[k];
+            if (!range.startsWith(this.parent.tic) && this.parent.isCellReference(range)) {
+                var i = range.indexOf(':');
+                var startRow = this.parent.rowIndex(range.substr(0, i));
+                var endRow = this.parent.rowIndex(range.substr(i + 1));
+                if (!(startRow !== -1 || endRow === -1) === (startRow === -1 || endRow !== -1)) {
+                    return this.parent.getErrorStrings()[CommonErrors.Name];
+                }
+                if (startRow > endRow) {
+                    _a = [endRow, startRow], startRow = _a[0], endRow = _a[1];
+                }
+                var col1 = this.parent.colIndex(range.substr(0, i));
+                var col2 = this.parent.colIndex(range.substr(i + 1));
+                if (col1 > col2) {
+                    _b = [col2, col1], col1 = _b[0], col2 = _b[1];
+                }
+                if (mulValues === null) {
+                    count = (endRow - startRow + 1) * (col2 - col1 + 1);
+                    mulValues = [];
+                    for (i = 0; i < count; ++i) {
+                        mulValues[i] = 1; //To create required index.
+                    }
+                }
+                i = 0;
+                for (var row = startRow; row <= endRow; ++row) {
+                    for (var col = col1; col <= col2; ++col) {
+                        var cellRef = this.getSheetReference(range) + this.parent.convertAlpha(col) + (row);
+                        var result = this.parent.getValueFromArg(cellRef);
+                        if (this.parent.getErrorStrings().indexOf(result) > -1) {
+                            return result;
+                        }
+                        if (!isNaN(this.parent.parseFloat(result))) {
+                            //To return #VALUE! error when array dimensions are mismatched.
+                            if (isNaN(mulValues[i])) {
+                                return this.parent.getErrorStrings()[CommonErrors.Name];
+                            }
+                            mulValues[i] = mulValues[i] * this.parent.parseFloat(result);
+                        }
+                        else {
+                            mulValues[i] = 0;
+                        }
+                        i++;
+                    }
+                }
+            }
+            else {
+                var s1 = this.parent.getValueFromArg(range);
+                index = s1.indexOf('"');
+                if (this.parent.getErrorStrings().indexOf(s1) > -1) {
+                    return s1;
+                }
+                else if (index > -1) {
+                    return 0;
+                }
+                else {
+                    return this.parent.getErrorStrings()[CommonErrors.Value];
+                }
+            }
+        }
+        for (var i = 0; i < count; ++i) {
+            sum += mulValues[i];
+        }
+        return sum;
+    };
+    /**
+     * Multiplies all the numbers given as arguments and returns the product.
+     *
+     * Excel: `PRODUCT(...)`.
+     *
+     * @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`.
+     */
+    MathAggregateFormulas.prototype.ComputePRODUCT = 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.InvalidArguments];
+        }
+        var product = 1;
+        var val;
+        var orgValue;
+        var argsHit = true;
+        var parseVal;
+        if (!isNullOrUndefined(args)) {
+            var argArr = args;
+            for (var i = 0; i < argArr.length; i++) {
+                var rangevalue = argArr[i];
+                if (rangevalue.indexOf(':') > -1 && this.parent.isCellReference(rangevalue)) {
+                    var cellCollection = this.parent.getCellCollection(rangevalue);
+                    for (var j = 0; j < cellCollection.length; j++) {
+                        val = !isSubtotalFormula ? this.parent.getValueFromArg(cellCollection[j]) :
+                            this.parent.getValueFromArg(cellCollection[j], null, null, true);
+                        if (isSubtotalFormula && val.includes('SUBTOTAL(')) {
+                            continue;
+                        }
+                        if (!isNumber(val)) {
+                            continue;
+                        }
+                        if (this.parent.getErrorStrings().indexOf(val) > -1) {
+                            return val;
+                        }
+                        parseVal = this.parent.parseFloat(val);
+                        if (!isNaN(parseVal)) {
+                            if (val.length > 0) {
+                                product = product * parseVal;
+                                argsHit = false;
+                            }
+                        }
+                    }
+                }
+                else if (rangevalue.indexOf(':') === -1 && this.parent.isCellReference(rangevalue)) {
+                    orgValue = !isSubtotalFormula ? this.parent.getValueFromArg(argArr[i]) :
+                        this.parent.getValueFromArg(argArr[i], null, null, true);
+                    if (isSubtotalFormula && orgValue.includes('SUBTOTAL(')) {
+                        continue;
+                    }
+                    if (!isNumber(orgValue)) {
+                        continue;
+                    }
+                    if (this.parent.getErrorStrings().indexOf(orgValue) > -1) {
+                        return orgValue;
+                    }
+                }
+                else {
+                    orgValue = argArr[i];
+                    var isEmptyStr = orgValue.indexOf(this.parent.tic) > -1 && orgValue.split(this.parent.tic).join('').trim() === '';
+                    if (isEmptyStr || (argArr[i].indexOf(this.parent.tic) > -1 && isNaN(this.parent.parseFloat(orgValue.split(this.parent.tic).join(''))))) {
+                        return this.parent.getErrorStrings()[CommonErrors.Value];
+                    }
+                    orgValue = this.parent.getValueFromArg(argArr[i].split(this.parent.tic).join(''));
+                    orgValue = (orgValue === this.parent.trueValue) ? '1' : (orgValue === this.parent.falseValue) ? '0' : orgValue.split(this.parent.tic).join('');
+                    if (this.parent.getErrorStrings().indexOf(orgValue) > -1) {
+                        return orgValue;
+                    }
+                }
+                parseVal = this.parent.parseFloat(orgValue);
+                if (!isNaN(parseVal)) {
+                    if (orgValue.length > 0) {
+                        product = product * parseVal;
+                        argsHit = false;
+                    }
+                }
+            }
+        }
+        return argsHit ? '0' : product.toString();
+    };
+    return MathAggregateFormulas;
+}(FormulaModuleBase));
+export { MathAggregateFormulas };

package/src/formulas/math-ceiling-ecma.d.ts

@@ -0,0 +1,42 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * ECMA-376 ceiling rounding variants (ISO.CEILING and ECMA.CEILING) with significance-based rounding rules.
+ *
+ * Registered functions: ISO.CEILING, ECMA.CEILING.
+ *
+ * @hidden
+ */
+export declare class MathCeilingEcmaFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Rounds a number up to the nearest integer or multiple of significance.
+     *
+     * Excel: `ISO.CEILING(...)`.
+     *
+     * @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('=ISO.CEILING(1)');
+     * ```
+     */
+    ['ComputeISO.CEILING'](...args: string[]): string | number;
+    /**
+     * Rounds a number up, away from zero, to the nearest multiple of significance.
+     *
+     * Excel: `ECMA.CEILING(...)`.
+     *
+     * @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`.
+     */
+    ['ComputeECMA.CEILING'](...args: string[]): string | number;
+}

package/src/formulas/math-ceiling-ecma.js

@@ -0,0 +1,123 @@
+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';
+/**
+ * ECMA-376 ceiling rounding variants (ISO.CEILING and ECMA.CEILING) with significance-based rounding rules.
+ *
+ * Registered functions: ISO.CEILING, ECMA.CEILING.
+ *
+ * @hidden
+ */
+var MathCeilingEcmaFormulas = /** @class */ (function (_super) {
+    __extends(MathCeilingEcmaFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function MathCeilingEcmaFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'ISO.CEILING', category: 'Math & Trig', description: 'Rounds a number up to the nearest integer or multiple of significance.' },
+            { formulaName: 'ECMA.CEILING', category: 'Math & Trig', description: 'Rounds a number up, away from zero, to the nearest multiple of significance.' }
+        ];
+        return _this;
+    }
+    /**
+     * Rounds a number up to the nearest integer or multiple of significance.
+     *
+     * Excel: `ISO.CEILING(...)`.
+     *
+     * @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('=ISO.CEILING(1)');
+     * ```
+     */
+    MathCeilingEcmaFormulas.prototype['ComputeISO.CEILING'] = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length < 1 || args.length > 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var x = this.resolveNumberArg(args[0]);
+        if (typeof x === 'string') {
+            return x;
+        }
+        var sig = 1;
+        if (args.length === 2 && args[1] !== '') {
+            var s = this.resolveNumberArg(args[1]);
+            if (typeof s === 'string') {
+                return s;
+            }
+            sig = Math.abs(s);
+        }
+        if (x === 0 || sig === 0) {
+            return '0';
+        }
+        var result = Math.ceil(x / sig) * sig;
+        return result.toString();
+    };
+    /**
+     * Rounds a number up, away from zero, to the nearest multiple of significance.
+     *
+     * Excel: `ECMA.CEILING(...)`.
+     *
+     * @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`.
+     */
+    MathCeilingEcmaFormulas.prototype['ComputeECMA.CEILING'] = 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 x = this.resolveNumberArg(args[0]);
+        var sig = this.resolveNumberArg(args[1]);
+        if (typeof x === 'string') {
+            return x;
+        }
+        if (typeof sig === 'string') {
+            return sig;
+        }
+        if (x === 0 || sig === 0) {
+            return '0';
+        }
+        if (x > 0 && sig < 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var result;
+        if (x > 0) {
+            result = Math.ceil(x / sig) * sig;
+        }
+        else if (sig > 0) {
+            result = Math.ceil(x / sig) * sig;
+        }
+        else {
+            result = Math.floor(x / sig) * sig;
+        }
+        return result.toString();
+    };
+    return MathCeilingEcmaFormulas;
+}(FormulaModuleBase));
+export { MathCeilingEcmaFormulas };