@syncfusion/ej2-calculate 35.1.37

package/src/formulas/engineering-bessel.js

@@ -0,0 +1,167 @@
+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 { besselI, besselJ, besselK, besselY } from './formula-math-helpers';
+/**
+ * Bessel function family (J, Y, I, K) for oscillatory and decaying physical models.
+ *
+ * Registered functions: BESSELI, BESSELJ, BESSELK, BESSELY.
+ *
+ * @hidden
+ */
+var EngineeringBesselFormulas = /** @class */ (function (_super) {
+    __extends(EngineeringBesselFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function EngineeringBesselFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'BESSELI', category: 'Engineering', description: 'Returns the modified Bessel function In(x).' },
+            { formulaName: 'BESSELJ', category: 'Engineering', description: 'Returns the Bessel function Jn(x).' },
+            { formulaName: 'BESSELK', category: 'Engineering', description: 'Returns the modified Bessel function Kn(x).' },
+            { formulaName: 'BESSELY', category: 'Engineering', description: 'Returns the Bessel function Yn(x).' }
+        ];
+        return _this;
+    }
+    EngineeringBesselFormulas.prototype.besselArgs = function (args) {
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length !== 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var x = this.resolveNumberArg(args[0]);
+        var n = this.resolveNumberArg(args[1]);
+        if (typeof x === 'string') {
+            return x;
+        }
+        if (typeof n === 'string') {
+            return n;
+        }
+        if (n < 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        return { x: x, n: Math.floor(n) };
+    };
+    /**
+     * 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)');
+     * ```
+     */
+    EngineeringBesselFormulas.prototype.ComputeBESSELI = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var parsed = this.besselArgs(args);
+        if (typeof parsed === 'string') {
+            return parsed;
+        }
+        var result = besselI(parsed.n, parsed.x);
+        if (!isFinite(result)) {
+            return this.parent.getErrorStrings()[CommonErrors.Num];
+        }
+        return result.toString();
+    };
+    /**
+     * 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`.
+     */
+    EngineeringBesselFormulas.prototype.ComputeBESSELJ = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var parsed = this.besselArgs(args);
+        if (typeof parsed === 'string') {
+            return parsed;
+        }
+        return besselJ(parsed.n, parsed.x).toString();
+    };
+    /**
+     * 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`.
+     */
+    EngineeringBesselFormulas.prototype.ComputeBESSELK = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        var parsed = this.besselArgs(args);
+        if (typeof parsed === 'string') {
+            return parsed;
+        }
+        if (parsed.x <= 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var result = besselK(parsed.n, parsed.x);
+        if (!isFinite(result)) {
+            return errCollection[CommonErrors.Num];
+        }
+        return result.toString();
+    };
+    /**
+     * 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`.
+     */
+    EngineeringBesselFormulas.prototype.ComputeBESSELY = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        var parsed = this.besselArgs(args);
+        if (typeof parsed === 'string') {
+            return parsed;
+        }
+        if (parsed.x <= 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var result = besselY(parsed.n, parsed.x);
+        if (!isFinite(result)) {
+            return errCollection[CommonErrors.Num];
+        }
+        return result.toString();
+    };
+    return EngineeringBesselFormulas;
+}(FormulaModuleBase));
+export { EngineeringBesselFormulas };

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

