@syncfusion/ej2-calculate 35.1.37

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

@@ -0,0 +1,64 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Asset depreciation schedules including straight-line, declining-balance, and SYD methods.
+ *
+ * Registered functions: SLN, SYD, DB, DDB.
+ *
+ * @hidden
+ */
+export declare class FinancialDepreciationFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns the straight-line depreciation of an asset for one period.
+     *
+     * Excel: `SLN(...)`.
+     *
+     * @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('=SLN(1)');
+     * ```
+     */
+    ComputeSLN(...args: string[]): string | number;
+    /**
+     * Returns the sum-of-years digits depreciation for a specified period.
+     *
+     * Excel: `SYD(...)`.
+     *
+     * @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`.
+     */
+    ComputeSYD(...args: string[]): string | number;
+    /**
+     * Returns the depreciation of an asset for a period using fixed-declining balance.
+     *
+     * Excel: `DB(...)`.
+     *
+     * @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`.
+     */
+    ComputeDB(...args: string[]): string | number;
+    /**
+     * Returns the depreciation of an asset for a period using double-declining balance.
+     *
+     * Excel: `DDB(...)`.
+     *
+     * @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`.
+     */
+    ComputeDDB(...args: string[]): string | number;
+}

package/src/formulas/financial-depreciation.js

@@ -0,0 +1,247 @@
+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';
+/**
+ * Asset depreciation schedules including straight-line, declining-balance, and SYD methods.
+ *
+ * Registered functions: SLN, SYD, DB, DDB.
+ *
+ * @hidden
+ */
+var FinancialDepreciationFormulas = /** @class */ (function (_super) {
+    __extends(FinancialDepreciationFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function FinancialDepreciationFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'SLN', category: 'Financial', description: 'Returns the straight-line depreciation of an asset for one period.' },
+            { formulaName: 'SYD', category: 'Financial', description: 'Returns the sum-of-years digits depreciation for a specified period.' },
+            { formulaName: 'DB', category: 'Financial', description: 'Returns the depreciation of an asset for a period using fixed-declining balance.' },
+            { formulaName: 'DDB', category: 'Financial', description: 'Returns the depreciation of an asset for a period using double-declining balance.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns the straight-line depreciation of an asset for one period.
+     *
+     * Excel: `SLN(...)`.
+     *
+     * @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('=SLN(1)');
+     * ```
+     */
+    FinancialDepreciationFormulas.prototype.ComputeSLN = 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 cost = this.resolveNumberArg(args[0]);
+        var salvage = this.resolveNumberArg(args[1]);
+        var life = this.resolveNumberArg(args[2]);
+        if (typeof cost === 'string') {
+            return cost;
+        }
+        if (typeof salvage === 'string') {
+            return salvage;
+        }
+        if (typeof life === 'string') {
+            return life;
+        }
+        if (life === 0) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        return ((cost - salvage) / life).toString();
+    };
+    /**
+     * Returns the sum-of-years digits depreciation for a specified period.
+     *
+     * Excel: `SYD(...)`.
+     *
+     * @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`.
+     */
+    FinancialDepreciationFormulas.prototype.ComputeSYD = 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 !== 4) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var cost = this.resolveNumberArg(args[0]);
+        var salvage = this.resolveNumberArg(args[1]);
+        var life = this.resolveNumberArg(args[2]);
+        var per = this.resolveNumberArg(args[3]);
+        if (typeof cost === 'string') {
+            return cost;
+        }
+        if (typeof salvage === 'string') {
+            return salvage;
+        }
+        if (typeof life === 'string') {
+            return life;
+        }
+        if (typeof per === 'string') {
+            return per;
+        }
+        if (life <= 0 || per <= 0 || per > life) {
+            return errCollection[CommonErrors.Num];
+        }
+        var sumYears = life * (life + 1) / 2;
+        var depreciation = (cost - salvage) * (life - per + 1) / sumYears;
+        return depreciation.toString();
+    };
+    /**
+     * Returns the depreciation of an asset for a period using fixed-declining balance.
+     *
+     * Excel: `DB(...)`.
+     *
+     * @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`.
+     */
+    FinancialDepreciationFormulas.prototype.ComputeDB = 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 < 4 || args.length > 5) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var cost = this.resolveNumberArg(args[0]);
+        var salvage = this.resolveNumberArg(args[1]);
+        var life = this.resolveNumberArg(args[2]);
+        var period = this.resolveNumberArg(args[3]);
+        if (typeof cost === 'string') {
+            return cost;
+        }
+        if (typeof salvage === 'string') {
+            return salvage;
+        }
+        if (typeof life === 'string') {
+            return life;
+        }
+        if (typeof period === 'string') {
+            return period;
+        }
+        var month = 12;
+        if (args.length === 5) {
+            var m = this.resolveNumberArg(args[4]);
+            if (typeof m === 'string') {
+                return m;
+            }
+            month = Math.floor(m);
+        }
+        if (life <= 0 || period <= 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var rate = 1 - Math.pow(salvage / cost, 1 / life);
+        var totalDep = 0;
+        for (var p = 1; p <= Math.floor(period); p++) {
+            var dep = (cost - totalDep) * rate * (p === 1 ? month / 12 : 1);
+            totalDep += dep;
+        }
+        var frac = period - Math.floor(period);
+        if (frac > 0) {
+            totalDep += (cost - totalDep) * rate * frac;
+        }
+        if (Math.floor(period) === 1) {
+            return (totalDep).toString();
+        }
+        var prev = 0;
+        for (var p = 1; p < Math.floor(period); p++) {
+            var dep = (cost - prev) * rate * (p === 1 ? month / 12 : 1);
+            prev += dep;
+        }
+        return (totalDep - prev).toString();
+    };
+    /**
+     * Returns the depreciation of an asset for a period using double-declining balance.
+     *
+     * Excel: `DDB(...)`.
+     *
+     * @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`.
+     */
+    FinancialDepreciationFormulas.prototype.ComputeDDB = 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 < 4 || args.length > 5) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var cost = this.resolveNumberArg(args[0]);
+        var salvage = this.resolveNumberArg(args[1]);
+        var life = this.resolveNumberArg(args[2]);
+        var period = this.resolveNumberArg(args[3]);
+        if (typeof cost === 'string') {
+            return cost;
+        }
+        if (typeof salvage === 'string') {
+            return salvage;
+        }
+        if (typeof life === 'string') {
+            return life;
+        }
+        if (typeof period === 'string') {
+            return period;
+        }
+        var factor = 2;
+        if (args.length === 5) {
+            var f = this.resolveNumberArg(args[4]);
+            if (typeof f === 'string') {
+                return f;
+            }
+            factor = f;
+        }
+        if (life <= 0 || period <= 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var rate = factor / life;
+        var book = cost;
+        var dep = 0;
+        for (var p = 1; p <= Math.floor(period); p++) {
+            dep = Math.min(book * rate, book - salvage);
+            book -= dep;
+        }
+        var frac = period - Math.floor(period);
+        if (frac > 0) {
+            dep = Math.min(book * rate * frac, (book - salvage) * frac);
+        }
+        return dep.toString();
+    };
+    return FinancialDepreciationFormulas;
+}(FormulaModuleBase));
+export { FinancialDepreciationFormulas };

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

