@syncfusion/ej2-calculate 35.1.37

package/src/formulas/financial-bond-helpers.js

@@ -0,0 +1,190 @@
+/**
+ * Shared bond/coupon date helpers for financial ECMA formulas.
+ *
+ * @hidden
+ */
+var FinancialBondHelpers = /** @class */ (function () {
+    function FinancialBondHelpers(parent) {
+        this.parent = parent;
+    }
+    /**
+     * yearDays helper.
+     *
+     * @param {number} basis - basis argument.
+     * @returns {number} - yearDays result.
+     */
+    FinancialBondHelpers.prototype.yearDays = function (basis) {
+        switch (basis) {
+            case 1:
+                return 365;
+            case 3:
+                return 365;
+            default:
+                return 360;
+        }
+    };
+    /**
+     * toDate helper.
+     *
+     * @param {number} serial - serial argument.
+     * @returns {Date} - toDate result.
+     */
+    FinancialBondHelpers.prototype.toDate = function (serial) {
+        return this.parent.fromOADate(serial);
+    };
+    /**
+     * toSerial helper.
+     *
+     * @param {Date} date - date argument.
+     * @returns {number} - toSerial result.
+     */
+    FinancialBondHelpers.prototype.toSerial = function (date) {
+        return this.parent.toOADate(date);
+    };
+    /**
+     * coupPCD helper.
+     *
+     * @param {number} settlement - settlement argument.
+     * @param {number} maturity - maturity argument.
+     * @param {number} frequency - frequency argument.
+     * @returns {number} - coupPCD result.
+     */
+    FinancialBondHelpers.prototype.coupPCD = function (settlement, maturity, frequency) {
+        var mat = this.toDate(maturity);
+        var coupon = new Date(mat.getFullYear(), mat.getMonth(), mat.getDate());
+        var monthsPer = 12 / frequency;
+        while (this.toSerial(coupon) > settlement) {
+            coupon = this.addMonths(coupon, -monthsPer);
+        }
+        if (this.toSerial(coupon) > settlement) {
+            return settlement;
+        }
+        return this.toSerial(coupon);
+    };
+    /**
+     * coupNCD helper.
+     *
+     * @param {number} settlement - settlement argument.
+     * @param {number} maturity - maturity argument.
+     * @param {number} frequency - frequency argument.
+     * @returns {number} - coupNCD result.
+     */
+    FinancialBondHelpers.prototype.coupNCD = function (settlement, maturity, frequency) {
+        var pcd = this.coupPCD(settlement, maturity, frequency);
+        if (pcd <= settlement) {
+            var monthsPer = 12 / frequency;
+            pcd = this.toSerial(this.addMonths(this.toDate(pcd), monthsPer));
+        }
+        return pcd;
+    };
+    /**
+     * coupDays helper.
+     *
+     * @param {number} settlement - settlement argument.
+     * @param {number} maturity - maturity argument.
+     * @param {number} frequency - frequency argument.
+     * @param {number} basis - basis argument.
+     * @returns {number} - coupDays result.
+     */
+    FinancialBondHelpers.prototype.coupDays = function (settlement, maturity, frequency, basis) {
+        if (basis === void 0) { basis = 0; }
+        var pcd = this.coupPCD(settlement, maturity, frequency);
+        var ncd = this.coupNCD(settlement, maturity, frequency);
+        return this.daysBetween(pcd, ncd, basis);
+    };
+    /**
+     * coupDayBS helper.
+     *
+     * @param {number} settlement - settlement argument.
+     * @param {number} maturity - maturity argument.
+     * @param {number} frequency - frequency argument.
+     * @param {number} basis - basis argument.
+     * @returns {number} - coupDayBS result.
+     */
+    FinancialBondHelpers.prototype.coupDayBS = function (settlement, maturity, frequency, basis) {
+        if (basis === void 0) { basis = 0; }
+        var pcd = this.coupPCD(settlement, maturity, frequency);
+        return this.daysBetween(pcd, settlement, basis);
+    };
+    /**
+     * coupDaysNC helper.
+     *
+     * @param {number} settlement - settlement argument.
+     * @param {number} maturity - maturity argument.
+     * @param {number} frequency - frequency argument.
+     * @param {number} basis - basis argument.
+     * @returns {number} - coupDaysNC result.
+     */
+    FinancialBondHelpers.prototype.coupDaysNC = function (settlement, maturity, frequency, basis) {
+        if (basis === void 0) { basis = 0; }
+        var ncd = this.coupNCD(settlement, maturity, frequency);
+        return this.daysBetween(settlement, ncd, basis);
+    };
+    /**
+     * coupNum helper.
+     *
+     * @param {number} settlement - settlement argument.
+     * @param {number} maturity - maturity argument.
+     * @param {number} frequency - frequency argument.
+     * @param {number} _basis - basis argument.
+     * @returns {number} - coupNum result.
+     */
+    FinancialBondHelpers.prototype.coupNum = function (settlement, maturity, frequency, _basis) {
+        if (_basis === void 0) { _basis = 0; }
+        void _basis;
+        var monthsPer = 12 / frequency;
+        var mat = this.toDate(maturity);
+        var coupon = new Date(mat.getFullYear(), mat.getMonth(), mat.getDate());
+        var count = 0;
+        while (this.toSerial(coupon) > settlement) {
+            count++;
+            coupon = this.addMonths(coupon, -monthsPer);
+        }
+        return count;
+    };
+    /**
+     * daysBetween helper.
+     *
+     * @param {number} start - start argument.
+     * @param {number} end - end argument.
+     * @param {number} basis - basis argument.
+     * @returns {number} - daysBetween result.
+     */
+    FinancialBondHelpers.prototype.daysBetween = function (start, end, basis) {
+        if (basis === 1) {
+            return Math.round((end - start));
+        }
+        var d1 = this.toDate(start);
+        var d2 = this.toDate(end);
+        if (basis === 3) {
+            return Math.abs(Math.round((d2.getTime() - d1.getTime()) / 86400000));
+        }
+        var y1 = d1.getFullYear();
+        var m1 = d1.getMonth() + 1;
+        var day1 = d1.getDate();
+        var y2 = d2.getFullYear();
+        var m2 = d2.getMonth() + 1;
+        var day2 = d2.getDate();
+        if (day1 === 31) {
+            day1 = 30;
+        }
+        if (day2 === 31) {
+            day2 = 30;
+        }
+        return (y2 - y1) * 360 + (m2 - m1) * 30 + (day2 - day1);
+    };
+    /**
+     * addMonths helper.
+     *
+     * @param {Date} date - date argument.
+     * @param {number} months - months argument.
+     * @returns {Date} - addMonths result.
+     */
+    FinancialBondHelpers.prototype.addMonths = function (date, months) {
+        var d = new Date(date.getTime());
+        d.setMonth(d.getMonth() + months);
+        return d;
+    };
+    return FinancialBondHelpers;
+}());
+export { FinancialBondHelpers };

