@syncfusion/ej2-calculate 35.1.37

package/src/formulas/engineering-base.d.ts

@@ -0,0 +1,150 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Foundational engineering conversions and numeric transforms used in scientific worksheets.
+ *
+ * Registers 12 functions including BIN2DEC, BIN2HEX, BIN2OCT, DEC2BIN, DEC2HEX, and others.
+ *
+ * @hidden
+ */
+export declare class EngineeringBaseFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    private parseBaseNumber;
+    private resolveBaseArg;
+    private formatToBase;
+    /**
+     * Converts a binary number to decimal.
+     *
+     * Excel: `BIN2DEC(...)`.
+     *
+     * @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('=BIN2DEC(1)');
+     * ```
+     */
+    ComputeBIN2DEC(...args: string[]): string | number;
+    /**
+     * Converts a binary number to hexadecimal.
+     *
+     * Excel: `BIN2HEX(...)`.
+     *
+     * @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`.
+     */
+    ComputeBIN2HEX(...args: string[]): string | number;
+    /**
+     * Converts a binary number to octal.
+     *
+     * Excel: `BIN2OCT(...)`.
+     *
+     * @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`.
+     */
+    ComputeBIN2OCT(...args: string[]): string | number;
+    private binTo;
+    /**
+     * Converts a decimal number to binary.
+     *
+     * Excel: `DEC2BIN(...)`.
+     *
+     * @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`.
+     */
+    ComputeDEC2BIN(...args: string[]): string | number;
+    /**
+     * Converts a decimal number to hexadecimal.
+     *
+     * Excel: `DEC2HEX(...)`.
+     *
+     * @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`.
+     */
+    ComputeDEC2HEX(...args: string[]): string | number;
+    /**
+     * Converts a decimal number to octal.
+     *
+     * Excel: `DEC2OCT(...)`.
+     *
+     * @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`.
+     */
+    ComputeDEC2OCT(...args: string[]): string | number;
+    private decTo;
+    /**
+     * Converts a hexadecimal number to decimal.
+     *
+     * Excel: `HEX2DEC(...)`.
+     *
+     * @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`.
+     */
+    ComputeHEX2DEC(...args: string[]): string | number;
+    /**
+     * Converts a hexadecimal number to binary.
+     *
+     * Excel: `HEX2BIN(...)`.
+     *
+     * @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`.
+     */
+    ComputeHEX2BIN(...args: string[]): string | number;
+    /**
+     * Converts a hexadecimal number to octal.
+     *
+     * Excel: `HEX2OCT(...)`.
+     *
+     * @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`.
+     */
+    ComputeHEX2OCT(...args: string[]): string | number;
+    /**
+     * Converts an octal number to decimal.
+     *
+     * Excel: `OCT2DEC(...)`.
+     *
+     * @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`.
+     */
+    ComputeOCT2DEC(...args: string[]): string | number;
+    /**
+     * Converts an octal number to binary.
+     *
+     * Excel: `OCT2BIN(...)`.
+     *
+     * @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`.
+     */
+    ComputeOCT2BIN(...args: string[]): string | number;
+    /**
+     * Converts an octal number to hexadecimal.
+     *
+     * Excel: `OCT2HEX(...)`.
+     *
+     * @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`.
+     */
+    ComputeOCT2HEX(...args: string[]): string | number;
+    private hexOctTo;
+}

package/src/formulas/engineering-base.js