@@ -0,0 +1,54 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Interest rate and yield conversions between nominal, effective, and periodic rates.
+ *
+ * Registered functions: EFFECT, NOMINAL, FVSCHEDULE.
+ *
+ * @hidden
+ */
+export declare class FinancialRatesFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns the effective annual interest rate.
+     *
+     * Excel: `EFFECT(...)`.
+     *
+     * @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('=EFFECT(1)');
+     * ```
+     */
+    ComputeEFFECT(...args: string[]): string | number;
+    /**
+     * Returns the nominal annual interest rate.
+     *
+     * Excel: `NOMINAL(...)`.
+     *
+     * @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`.
+     */
+    ComputeNOMINAL(...args: string[]): string | number;
+    /**
+     * Returns the future value of an initial principal after applying compound interest rates.
+     *
+     * Excel: `FVSCHEDULE(...)`.
+     *
+     * @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`.
+     */
+    ComputeFVSCHEDULE(...args: string[]): string | number;
+}

package/src/formulas/financial-rates.js

@@ -0,0 +1,140 @@
+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';
+/**
+ * Interest rate and yield conversions between nominal, effective, and periodic rates.
+ *
+ * Registered functions: EFFECT, NOMINAL, FVSCHEDULE.
+ *
+ * @hidden
+ */
+var FinancialRatesFormulas = /** @class */ (function (_super) {
+    __extends(FinancialRatesFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function FinancialRatesFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'EFFECT', category: 'Financial', description: 'Returns the effective annual interest rate.' },
+            { formulaName: 'NOMINAL', category: 'Financial', description: 'Returns the nominal annual interest rate.' },
+            { formulaName: 'FVSCHEDULE', category: 'Financial', description: 'Returns the future value of an initial principal after applying compound interest rates.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns the effective annual interest rate.
+     *
+     * Excel: `EFFECT(...)`.
+     *
+     * @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('=EFFECT(1)');
+     * ```
+     */
+    FinancialRatesFormulas.prototype.ComputeEFFECT = 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 nominal = this.resolveNumberArg(args[0]);
+        var npery = this.resolveNumberArg(args[1]);
+        if (typeof nominal === 'string') {
+            return nominal;
+        }
+        if (typeof npery === 'string') {
+            return npery;
+        }
+        if (npery < 1) {
+            return errCollection[CommonErrors.Num];
+        }
+        return (Math.pow(1 + nominal / npery, npery) - 1).toString();
+    };
+    /**
+     * Returns the nominal annual interest rate.
+     *
+     * Excel: `NOMINAL(...)`.
+     *
+     * @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`.
+     */
+    FinancialRatesFormulas.prototype.ComputeNOMINAL = 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 effect = this.resolveNumberArg(args[0]);
+        var npery = this.resolveNumberArg(args[1]);
+        if (typeof effect === 'string') {
+            return effect;
+        }
+        if (typeof npery === 'string') {
+            return npery;
+        }
+        if (npery < 1) {
+            return errCollection[CommonErrors.Num];
+        }
+        return (npery * (Math.pow(1 + effect, 1 / npery) - 1)).toString();
+    };
+    /**
+     * Returns the future value of an initial principal after applying compound interest rates.
+     *
+     * Excel: `FVSCHEDULE(...)`.
+     *
+     * @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`.
+     */
+    FinancialRatesFormulas.prototype.ComputeFVSCHEDULE = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length < 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var principal = this.resolveNumberArg(args[0]);
+        if (typeof principal === 'string') {
+            return principal;
+        }
+        var fv = principal;
+        for (var i = 1; i < args.length; i++) {
+            var rate = this.resolveNumberArg(args[i]);
+            if (typeof rate === 'string') {
+                return rate;
+            }
+            fv *= 1 + rate;
+        }
+        return fv.toString();
+    };
+    return FinancialRatesFormulas;
+}(FormulaModuleBase));
+export { FinancialRatesFormulas };

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

