@syncfusion/ej2-calculate 35.1.37

package/src/formulas/financial-amortization-ecma.js

@@ -0,0 +1,288 @@
+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 { FinancialBondHelpers } from './financial-bond-helpers';
+/**
+ * ECMA amortization and odd-period bond pricing/yield functions for European accounting conventions.
+ *
+ * Registered functions: AMORDEGRC, AMORLINC, ODDFPRICE, ODDFYIELD, ODDLPRICE, ODDLYIELD.
+ *
+ * @hidden
+ */
+var FinancialAmortizationEcmaFormulas = /** @class */ (function (_super) {
+    __extends(FinancialAmortizationEcmaFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function FinancialAmortizationEcmaFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'AMORDEGRC', category: 'Financial', description: 'Returns the depreciation for each accounting period using a depreciation coefficient.' },
+            { formulaName: 'AMORLINC', category: 'Financial', description: 'Returns the depreciation for each accounting period.' },
+            { formulaName: 'ODDFPRICE', category: 'Financial', description: 'Returns the price per $100 face value of a security with an odd first period.' },
+            { formulaName: 'ODDFYIELD', category: 'Financial', description: 'Returns the yield of a security with an odd first period.' },
+            { formulaName: 'ODDLPRICE', category: 'Financial', description: 'Returns the price per $100 face value of a security with an odd last period.' },
+            { formulaName: 'ODDLYIELD', category: 'Financial', description: 'Returns the yield of a security with an odd last period.' }
+        ];
+        _this.bond = new FinancialBondHelpers(_this.parent);
+        return _this;
+    }
+    /**
+     * 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)');
+     * ```
+     */
+    FinancialAmortizationEcmaFormulas.prototype.ComputeAMORLINC = 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 < 6 || args.length > 7) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var cost = this.resolveNumberArg(args[0]);
+        var purchased = this.resolveNumberArg(args[1]);
+        var firstPeriod = this.resolveNumberArg(args[2]);
+        var salvage = this.resolveNumberArg(args[3]);
+        var period = this.resolveNumberArg(args[4]);
+        var rate = this.resolveNumberArg(args[5]);
+        if (typeof cost === 'string') {
+            return cost;
+        }
+        if (typeof purchased === 'string') {
+            return purchased;
+        }
+        if (typeof firstPeriod === 'string') {
+            return firstPeriod;
+        }
+        if (typeof salvage === 'string') {
+            return salvage;
+        }
+        if (typeof period === 'string') {
+            return period;
+        }
+        if (typeof rate === 'string') {
+            return rate;
+        }
+        var p = Math.floor(period);
+        if (p < 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var dep = Math.min((cost - salvage) * rate * (p + 1), cost - salvage);
+        return dep.toString();
+    };
+    /**
+     * 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`.
+     */
+    FinancialAmortizationEcmaFormulas.prototype.ComputeAMORDEGRC = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length < 7 || args.length > 8) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var cost = this.resolveNumberArg(args[0]);
+        var purchased = this.resolveNumberArg(args[1]);
+        var firstPeriod = this.resolveNumberArg(args[2]);
+        var salvage = this.resolveNumberArg(args[3]);
+        var period = this.resolveNumberArg(args[4]);
+        var rate = this.resolveNumberArg(args[5]);
+        var basis = args.length >= 8 ? this.resolveNumberArg(args[7]) : 0;
+        if (typeof cost === 'string') {
+            return cost;
+        }
+        if (typeof purchased === 'string') {
+            return purchased;
+        }
+        if (typeof firstPeriod === 'string') {
+            return firstPeriod;
+        }
+        if (typeof salvage === 'string') {
+            return salvage;
+        }
+        if (typeof period === 'string') {
+            return period;
+        }
+        if (typeof rate === 'string') {
+            return rate;
+        }
+        if (typeof basis === 'string') {
+            return basis;
+        }
+        var coef = rate < 0.03 ? 1 : rate < 0.05 ? 1.5 : rate < 0.1 ? 2 : 2.5;
+        var linear = this.ComputeAMORLINC(args[0], args[1], args[2], args[3], args[4], (rate * coef).toString());
+        return linear;
+    };
+    FinancialAmortizationEcmaFormulas.prototype.oddBondPrice = function (args, oddFirst) {
+        if (isNullOrUndefined(args) || args.length < 7 || args.length > 9) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var settlement = this.resolveNumberArg(args[0]);
+        var maturity = this.resolveNumberArg(args[1]);
+        var issue = this.resolveNumberArg(args[2]);
+        var firstCoupon = this.resolveNumberArg(args[3]);
+        var rate = this.resolveNumberArg(args[4]);
+        var yld = this.resolveNumberArg(args[5]);
+        var redemption = this.resolveNumberArg(args[6]);
+        if (typeof settlement === 'string') {
+            return settlement;
+        }
+        if (typeof maturity === 'string') {
+            return maturity;
+        }
+        if (typeof issue === 'string') {
+            return issue;
+        }
+        if (typeof firstCoupon === 'string') {
+            return firstCoupon;
+        }
+        if (typeof rate === 'string') {
+            return rate;
+        }
+        if (typeof yld === 'string') {
+            return yld;
+        }
+        if (typeof redemption === 'string') {
+            return redemption;
+        }
+        var freq = args.length >= 8 && args[7] !== '' ? this.resolveNumberArg(args[7]) : 2;
+        var basis = args.length >= 9 && args[8] !== '' ? this.resolveNumberArg(args[8]) : 0;
+        if (typeof freq === 'string') {
+            return freq;
+        }
+        if (typeof basis === 'string') {
+            return basis;
+        }
+        var n = this.bond.coupNum(settlement, maturity, freq, basis);
+        var coupon = 100 * rate / freq;
+        var refDate = oddFirst ? firstCoupon : maturity;
+        var days = this.bond.daysBetween(settlement, refDate, basis);
+        var periodDays = this.bond.coupDays(settlement, maturity, freq, basis) || 180;
+        var price = redemption / Math.pow(1 + yld / freq, n + days / periodDays);
+        price += coupon * days / periodDays;
+        for (var k = 1; k <= n; k++) {
+            price += coupon / Math.pow(1 + yld / freq, k - 1 + days / periodDays);
+        }
+        return price.toString();
+    };
+    /**
+     * 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`.
+     */
+    FinancialAmortizationEcmaFormulas.prototype.ComputeODDFPRICE = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.oddBondPrice(args, true);
+    };
+    /**
+     * 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`.
+     */
+    FinancialAmortizationEcmaFormulas.prototype.ComputeODDLPRICE = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.oddBondPrice(args, false);
+    };
+    FinancialAmortizationEcmaFormulas.prototype.oddBondYield = function (computePrice, args) {
+        var priceArg = args[6];
+        var yldGuess = 0.05;
+        var yld = yldGuess;
+        var target = this.parent.parseFloat(this.resolveNumberArg(priceArg));
+        for (var iter = 0; iter < 50; iter++) {
+            var trialArgs = args.slice(0, 6).concat([yld.toString()], args.slice(7));
+            var p = this.parent.parseFloat(computePrice.apply(void 0, trialArgs));
+            var diff = p - target;
+            if (Math.abs(diff) < 1e-6) {
+                return yld.toString();
+            }
+            yld -= diff * 0.0001;
+        }
+        return yld.toString();
+    };
+    /**
+     * 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`.
+     */
+    FinancialAmortizationEcmaFormulas.prototype.ComputeODDFYIELD = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length < 8 || args.length > 9) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        return this.oddBondYield(this.ComputeODDFPRICE.bind(this), args);
+    };
+    /**
+     * 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`.
+     */
+    FinancialAmortizationEcmaFormulas.prototype.ComputeODDLYIELD = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length < 8 || args.length > 9) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        return this.oddBondYield(this.ComputeODDLPRICE.bind(this), args);
+    };
+    return FinancialAmortizationEcmaFormulas;
+}(FormulaModuleBase));
+export { FinancialAmortizationEcmaFormulas };

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