@@ -0,0 +1,404 @@
+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';
+/**
+ * Foundational engineering conversions and numeric transforms used in scientific worksheets.
+ *
+ * Registers 12 functions including BIN2DEC, BIN2HEX, BIN2OCT, DEC2BIN, DEC2HEX, and others.
+ *
+ * @hidden
+ */
+var EngineeringBaseFormulas = /** @class */ (function (_super) {
+    __extends(EngineeringBaseFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function EngineeringBaseFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'BIN2DEC', category: 'Engineering', description: 'Converts a binary number to decimal.' },
+            { formulaName: 'BIN2HEX', category: 'Engineering', description: 'Converts a binary number to hexadecimal.' },
+            { formulaName: 'BIN2OCT', category: 'Engineering', description: 'Converts a binary number to octal.' },
+            { formulaName: 'DEC2BIN', category: 'Engineering', description: 'Converts a decimal number to binary.' },
+            { formulaName: 'DEC2HEX', category: 'Engineering', description: 'Converts a decimal number to hexadecimal.' },
+            { formulaName: 'DEC2OCT', category: 'Engineering', description: 'Converts a decimal number to octal.' },
+            { formulaName: 'HEX2BIN', category: 'Engineering', description: 'Converts a hexadecimal number to binary.' },
+            { formulaName: 'HEX2DEC', category: 'Engineering', description: 'Converts a hexadecimal number to decimal.' },
+            { formulaName: 'HEX2OCT', category: 'Engineering', description: 'Converts a hexadecimal number to octal.' },
+            { formulaName: 'OCT2BIN', category: 'Engineering', description: 'Converts an octal number to binary.' },
+            { formulaName: 'OCT2DEC', category: 'Engineering', description: 'Converts an octal number to decimal.' },
+            { formulaName: 'OCT2HEX', category: 'Engineering', description: 'Converts an octal number to hexadecimal.' }
+        ];
+        return _this;
+    }
+    EngineeringBaseFormulas.prototype.parseBaseNumber = function (text, base) {
+        var errCollection = this.parent.getErrorStrings();
+        var cleaned = text.trim().toUpperCase();
+        if (cleaned === '') {
+            return errCollection[CommonErrors.Num];
+        }
+        var pattern = base === 16 ? /^[0-9A-F]+$/ : base === 2 ? /^[01]+$/ : /^[0-7]+$/;
+        if (!pattern.test(cleaned)) {
+            return errCollection[CommonErrors.Num];
+        }
+        var value = parseInt(cleaned, base);
+        if (isNaN(value)) {
+            return errCollection[CommonErrors.Num];
+        }
+        return value;
+    };
+    EngineeringBaseFormulas.prototype.resolveBaseArg = function (arg, base) {
+        var errCollection = this.parent.getErrorStrings();
+        var text = this.resolveTextArg(arg);
+        if (errCollection.indexOf(text) > -1) {
+            return text;
+        }
+        return this.parseBaseNumber(text, base);
+    };
+    EngineeringBaseFormulas.prototype.formatToBase = function (value, base, places) {
+        var errCollection = this.parent.getErrorStrings();
+        var num = Math.trunc(value);
+        var limits = {
+            2: { min: -512, max: 511, maxPlaces: 10 },
+            8: { min: -536870912, max: 536870911, maxPlaces: 10 },
+            10: { min: Number.MIN_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER, maxPlaces: 0 },
+            16: { min: -549755813888, max: 549755813887, maxPlaces: 10 }
+        };
+        // eslint-disable-next-line security/detect-object-injection
+        var limit = limits[base];
+        if (num < limit.min || num > limit.max) {
+            return errCollection[CommonErrors.Num];
+        }
+        var negative = false;
+        if (num < 0) {
+            negative = true;
+            var width = places && places > 0 ? places : (base === 2 ? 10 : base === 8 ? 10 : 10);
+            num = (1 << width) + num;
+        }
+        var digits = num.toString(base).toUpperCase();
+        if (places !== undefined && places > 0) {
+            if (places > limit.maxPlaces) {
+                return errCollection[CommonErrors.Num];
+            }
+            while (digits.length < places) {
+                digits = '0' + digits;
+            }
+        }
+        return negative && base !== 10 ? digits : digits;
+    };
+    /**
+     * Converts a binary number to decimal.
+     *
+     * Excel: `BIN2DEC(...)`.
+     *
+     * @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('=BIN2DEC(1)');
+     * ```
+     */
+    EngineeringBaseFormulas.prototype.ComputeBIN2DEC = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var val = this.resolveBaseArg(args[0], 2);
+        if (typeof val === 'string') {
+            return val;
+        }
+        var binary = this.resolveTextArg(args[0]).trim();
+        if (binary.length > 10) {
+            return this.parent.getErrorStrings()[CommonErrors.Num];
+        }
+        var num = val;
+        if (binary.length === 10 && binary.charAt(0) === '1') {
+            num = parseInt(binary, 2) - (1 << 10);
+        }
+        return num.toString();
+    };
+    /**
+     * Converts a binary number to hexadecimal.
+     *
+     * Excel: `BIN2HEX(...)`.
+     *
+     * @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`.
+     */
+    EngineeringBaseFormulas.prototype.ComputeBIN2HEX = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.binTo(args, 16);
+    };
+    /**
+     * Converts a binary number to octal.
+     *
+     * Excel: `BIN2OCT(...)`.
+     *
+     * @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`.
+     */
+    EngineeringBaseFormulas.prototype.ComputeBIN2OCT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.binTo(args, 8);
+    };
+    EngineeringBaseFormulas.prototype.binTo = function (args, targetBase) {
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length < 1 || args.length > 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var dec = this.ComputeBIN2DEC(args[0]);
+        if (typeof dec === 'string' && errCollection.indexOf(dec) > -1) {
+            return dec;
+        }
+        var places;
+        if (args.length === 2) {
+            var p = this.resolveNumberArg(args[1]);
+            if (typeof p === 'string') {
+                return p;
+            }
+            places = Math.floor(p);
+        }
+        return this.formatToBase(parseInt(dec.toString(), 10), targetBase, places);
+    };
+    /**
+     * Converts a decimal number to binary.
+     *
+     * Excel: `DEC2BIN(...)`.
+     *
+     * @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`.
+     */
+    EngineeringBaseFormulas.prototype.ComputeDEC2BIN = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.decTo(args, 2);
+    };
+    /**
+     * Converts a decimal number to hexadecimal.
+     *
+     * Excel: `DEC2HEX(...)`.
+     *
+     * @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`.
+     */
+    EngineeringBaseFormulas.prototype.ComputeDEC2HEX = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.decTo(args, 16);
+    };
+    /**
+     * Converts a decimal number to octal.
+     *
+     * Excel: `DEC2OCT(...)`.
+     *
+     * @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`.
+     */
+    EngineeringBaseFormulas.prototype.ComputeDEC2OCT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.decTo(args, 8);
+    };
+    EngineeringBaseFormulas.prototype.decTo = function (args, targetBase) {
+        if (isNullOrUndefined(args) || args.length < 1 || args.length > 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var num = this.resolveNumberArg(args[0]);
+        if (typeof num === 'string') {
+            return num;
+        }
+        var places;
+        if (args.length === 2) {
+            var p = this.resolveNumberArg(args[1]);
+            if (typeof p === 'string') {
+                return p;
+            }
+            places = Math.floor(p);
+        }
+        return this.formatToBase(Math.trunc(num), targetBase, places);
+    };
+    /**
+     * Converts a hexadecimal number to decimal.
+     *
+     * Excel: `HEX2DEC(...)`.
+     *
+     * @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`.
+     */
+    EngineeringBaseFormulas.prototype.ComputeHEX2DEC = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var text = this.resolveTextArg(args[0]).trim().toUpperCase();
+        var val = this.parseBaseNumber(text, 16);
+        if (typeof val === 'string') {
+            return val;
+        }
+        if (text.length > 10) {
+            return this.parent.getErrorStrings()[CommonErrors.Num];
+        }
+        var num = val;
+        if (text.length === 10 && parseInt(text.charAt(0), 16) >= 8) {
+            num = parseInt(text, 16) - (1 << 40);
+        }
+        return num.toString();
+    };
+    /**
+     * Converts a hexadecimal number to binary.
+     *
+     * Excel: `HEX2BIN(...)`.
+     *
+     * @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`.
+     */
+    EngineeringBaseFormulas.prototype.ComputeHEX2BIN = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.hexOctTo(args, 2, this.ComputeHEX2DEC.bind(this));
+    };
+    /**
+     * Converts a hexadecimal number to octal.
+     *
+     * Excel: `HEX2OCT(...)`.
+     *
+     * @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`.
+     */
+    EngineeringBaseFormulas.prototype.ComputeHEX2OCT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.hexOctTo(args, 8, this.ComputeHEX2DEC.bind(this));
+    };
+    /**
+     * Converts an octal number to decimal.
+     *
+     * Excel: `OCT2DEC(...)`.
+     *
+     * @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`.
+     */
+    EngineeringBaseFormulas.prototype.ComputeOCT2DEC = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var text = this.resolveTextArg(args[0]).trim();
+        var val = this.parseBaseNumber(text, 8);
+        if (typeof val === 'string') {
+            return val;
+        }
+        if (text.length > 10) {
+            return this.parent.getErrorStrings()[CommonErrors.Num];
+        }
+        var num = val;
+        if (text.length === 10 && text.charAt(0) >= '4') {
+            num = parseInt(text, 8) - (1 << 30);
+        }
+        return num.toString();
+    };
+    /**
+     * Converts an octal number to binary.
+     *
+     * Excel: `OCT2BIN(...)`.
+     *
+     * @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`.
+     */
+    EngineeringBaseFormulas.prototype.ComputeOCT2BIN = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.hexOctTo(args, 2, this.ComputeOCT2DEC.bind(this));
+    };
+    /**
+     * Converts an octal number to hexadecimal.
+     *
+     * Excel: `OCT2HEX(...)`.
+     *
+     * @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`.
+     */
+    EngineeringBaseFormulas.prototype.ComputeOCT2HEX = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.hexOctTo(args, 16, this.ComputeOCT2DEC.bind(this));
+    };
+    EngineeringBaseFormulas.prototype.hexOctTo = function (args, targetBase, toDec) {
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length < 1 || args.length > 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var dec = toDec(args[0]);
+        if (typeof dec === 'string' && errCollection.indexOf(dec) > -1) {
+            return dec;
+        }
+        var places;
+        if (args.length === 2) {
+            var p = this.resolveNumberArg(args[1]);
+            if (typeof p === 'string') {
+                return p;
+            }
+            places = Math.floor(p);
+        }
+        return this.formatToBase(parseInt(dec.toString(), 10), targetBase, places);
+    };
+    return EngineeringBaseFormulas;
+}(FormulaModuleBase));
+export { EngineeringBaseFormulas };