@@ -0,0 +1,35 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Unit conversion between engineering measurement systems via the CONVERT function.
+ *
+ * Registered functions: CONVERT.
+ *
+ * @hidden
+ */
+export declare class EngineeringConvertFormulas extends FormulaModuleBase {
+    private static readonly UNITS;
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Converts a number from one measurement system to another.
+     *
+     * Excel: `CONVERT(...)`.
+     *
+     * @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('=CONVERT(1)');
+     * ```
+     */
+    ComputeCONVERT(...args: string[]): string | number;
+}

package/src/formulas/engineering-convert.js

@@ -0,0 +1,120 @@
+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';
+/**
+ * Unit conversion between engineering measurement systems via the CONVERT function.
+ *
+ * Registered functions: CONVERT.
+ *
+ * @hidden
+ */
+var EngineeringConvertFormulas = /** @class */ (function (_super) {
+    __extends(EngineeringConvertFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function EngineeringConvertFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'CONVERT', category: 'Engineering', description: 'Converts a number from one measurement system to another.' }
+        ];
+        return _this;
+    }
+    /**
+     * Converts a number from one measurement system to another.
+     *
+     * Excel: `CONVERT(...)`.
+     *
+     * @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('=CONVERT(1)');
+     * ```
+     */
+    EngineeringConvertFormulas.prototype.ComputeCONVERT = 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 !== 3) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var num = this.resolveNumberArg(args[0]);
+        if (typeof num === 'string') {
+            return num;
+        }
+        var fromUnit = this.resolveTextArg(args[1]).toLowerCase();
+        var toUnit = this.resolveTextArg(args[2]).toLowerCase();
+        if (errCollection.indexOf(fromUnit) > -1) {
+            return fromUnit;
+        }
+        if (errCollection.indexOf(toUnit) > -1) {
+            return toUnit;
+        }
+        if (fromUnit === toUnit) {
+            return num.toString();
+        }
+        if (fromUnit === 'c' && toUnit === 'f') {
+            return (num * 9 / 5 + 32).toString();
+        }
+        if (fromUnit === 'f' && toUnit === 'c') {
+            return ((num - 32) * 5 / 9).toString();
+        }
+        for (var _a = 0, _b = EngineeringConvertFormulas.UNITS; _a < _b.length; _a++) {
+            var entry = _b[_a];
+            if (entry.from === fromUnit && entry.to === toUnit && !isNaN(entry.factor)) {
+                return (num * entry.factor).toString();
+            }
+        }
+        var viaBase = EngineeringConvertFormulas.UNITS.find(function (e) { return e.from === fromUnit && !isNaN(e.factor); });
+        var viaBaseTo = viaBase ? viaBase.to : undefined;
+        var toBase = EngineeringConvertFormulas.UNITS.find(function (e) { return e.to === toUnit && e.from === viaBaseTo && !isNaN(e.factor); });
+        if (viaBase && toBase) {
+            return (num * viaBase.factor * toBase.factor).toString();
+        }
+        return errCollection[CommonErrors.NA];
+    };
+    EngineeringConvertFormulas.UNITS = [
+        { from: 'g', to: 'kg', factor: 0.001 },
+        { from: 'kg', to: 'g', factor: 1000 },
+        { from: 'lbm', to: 'kg', factor: 0.45359237 },
+        { from: 'kg', to: 'lbm', factor: 2.2046226218 },
+        { from: 'm', to: 'ft', factor: 3.280839895 },
+        { from: 'ft', to: 'm', factor: 0.3048 },
+        { from: 'in', to: 'm', factor: 0.0254 },
+        { from: 'm', to: 'in', factor: 39.37007874 },
+        { from: 'mi', to: 'm', factor: 1609.344 },
+        { from: 'm', to: 'mi', factor: 1 / 1609.344 },
+        { from: 'yr', to: 'day', factor: 365.25 },
+        { from: 'day', to: 'yr', factor: 1 / 365.25 },
+        { from: 'hr', to: 'sec', factor: 3600 },
+        { from: 'sec', to: 'hr', factor: 1 / 3600 },
+        { from: 'C', to: 'F', factor: NaN },
+        { from: 'F', to: 'C', factor: NaN },
+        { from: 'l', to: 'm3', factor: 0.001 },
+        { from: 'm3', to: 'l', factor: 1000 },
+        { from: 'N', to: 'lbf', factor: 0.224808943 },
+        { from: 'lbf', to: 'N', factor: 4.4482216153 }
+    ];
+    return EngineeringConvertFormulas;
+}(FormulaModuleBase));
+export { EngineeringConvertFormulas };

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

@@ -0,0 +1,64 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Miscellaneous engineering functions including delta, gestep, and related step/threshold helpers.
+ *
+ * Registered functions: DELTA, GESTEP, ERF, ERFC.
+ *
+ * @hidden
+ */
+export declare class EngineeringMiscFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Tests whether two values are equal.
+     *
+     * Excel: `DELTA(...)`.
+     *
+     * @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('=DELTA(1)');
+     * ```
+     */
+    ComputeDELTA(...args: string[]): string | number;
+    /**
+     * Tests whether a number is greater than a threshold.
+     *
+     * Excel: `GESTEP(...)`.
+     *
+     * @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`.
+     */
+    ComputeGESTEP(...args: string[]): string | number;
+    /**
+     * Returns the error function.
+     *
+     * Excel: `ERF(...)`.
+     *
+     * @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`.
+     */
+    ComputeERF(...args: string[]): string | number;
+    /**
+     * Returns the complementary error function.
+     *
+     * Excel: `ERFC(...)`.
+     *
+     * @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`.
+     */
+    ComputeERFC(...args: string[]): string | number;
+}

package/src/formulas/engineering-misc.js