@@ -0,0 +1,104 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Annuity and payment functions: present/future value, payment amount, periods, and interest rate.
+ *
+ * Registered functions: FV, PV, PMT, NPER, IPMT, PPMT, NPV, RATE.
+ *
+ * @hidden
+ */
+export declare class FinancialAnnuityFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    private resolveOptional;
+    /**
+     * Returns the future value of an investment.
+     *
+     * Excel: `FV(...)`.
+     *
+     * @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('=FV(1)');
+     * ```
+     */
+    ComputeFV(...args: string[]): string | number;
+    /**
+     * Returns the present value of an investment.
+     *
+     * Excel: `PV(...)`.
+     *
+     * @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`.
+     */
+    ComputePV(...args: string[]): string | number;
+    /**
+     * Returns the periodic payment for an annuity.
+     *
+     * Excel: `PMT(...)`.
+     *
+     * @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`.
+     */
+    ComputePMT(...args: string[]): string | number;
+    /**
+     * Returns the number of periods for an investment.
+     *
+     * Excel: `NPER(...)`.
+     *
+     * @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`.
+     */
+    ComputeNPER(...args: string[]): string | number;
+    /**
+     * Returns the interest payment for an investment for a given period.
+     *
+     * Excel: `IPMT(...)`.
+     *
+     * @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`.
+     */
+    ComputeIPMT(...args: string[]): string | number;
+    /**
+     * Returns the payment on the principal for an investment for a given period.
+     *
+     * Excel: `PPMT(...)`.
+     *
+     * @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`.
+     */
+    ComputePPMT(...args: string[]): string | number;
+    /**
+     * Returns the net present value of an investment based on periodic cash flows.
+     *
+     * Excel: `NPV(...)`.
+     *
+     * @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`.
+     */
+    ComputeNPV(...args: string[]): string | number;
+    /**
+     * Returns the interest rate per period of an annuity.
+     *
+     * Excel: `RATE(...)`.
+     *
+     * @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`.
+     */
+    ComputeRATE(...args: string[]): string | number;
+}