package/src/formulas/financial-cashflow.d.ts

@@ -0,0 +1,47 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Net present value and internal rate of return for uneven cash-flow series.
+ *
+ * Registered functions: IRR, MIRR.
+ *
+ * @hidden
+ */
+export declare class FinancialCashflowFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    private collectCashflows;
+    private npvAtRate;
+    private npvDerivative;
+    /**
+     * Returns the internal rate of return for a series of cash flows.
+     *
+     * Excel: `IRR(...)`.
+     *
+     * @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('=IRR(1)');
+     * ```
+     */
+    ComputeIRR(...args: string[]): string | number;
+    /**
+     * Returns the modified internal rate of return for cash flows.
+     *
+     * Excel: `MIRR(...)`.
+     *
+     * @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`.
+     */
+    ComputeMIRR(...args: string[]): string | number;
+}

package/src/formulas/financial-cashflow.js

@@ -0,0 +1,203 @@
+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';
+/**
+ * Net present value and internal rate of return for uneven cash-flow series.
+ *
+ * Registered functions: IRR, MIRR.
+ *
+ * @hidden
+ */
+var FinancialCashflowFormulas = /** @class */ (function (_super) {
+    __extends(FinancialCashflowFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function FinancialCashflowFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'IRR', category: 'Financial', description: 'Returns the internal rate of return for a series of cash flows.' },
+            { formulaName: 'MIRR', category: 'Financial', description: 'Returns the modified internal rate of return for cash flows.' }
+        ];
+        return _this;
+    }
+    FinancialCashflowFormulas.prototype.collectCashflows = function (args) {
+        var errCollection = this.parent.getErrorStrings();
+        var flows = [];
+        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)) {
+                        flows.push(this.parent.parseFloat(val));
+                    }
+                }
+            }
+            else {
+                var num = this.resolveNumberArg(arg);
+                if (typeof num === 'string') {
+                    return num;
+                }
+                flows.push(num);
+            }
+        }
+        return flows;
+    };
+    FinancialCashflowFormulas.prototype.npvAtRate = function (flows, rate) {
+        var npv = 0;
+        for (var i = 0; i < flows.length; i++) {
+            npv += flows[i] / Math.pow(1 + rate, i);
+        }
+        return npv;
+    };
+    FinancialCashflowFormulas.prototype.npvDerivative = function (flows, rate) {
+        var d = 0;
+        for (var i = 1; i < flows.length; i++) {
+            d -= i * flows[i] / Math.pow(1 + rate, i + 1);
+        }
+        return d;
+    };
+    /**
+     * Returns the internal rate of return for a series of cash flows.
+     *
+     * Excel: `IRR(...)`.
+     *
+     * @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('=IRR(1)');
+     * ```
+     */
+    FinancialCashflowFormulas.prototype.ComputeIRR = 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 guess = 0.1;
+        var flowArgs = args;
+        if (args.length === 2 && this.parent.isCellReference(args[0])) {
+            var guessArg = this.resolveNumberArg(args[1]);
+            if (typeof guessArg === 'number') {
+                guess = guessArg;
+                flowArgs = [args[0]];
+            }
+        }
+        var flows = this.collectCashflows(flowArgs);
+        if (typeof flows === 'string') {
+            return flows;
+        }
+        if (flows.length < 2) {
+            return errCollection[CommonErrors.Num];
+        }
+        var hasPos = false;
+        var hasNeg = false;
+        for (var i = 0; i < flows.length; i++) {
+            if (flows[i] > 0) {
+                hasPos = true;
+            }
+            if (flows[i] < 0) {
+                hasNeg = true;
+            }
+        }
+        if (!hasPos || !hasNeg) {
+            return errCollection[CommonErrors.Num];
+        }
+        var rate = guess;
+        for (var iter = 0; iter < 100; iter++) {
+            var npv = this.npvAtRate(flows, rate);
+            var dnpv = this.npvDerivative(flows, rate);
+            if (Math.abs(dnpv) < 1e-12) {
+                break;
+            }
+            var next = rate - npv / dnpv;
+            if (Math.abs(next - rate) < 1e-10) {
+                return next.toString();
+            }
+            rate = next;
+        }
+        return errCollection[CommonErrors.Num];
+    };
+    /**
+     * Returns the modified internal rate of return for cash flows.
+     *
+     * Excel: `MIRR(...)`.
+     *
+     * @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`.
+     */
+    FinancialCashflowFormulas.prototype.ComputeMIRR = 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 financeRate = this.resolveNumberArg(args[1]);
+        var reinvestRate = this.resolveNumberArg(args[2]);
+        if (typeof financeRate === 'string') {
+            return financeRate;
+        }
+        if (typeof reinvestRate === 'string') {
+            return reinvestRate;
+        }
+        var flows = this.collectCashflows([args[0]]);
+        if (typeof flows === 'string') {
+            return flows;
+        }
+        if (flows.length < 2) {
+            return errCollection[CommonErrors.Num];
+        }
+        var n = flows.length - 1;
+        var posPv = 0;
+        var negFv = 0;
+        for (var i = 0; i < flows.length; i++) {
+            var cf = flows[i];
+            if (cf >= 0) {
+                negFv += cf * Math.pow(1 + reinvestRate, n - i);
+            }
+            else {
+                posPv += cf / Math.pow(1 + financeRate, i);
+            }
+        }
+        if (posPv === 0 || negFv === 0) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        return (Math.pow(-negFv / posPv, 1 / n) - 1).toString();
+    };
+    return FinancialCashflowFormulas;
+}(FormulaModuleBase));
+export { FinancialCashflowFormulas };