package/src/formulas/engineering-bessel.d.ts

@@ -0,0 +1,65 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Bessel function family (J, Y, I, K) for oscillatory and decaying physical models.
+ *
+ * Registered functions: BESSELI, BESSELJ, BESSELK, BESSELY.
+ *
+ * @hidden
+ */
+export declare class EngineeringBesselFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    private besselArgs;
+    /**
+     * Returns the modified Bessel function In(x).
+     *
+     * Excel: `BESSELI(...)`.
+     *
+     * @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('=BESSELI(1)');
+     * ```
+     */
+    ComputeBESSELI(...args: string[]): string | number;
+    /**
+     * Returns the Bessel function Jn(x).
+     *
+     * Excel: `BESSELJ(...)`.
+     *
+     * @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`.
+     */
+    ComputeBESSELJ(...args: string[]): string | number;
+    /**
+     * Returns the modified Bessel function Kn(x).
+     *
+     * Excel: `BESSELK(...)`.
+     *
+     * @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`.
+     */
+    ComputeBESSELK(...args: string[]): string | number;
+    /**
+     * Returns the Bessel function Yn(x).
+     *
+     * Excel: `BESSELY(...)`.
+     *
+     * @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`.
+     */
+    ComputeBESSELY(...args: string[]): string | number;
+}