@syncfusion/ej2-calculate 35.1.37

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

@@ -0,0 +1,75 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Combinatorial functions for permutations, combinations, and greatest-common-divisor calculations.
+ *
+ * Registered functions: FACTDOUBLE, MULTINOMIAL, PERMUT, SERIESSUM, ROMAN.
+ *
+ * @hidden
+ */
+export declare class MathCombinatoricsFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns the double factorial of a number.
+     *
+     * Excel: `FACTDOUBLE(...)`.
+     *
+     * @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('=FACTDOUBLE(1)');
+     * ```
+     */
+    ComputeFACTDOUBLE(...args: string[]): string | number;
+    /**
+     * Returns the multinomial of a set of numbers.
+     *
+     * Excel: `MULTINOMIAL(...)`.
+     *
+     * @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`.
+     */
+    ComputeMULTINOMIAL(...args: string[]): string | number;
+    /**
+     * Returns the number of permutations for a given number of objects.
+     *
+     * Excel: `PERMUT(...)`.
+     *
+     * @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`.
+     */
+    ComputePERMUT(...args: string[]): string | number;
+    /**
+     * Returns the sum of a power series.
+     *
+     * Excel: `SERIESSUM(...)`.
+     *
+     * @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`.
+     */
+    ComputeSERIESSUM(...args: string[]): string | number;
+    /**
+     * Converts an Arabic numeral to Roman, as text.
+     *
+     * Excel: `ROMAN(...)`.
+     *
+     * @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`.
+     */
+    ComputeROMAN(...args: string[]): string | number;
+    private toRoman;
+}

package/src/formulas/math-combinatorics.js