package/src/formulas/financial-coupons.d.ts

@@ -0,0 +1,227 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Bond coupon payment schedules, accrued interest, and coupon-period date boundaries.
+ *
+ * Registers 20 functions including COUPDAYBS, COUPDAYS, COUPDAYSNC, COUPNCD, COUPNUM, and others.
+ *
+ * @hidden
+ */
+export declare class FinancialCouponsFormulas extends FormulaModuleBase {
+    private bond;
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    private parseBondArgs;
+    private coupArgs;
+    /**
+     * Returns the number of days from the beginning of the coupon period to the settlement date.
+     *
+     * Excel: `COUPDAYBS(...)`.
+     *
+     * @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('=COUPDAYBS(1)');
+     * ```
+     */
+    ComputeCOUPDAYBS(...args: string[]): string | number;
+    /**
+     * Returns the number of days in the coupon period that contains the settlement date.
+     *
+     * Excel: `COUPDAYS(...)`.
+     *
+     * @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`.
+     */
+    ComputeCOUPDAYS(...args: string[]): string | number;
+    /**
+     * Returns the number of days from the settlement date to the next coupon date.
+     *
+     * Excel: `COUPDAYSNC(...)`.
+     *
+     * @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`.
+     */
+    ComputeCOUPDAYSNC(...args: string[]): string | number;
+    /**
+     * Returns the next coupon date after the settlement date.
+     *
+     * Excel: `COUPNCD(...)`.
+     *
+     * @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`.
+     */
+    ComputeCOUPNCD(...args: string[]): string | number;
+    /**
+     * Returns the number of coupons payable between settlement and maturity.
+     *
+     * Excel: `COUPNUM(...)`.
+     *
+     * @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`.
+     */
+    ComputeCOUPNUM(...args: string[]): string | number;
+    /**
+     * Returns the previous coupon date before the settlement date.
+     *
+     * Excel: `COUPPCD(...)`.
+     *
+     * @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`.
+     */
+    ComputeCOUPPCD(...args: string[]): string | number;
+    /**
+     * Returns the accrued interest for a security that pays periodic interest.
+     *
+     * Excel: `ACCRINT(...)`.
+     *
+     * @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`.
+     */
+    ComputeACCRINT(...args: string[]): string | number;
+    /**
+     * Returns the accrued interest for a security that pays interest at maturity.
+     *
+     * Excel: `ACCRINTM(...)`.
+     *
+     * @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`.
+     */
+    ComputeACCRINTM(...args: string[]): string | number;
+    /**
+     * Returns the interest paid during a specific period of an investment.
+     *
+     * Excel: `ISPMT(...)`.
+     *
+     * @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`.
+     */
+    ComputeISPMT(...args: string[]): string | number;
+    /**
+     * Returns the modified Macauley duration for a security with an assumed par value of $100.
+     *
+     * Excel: `MDURATION(...)`.
+     *
+     * @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`.
+     */
+    ComputeMDURATION(...args: string[]): string | number;
+    /**
+     * Returns the price per $100 face value of a security that pays periodic interest.
+     *
+     * Excel: `PRICE(...)`.
+     *
+     * @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`.
+     */
+    ComputePRICE(...args: string[]): string | number;
+    /**
+     * Returns the price per $100 face value of a discounted security.
+     *
+     * Excel: `PRICEDISC(...)`.
+     *
+     * @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`.
+     */
+    ComputePRICEDISC(...args: string[]): string | number;
+    /**
+     * Returns the price per $100 face value of a security that pays interest at maturity.
+     *
+     * Excel: `PRICEMAT(...)`.
+     *
+     * @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`.
+     */
+    ComputePRICEMAT(...args: string[]): string | number;
+    /**
+     * Returns the price per $100 face value for a Treasury bill.
+     *
+     * Excel: `TBILLPRICE(...)`.
+     *
+     * @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`.
+     */
+    ComputeTBILLPRICE(...args: string[]): string | number;
+    /**
+     * Returns the yield for a Treasury bill.
+     *
+     * Excel: `TBILLYIELD(...)`.
+     *
+     * @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`.
+     */
+    ComputeTBILLYIELD(...args: string[]): string | number;
+    /**
+     * Returns the bond-equivalent yield for a Treasury bill.
+     *
+     * Excel: `TBILLEQ(...)`.
+     *
+     * @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`.
+     */
+    ComputeTBILLEQ(...args: string[]): string | number;
+    /**
+     * Returns the net present value for a schedule of cash flows that is not necessarily periodic.
+     *
+     * Excel: `XNPV(...)`.
+     *
+     * @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`.
+     */
+    ComputeXNPV(...args: string[]): string | number;
+    /**
+     * Returns the yield on a security that pays periodic interest.
+     *
+     * Excel: `YIELD(...)`.
+     *
+     * @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`.
+     */
+    ComputeYIELD(...args: string[]): string | number;
+    /**
+     * Returns the annual yield for a discounted security.
+     *
+     * Excel: `YIELDDISC(...)`.
+     *
+     * @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`.
+     */
+    ComputeYIELDDISC(...args: string[]): string | number;
+    /**
+     * Returns the annual yield of a security that pays interest at maturity.
+     *
+     * Excel: `YIELDMAT(...)`.
+     *
+     * @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`.
+     */
+    ComputeYIELDMAT(...args: string[]): string | number;
+}