@@ -0,0 +1,126 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Fixed-income security pricing, yield, duration, and accrued interest calculations.
+ *
+ * Registers 10 functions including DOLLARDE, DOLLARFR, DISC, DURATION, INTRATE, and others.
+ *
+ * @hidden
+ */
+export declare class FinancialSecuritiesFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Converts a dollar price expressed as a fraction into a decimal number.
+     *
+     * Excel: `DOLLARDE(...)`.
+     *
+     * @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('=DOLLARDE(1)');
+     * ```
+     */
+    ComputeDOLLARDE(...args: string[]): string | number;
+    /**
+     * Converts a dollar price expressed as a decimal number into a fraction.
+     *
+     * Excel: `DOLLARFR(...)`.
+     *
+     * @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`.
+     */
+    ComputeDOLLARFR(...args: string[]): string | number;
+    /**
+     * Returns the discount rate for a security.
+     *
+     * Excel: `DISC(...)`.
+     *
+     * @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`.
+     */
+    ComputeDISC(...args: string[]): string | number;
+    /**
+     * Returns the annual duration of a security with periodic interest payments.
+     *
+     * Excel: `DURATION(...)`.
+     *
+     * @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`.
+     */
+    ComputeDURATION(...args: string[]): string | number;
+    /**
+     * Returns the interest rate for a fully invested security.
+     *
+     * Excel: `INTRATE(...)`.
+     *
+     * @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`.
+     */
+    ComputeINTRATE(...args: string[]): string | number;
+    /**
+     * Returns the amount received at maturity for a fully invested security.
+     *
+     * Excel: `RECEIVED(...)`.
+     *
+     * @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`.
+     */
+    ComputeRECEIVED(...args: string[]): string | number;
+    /**
+     * Returns the cumulative interest paid between two periods.
+     *
+     * Excel: `CUMIPMT(...)`.
+     *
+     * @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`.
+     */
+    ComputeCUMIPMT(...args: string[]): string | number;
+    /**
+     * Returns the cumulative principal paid on a loan between two periods.
+     *
+     * Excel: `CUMPRINC(...)`.
+     *
+     * @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`.
+     */
+    ComputeCUMPRINC(...args: string[]): string | number;
+    private cumIpmtPrinc;
+    private computePmt;
+    /**
+     * Returns the depreciation of an asset for a period using the declining balance method.
+     *
+     * Excel: `VDB(...)`.
+     *
+     * @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`.
+     */
+    ComputeVDB(...args: string[]): string | number;
+    /**
+     * Returns the internal rate of return for a schedule of cash flows that is not necessarily periodic.
+     *
+     * Excel: `XIRR(...)`.
+     *
+     * @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`.
+     */
+    ComputeXIRR(...args: string[]): string | number;
+}