@@ -0,0 +1,168 @@
+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 } from '../common/index';
+import { isNullOrUndefined } from '@syncfusion/ej2-base';
+import { FormulaModuleBase } from './formula-module-base';
+import { erf, erfc } from './formula-math-helpers';
+/**
+ * Miscellaneous engineering functions including delta, gestep, and related step/threshold helpers.
+ *
+ * Registered functions: DELTA, GESTEP, ERF, ERFC.
+ *
+ * @hidden
+ */
+var EngineeringMiscFormulas = /** @class */ (function (_super) {
+    __extends(EngineeringMiscFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function EngineeringMiscFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'DELTA', category: 'Engineering', description: 'Tests whether two values are equal.' },
+            { formulaName: 'GESTEP', category: 'Engineering', description: 'Tests whether a number is greater than a threshold.' },
+            { formulaName: 'ERF', category: 'Engineering', description: 'Returns the error function.' },
+            { formulaName: 'ERFC', category: 'Engineering', description: 'Returns the complementary error function.' }
+        ];
+        return _this;
+    }
+    /**
+     * Tests whether two values are equal.
+     *
+     * Excel: `DELTA(...)`.
+     *
+     * @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('=DELTA(1)');
+     * ```
+     */
+    EngineeringMiscFormulas.prototype.ComputeDELTA = 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 a = this.resolveNumberArg(args[0]);
+        if (typeof a === 'string') {
+            return a;
+        }
+        var b = 0;
+        if (args.length === 2) {
+            var bArg = this.resolveNumberArg(args[1]);
+            if (typeof bArg === 'string') {
+                return bArg;
+            }
+            b = bArg;
+        }
+        return (a === b ? 1 : 0).toString();
+    };
+    /**
+     * Tests whether a number is greater than a threshold.
+     *
+     * Excel: `GESTEP(...)`.
+     *
+     * @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`.
+     */
+    EngineeringMiscFormulas.prototype.ComputeGESTEP = 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 num = this.resolveNumberArg(args[0]);
+        if (typeof num === 'string') {
+            return num;
+        }
+        var step = 0;
+        if (args.length === 2) {
+            var stepArg = this.resolveNumberArg(args[1]);
+            if (typeof stepArg === 'string') {
+                return stepArg;
+            }
+            step = stepArg;
+        }
+        return (num >= step ? 1 : 0).toString();
+    };
+    /**
+     * Returns the error function.
+     *
+     * Excel: `ERF(...)`.
+     *
+     * @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`.
+     */
+    EngineeringMiscFormulas.prototype.ComputeERF = 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];
+        }
+        if (args.length === 1) {
+            var x = this.resolveNumberArg(args[0]);
+            if (typeof x === 'string') {
+                return x;
+            }
+            return erf(x).toString();
+        }
+        var lower = this.resolveNumberArg(args[0]);
+        var upper = this.resolveNumberArg(args[1]);
+        if (typeof lower === 'string') {
+            return lower;
+        }
+        if (typeof upper === 'string') {
+            return upper;
+        }
+        return (erf(upper) - erf(lower)).toString();
+    };
+    /**
+     * Returns the complementary error function.
+     *
+     * Excel: `ERFC(...)`.
+     *
+     * @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`.
+     */
+    EngineeringMiscFormulas.prototype.ComputeERFC = 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 x = this.resolveNumberArg(args[0]);
+        if (typeof x === 'string') {
+            return x;
+        }
+        return erfc(x).toString();
+    };
+    return EngineeringMiscFormulas;
+}(FormulaModuleBase));
+export { EngineeringMiscFormulas };

package/src/formulas/financial-amortization-ecma.d.ts

@@ -0,0 +1,87 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * ECMA amortization and odd-period bond pricing/yield functions for European accounting conventions.
+ *
+ * Registered functions: AMORDEGRC, AMORLINC, ODDFPRICE, ODDFYIELD, ODDLPRICE, ODDLYIELD.
+ *
+ * @hidden
+ */
+export declare class FinancialAmortizationEcmaFormulas extends FormulaModuleBase {
+    private bond;
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns the depreciation for each accounting period.
+     *
+     * Excel: `AMORLINC(...)`.
+     *
+     * @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('=AMORLINC(1)');
+     * ```
+     */
+    ComputeAMORLINC(...args: string[]): string | number;
+    /**
+     * Returns the depreciation for each accounting period using a depreciation coefficient.
+     *
+     * Excel: `AMORDEGRC(...)`.
+     *
+     * @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`.
+     */
+    ComputeAMORDEGRC(...args: string[]): string | number;
+    private oddBondPrice;
+    /**
+     * Returns the price per $100 face value of a security with an odd first period.
+     *
+     * Excel: `ODDFPRICE(...)`.
+     *
+     * @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`.
+     */
+    ComputeODDFPRICE(...args: string[]): string | number;
+    /**
+     * Returns the price per $100 face value of a security with an odd last period.
+     *
+     * Excel: `ODDLPRICE(...)`.
+     *
+     * @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`.
+     */
+    ComputeODDLPRICE(...args: string[]): string | number;
+    private oddBondYield;
+    /**
+     * Returns the yield of a security with an odd first period.
+     *
+     * Excel: `ODDFYIELD(...)`.
+     *
+     * @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`.
+     */
+    ComputeODDFYIELD(...args: string[]): string | number;
+    /**
+     * Returns the yield of a security with an odd last period.
+     *
+     * Excel: `ODDLYIELD(...)`.
+     *
+     * @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`.
+     */
+    ComputeODDLYIELD(...args: string[]): string | number;
+}