@syncfusion/ej2-calculate 35.1.37

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

@@ -0,0 +1,76 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Number-theoretic helpers such as GCD, LCM, and integer decomposition utilities.
+ *
+ * Registered functions: GCD, LCM, MROUND, COMBIN, SUMSQ.
+ *
+ * @hidden
+ */
+export declare class MathNumberFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    private collectNumbers;
+    private gcd2;
+    /**
+     * Returns the greatest common divisor.
+     *
+     * Excel: `GCD(...)`.
+     *
+     * @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('=GCD(1)');
+     * ```
+     */
+    ComputeGCD(...args: string[]): string | number;
+    /**
+     * Returns the least common multiple.
+     *
+     * Excel: `LCM(...)`.
+     *
+     * @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`.
+     */
+    ComputeLCM(...args: string[]): string | number;
+    /**
+     * Returns a number rounded to the desired multiple.
+     *
+     * Excel: `MROUND(...)`.
+     *
+     * @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`.
+     */
+    ComputeMROUND(...args: string[]): string | number;
+    /**
+     * Returns the number of combinations for a given number of objects.
+     *
+     * Excel: `COMBIN(...)`.
+     *
+     * @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`.
+     */
+    ComputeCOMBIN(...args: string[]): string | number;
+    /**
+     * Returns the sum of the squares of the arguments.
+     *
+     * Excel: `SUMSQ(...)`.
+     *
+     * @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`.
+     */
+    ComputeSUMSQ(...args: string[]): string | number;
+}

package/src/formulas/math-number.js

@@ -0,0 +1,261 @@
+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';
+/**
+ * Number-theoretic helpers such as GCD, LCM, and integer decomposition utilities.
+ *
+ * Registered functions: GCD, LCM, MROUND, COMBIN, SUMSQ.
+ *
+ * @hidden
+ */
+var MathNumberFormulas = /** @class */ (function (_super) {
+    __extends(MathNumberFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function MathNumberFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'GCD', category: 'Math & Trig', description: 'Returns the greatest common divisor.' },
+            { formulaName: 'LCM', category: 'Math & Trig', description: 'Returns the least common multiple.' },
+            { formulaName: 'MROUND', category: 'Math & Trig', description: 'Returns a number rounded to the desired multiple.' },
+            { formulaName: 'COMBIN', category: 'Math & Trig', description: 'Returns the number of combinations for a given number of objects.' },
+            { formulaName: 'SUMSQ', category: 'Math & Trig', description: 'Returns the sum of the squares of the arguments.' }
+        ];
+        return _this;
+    }
+    MathNumberFormulas.prototype.collectNumbers = function (args) {
+        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 !== '' && this.parent.isNumber(val)) {
+                        nums.push(this.parent.parseFloat(val));
+                    }
+                }
+            }
+            else {
+                var num = this.resolveNumberArg(arg);
+                if (typeof num === 'string') {
+                    return num;
+                }
+                nums.push(num);
+            }
+        }
+        return nums;
+    };
+    MathNumberFormulas.prototype.gcd2 = function (a, b) {
+        var x = Math.abs(Math.floor(a));
+        var y = Math.abs(Math.floor(b));
+        while (y) {
+            var t = y;
+            y = x % y;
+            x = t;
+        }
+        return x;
+    };
+    /**
+     * Returns the greatest common divisor.
+     *
+     * Excel: `GCD(...)`.
+     *
+     * @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('=GCD(1)');
+     * ```
+     */
+    MathNumberFormulas.prototype.ComputeGCD = 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.collectNumbers(args);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length === 0) {
+            return errCollection[CommonErrors.Value];
+        }
+        for (var i = 0; i < nums.length; i++) {
+            if (nums[i] < 0) {
+                return errCollection[CommonErrors.Num];
+            }
+        }
+        var result = Math.floor(nums[0]);
+        for (var i = 1; i < nums.length; i++) {
+            result = this.gcd2(result, nums[i]);
+        }
+        return result.toString();
+    };
+    /**
+     * Returns the least common multiple.
+     *
+     * Excel: `LCM(...)`.
+     *
+     * @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`.
+     */
+    MathNumberFormulas.prototype.ComputeLCM = 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.collectNumbers(args);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length === 0) {
+            return errCollection[CommonErrors.Value];
+        }
+        for (var i = 0; i < nums.length; i++) {
+            if (nums[i] < 0) {
+                return errCollection[CommonErrors.Num];
+            }
+        }
+        var result = Math.floor(nums[0]);
+        for (var i = 1; i < nums.length; i++) {
+            var n = Math.floor(nums[i]);
+            result = result === 0 || n === 0 ? 0 : Math.abs(result * n) / this.gcd2(result, n);
+        }
+        return result.toString();
+    };
+    /**
+     * Returns a number rounded to the desired multiple.
+     *
+     * Excel: `MROUND(...)`.
+     *
+     * @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`.
+     */
+    MathNumberFormulas.prototype.ComputeMROUND = 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 number = this.resolveNumberArg(args[0]);
+        var multiple = this.resolveNumberArg(args[1]);
+        if (typeof number === 'string') {
+            return number;
+        }
+        if (typeof multiple === 'string') {
+            return multiple;
+        }
+        if (multiple === 0) {
+            return '0';
+        }
+        if ((number > 0 && multiple < 0) || (number < 0 && multiple > 0)) {
+            return errCollection[CommonErrors.Num];
+        }
+        return (Math.round(number / multiple) * multiple).toString();
+    };
+    /**
+     * Returns the number of combinations for a given number of objects.
+     *
+     * Excel: `COMBIN(...)`.
+     *
+     * @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`.
+     */
+    MathNumberFormulas.prototype.ComputeCOMBIN = 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 nArg = this.resolveNumberArg(args[0]);
+        var kArg = this.resolveNumberArg(args[1]);
+        if (typeof nArg === 'string') {
+            return nArg;
+        }
+        if (typeof kArg === 'string') {
+            return kArg;
+        }
+        var n = Math.floor(nArg);
+        var k = Math.floor(kArg);
+        if (n < 0 || k < 0 || n < k) {
+            return errCollection[CommonErrors.Num];
+        }
+        var result = 1;
+        for (var i = 1; i <= k; i++) {
+            result = result * (n - k + i) / i;
+        }
+        return Math.round(result).toString();
+    };
+    /**
+     * Returns the sum of the squares of the arguments.
+     *
+     * Excel: `SUMSQ(...)`.
+     *
+     * @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`.
+     */
+    MathNumberFormulas.prototype.ComputeSUMSQ = 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.InvalidArguments];
+        }
+        var nums = this.collectNumbers(args);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        var sum = 0;
+        for (var i = 0; i < nums.length; i++) {
+            sum += nums[i] * nums[i];
+        }
+        return sum.toString();
+    };
+    return MathNumberFormulas;
+}(FormulaModuleBase));
+export { MathNumberFormulas };

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