@@ -0,0 +1,290 @@
+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';
+import { factorial } from './formula-math-helpers';
+/**
+ * Combinatorial functions for permutations, combinations, and greatest-common-divisor calculations.
+ *
+ * Registered functions: FACTDOUBLE, MULTINOMIAL, PERMUT, SERIESSUM, ROMAN.
+ *
+ * @hidden
+ */
+var MathCombinatoricsFormulas = /** @class */ (function (_super) {
+    __extends(MathCombinatoricsFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function MathCombinatoricsFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'FACTDOUBLE', category: 'Math & Trig', description: 'Returns the double factorial of a number.' },
+            { formulaName: 'MULTINOMIAL', category: 'Math & Trig', description: 'Returns the multinomial of a set of numbers.' },
+            { formulaName: 'PERMUT', category: 'Math & Trig', description: 'Returns the number of permutations for a given number of objects.' },
+            { formulaName: 'SERIESSUM', category: 'Math & Trig', description: 'Returns the sum of a power series.' },
+            { formulaName: 'ROMAN', category: 'Math & Trig', description: 'Converts an Arabic numeral to Roman, as text.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns the double factorial of a number.
+     *
+     * Excel: `FACTDOUBLE(...)`.
+     *
+     * @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('=FACTDOUBLE(1)');
+     * ```
+     */
+    MathCombinatoricsFormulas.prototype.ComputeFACTDOUBLE = 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) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var num = this.resolveNumberArg(args[0]);
+        if (typeof num === 'string') {
+            return num;
+        }
+        var n = Math.floor(num);
+        if (n < 0 || n > 300) {
+            return errCollection[CommonErrors.Num];
+        }
+        var result = 1;
+        for (var i = n; i > 0; i -= 2) {
+            result *= i;
+        }
+        return result.toString();
+    };
+    /**
+     * Returns the multinomial of a set of numbers.
+     *
+     * Excel: `MULTINOMIAL(...)`.
+     *
+     * @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`.
+     */
+    MathCombinatoricsFormulas.prototype.ComputeMULTINOMIAL = 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 values = [];
+        for (var i = 0; i < args.length; i++) {
+            var num = this.resolveNumberArg(args[i]);
+            if (typeof num === 'string') {
+                return num;
+            }
+            var n = Math.floor(num);
+            if (n < 0) {
+                return errCollection[CommonErrors.Num];
+            }
+            values.push(n);
+        }
+        var sum = values.reduce(function (a, b) { return a + b; }, 0);
+        var denom = 1;
+        for (var i = 0; i < values.length; i++) {
+            denom *= factorial(values[i]);
+        }
+        var result = factorial(sum) / denom;
+        return result.toString();
+    };
+    /**
+     * Returns the number of permutations for a given number of objects.
+     *
+     * Excel: `PERMUT(...)`.
+     *
+     * @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`.
+     */
+    MathCombinatoricsFormulas.prototype.ComputePERMUT = 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 = 0; i < k; i++) {
+            result *= n - i;
+        }
+        return result.toString();
+    };
+    /**
+     * Returns the sum of a power series.
+     *
+     * Excel: `SERIESSUM(...)`.
+     *
+     * @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`.
+     */
+    MathCombinatoricsFormulas.prototype.ComputeSERIESSUM = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length < 4) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var x = this.resolveNumberArg(args[0]);
+        var n = this.resolveNumberArg(args[1]);
+        var m = this.resolveNumberArg(args[2]);
+        if (typeof x === 'string') {
+            return x;
+        }
+        if (typeof n === 'string') {
+            return n;
+        }
+        if (typeof m === 'string') {
+            return m;
+        }
+        var coeffs = [];
+        for (var i = 3; i < args.length; i++) {
+            var c = this.resolveNumberArg(args[i]);
+            if (typeof c === 'string') {
+                return c;
+            }
+            coeffs.push(c);
+        }
+        var sum = 0;
+        for (var i = 0; i < coeffs.length; i++) {
+            var power = n + i * m;
+            sum += coeffs[i] * Math.pow(x, power);
+        }
+        return sum.toString();
+    };
+    /**
+     * Converts an Arabic numeral to Roman, as text.
+     *
+     * Excel: `ROMAN(...)`.
+     *
+     * @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`.
+     */
+    MathCombinatoricsFormulas.prototype.ComputeROMAN = 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.length > 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var numArg = this.resolveNumberArg(args[0]);
+        if (typeof numArg === 'string') {
+            return numArg;
+        }
+        var form = 0;
+        if (args.length === 2) {
+            var formArg = this.resolveNumberArg(args[1]);
+            if (typeof formArg === 'string') {
+                return formArg;
+            }
+            form = Math.floor(formArg);
+            if (form < 0 || form > 4) {
+                return errCollection[CommonErrors.Value];
+            }
+        }
+        var n = Math.floor(numArg);
+        if (n < 0 || n > 3999) {
+            return errCollection[CommonErrors.Value];
+        }
+        if (n === 0) {
+            return '';
+        }
+        return this.toRoman(n, form);
+    };
+    MathCombinatoricsFormulas.prototype.toRoman = function (num, form) {
+        var thousands = ['', 'M', 'MM', 'MMM'];
+        var hundredsClassic = [
+            ['', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM'],
+            ['', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM'],
+            ['', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM'],
+            ['', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM'],
+            ['', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM']
+        ];
+        var tensClassic = [
+            ['', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC'],
+            ['', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC'],
+            ['', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC'],
+            ['', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC'],
+            ['', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC']
+        ];
+        var onesClassic = [
+            ['', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'],
+            ['', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'],
+            ['', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'],
+            ['', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'],
+            ['', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX']
+        ];
+        var f = Math.min(form, 4);
+        var result = thousands[Math.floor(num / 1000)];
+        result += hundredsClassic[f][Math.floor((num % 1000) / 100)];
+        result += tensClassic[f][Math.floor((num % 100) / 10)];
+        result += onesClassic[f][num % 10];
+        if (form === 1) {
+            result = result.replace(/XLV/g, 'VL').replace(/XCV/g, 'VC').replace(/CDL/g, 'LD')
+                .replace(/CML/g, 'LM').replace(/CMVC/g, 'LMVL');
+        }
+        else if (form === 2) {
+            result = result.replace(/IV/g, 'IIII').replace(/IX/g, 'VIIII')
+                .replace(/XL/g, 'XXXX').replace(/XC/g, 'LXXXX')
+                .replace(/CD/g, 'CCCC').replace(/CM/g, 'DCCCC');
+        }
+        else if (form === 3) {
+            result = result.replace(/IV/g, 'IIII').replace(/IX/g, 'VIIII')
+                .replace(/XL/g, 'XXXX').replace(/XC/g, 'LXXXX')
+                .replace(/CD/g, 'CCCC').replace(/CM/g, 'DCCCC');
+        }
+        else if (form === 4) {
+            result = result.replace(/V/g, 'IV').replace(/L/g, 'XL').replace(/D/g, 'CD');
+        }
+        return result;
+    };
+    return MathCombinatoricsFormulas;
+}(FormulaModuleBase));
+export { MathCombinatoricsFormulas };

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

@@ -0,0 +1,164 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Core numeric utilities: absolute value, random numbers, logarithms, powers, roots, factorials, and angle/unit conversions.
+ *
+ * Registers 14 functions including ABS, RAND, RANDBETWEEN, RADIANS, DEGREES, and others.
+ *
+ * @hidden
+ */
+export declare class MathMiscFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns the absolute value of a number.
+     *
+     * Excel: `ABS(...)`.
+     *
+     * @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('=ABS(-5)');
+     * ```
+     */
+    ComputeABS(...args: string[]): string | number;
+    /**
+     * Return a random number between 0 and 1.
+     *
+     * Excel: `RAND(...)`.
+     *
+     * @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!`.
+     */
+    ComputeRAND(...args: string[]): string;
+    /**
+     * Returns an integer random number in a specified range.
+     *
+     * Excel: `RANDBETWEEN(...)`.
+     *
+     * @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`.
+     */
+    ComputeRANDBETWEEN(...args: string[]): string | number;
+    /**
+     * Converts degrees to radians.
+     *
+     * Excel: `RADIANS(...)`.
+     *
+     * @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`.
+     */
+    ComputeRADIANS(...args: string[]): string | number;
+    /**
+     * Converts radians to degrees.
+     *
+     * Excel: `DEGREES(...)`.
+     *
+     * @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`.
+     */
+    ComputeDEGREES(...args: string[]): string | number;
+    /**
+     * Returns the value of pi.
+     *
+     * Excel: `PI(...)`.
+     *
+     * @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`.
+     */
+    ComputePI(...args: string[]): string | number;
+    /**
+     * Returns a remainder after a number is divided by divisor.
+     *
+     * Excel: `MOD(...)`.
+     *
+     * @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`.
+     */
+    ComputeMOD(...args: string[]): string | number;
+    /**
+     * Returns the factorial of a number.
+     *
+     * Excel: `FACT(...)`.
+     *
+     * @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`.
+     */
+    ComputeFACT(...args: string[]): string | number;
+    /**
+     * Converts a text representation of a number in a given base into a decimal number.
+     *
+     * Excel: `DECIMAL(...)`.
+     *
+     * @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`.
+     */
+    ComputeDECIMAL(...args: string[]): string | number;
+    /**
+     * Returns the natural logarithm of a number.
+     *
+     * Excel: `LN(...)`.
+     *
+     * @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`.
+     */
+    ComputeLN(...args: string[]): string | number;
+    /**
+     * Returns the logarithm of a number to the base that you specify.
+     *
+     * Excel: `LOG(...)`.
+     *
+     * @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`.
+     */
+    ComputeLOG(...args: string[]): number | string;
+    /**
+     * Returns the result of a number raised to power.
+     *
+     * Excel: `POWER(...)`.
+     *
+     * @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.
+     */
+    ComputePOWER(...args: string[]): boolean | string;
+    /**
+     * Returns the square root of a positive number.
+     *
+     * Excel: `SQRT(...)`.
+     *
+     * @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`.
+     */
+    ComputeSQRT(...args: string[]): number | string;
+    /**
+     * Returns e raised to the power of the given number.
+     *
+     * Excel: `EXP(...)`.
+     *
+     * @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.
+     */
+    ComputeEXP(...args: string[]): boolean | string;
+}