@@ -0,0 +1,115 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Rounding and truncation functions for numeric precision control, including CEILING, FLOOR, ROUND, and TRUNC variants.
+ *
+ * Registers 9 functions including ROUND, ROUNDUP, ROUNDDOWN, FLOOR, CEILING, and others.
+ *
+ * @hidden
+ */
+export declare class MathRoundingFormulas 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 to a specified number of digits.
+     *
+     * Excel: `ROUND(...)`.
+     *
+     * @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('=ROUND(3.1415,2)');
+     * ```
+     */
+    ComputeROUND(...args: string[]): number | string;
+    private preciseRound;
+    /**
+     * Rounds a number away from zero.
+     *
+     * Excel: `ROUNDUP(...)`.
+     *
+     * @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`.
+     */
+    ComputeROUNDUP(...args: string[]): string | number;
+    /**
+     * Rounds a number down, toward zero.
+     *
+     * Excel: `ROUNDDOWN(...)`.
+     *
+     * @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`.
+     */
+    ComputeROUNDDOWN(...args: string[]): string | number;
+    /**
+     * Returns the round a number down to the nearest integer.
+     *
+     * Excel: `FLOOR(...)`.
+     *
+     * @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`.
+     */
+    ComputeFLOOR(...args: string[]): number | string;
+    /**
+     * Returns a number rounded up to a multiple of another number.
+     *
+     * Excel: `CEILING(...)`.
+     *
+     * @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`.
+     */
+    ComputeCEILING(...args: string[]): number | string;
+    /**
+     * Returns a number to the nearest integer.
+     *
+     * Excel: `INT(...)`.
+     *
+     * @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`.
+     */
+    ComputeINT(...args: string[]): string | number;
+    /**
+     * Returns the truncated value of a number to a specified number of decimal places.
+     *
+     * Excel: `TRUNC(...)`.
+     *
+     * @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.
+     */
+    ComputeTRUNC(...args: string[]): boolean | string;
+    /**
+     * Rounds a positive number up and negative number down to the nearest odd integer.
+     *
+     * Excel: `ODD(...)`.
+     *
+     * @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`.
+     */
+    ComputeODD(...args: string[]): string | number;
+    /**
+     * Rounds a positive number up and negative number down to the nearest even integer.
+     *
+     * Excel: `EVEN(...)`.
+     *
+     * @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`.
+     */
+    ComputeEVEN(...args: string[]): string | number;
+}