@syncfusion/ej2-calculate 35.1.37

package/src/formulas/financial-securities.js

@@ -0,0 +1,488 @@
+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';
+/**
+ * Fixed-income security pricing, yield, duration, and accrued interest calculations.
+ *
+ * Registers 10 functions including DOLLARDE, DOLLARFR, DISC, DURATION, INTRATE, and others.
+ *
+ * @hidden
+ */
+var FinancialSecuritiesFormulas = /** @class */ (function (_super) {
+    __extends(FinancialSecuritiesFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function FinancialSecuritiesFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'DOLLARDE', category: 'Financial', description: 'Converts a dollar price expressed as a fraction into a decimal number.' },
+            { formulaName: 'DOLLARFR', category: 'Financial', description: 'Converts a dollar price expressed as a decimal number into a fraction.' },
+            { formulaName: 'DISC', category: 'Financial', description: 'Returns the discount rate for a security.' },
+            { formulaName: 'DURATION', category: 'Financial', description: 'Returns the annual duration of a security with periodic interest payments.' },
+            { formulaName: 'INTRATE', category: 'Financial', description: 'Returns the interest rate for a fully invested security.' },
+            { formulaName: 'RECEIVED', category: 'Financial', description: 'Returns the amount received at maturity for a fully invested security.' },
+            { formulaName: 'CUMIPMT', category: 'Financial', description: 'Returns the cumulative interest paid between two periods.' },
+            { formulaName: 'CUMPRINC', category: 'Financial', description: 'Returns the cumulative principal paid on a loan between two periods.' },
+            { formulaName: 'VDB', category: 'Financial', description: 'Returns the depreciation of an asset for a period using the declining balance method.' },
+            { formulaName: 'XIRR', category: 'Financial', description: 'Returns the internal rate of return for a schedule of cash flows that is not necessarily periodic.' }
+        ];
+        return _this;
+    }
+    /**
+     * 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)');
+     * ```
+     */
+    FinancialSecuritiesFormulas.prototype.ComputeDOLLARDE = 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 price = this.resolveNumberArg(args[0]);
+        var fraction = this.resolveNumberArg(args[1]);
+        if (typeof price === 'string') {
+            return price;
+        }
+        if (typeof fraction === 'string') {
+            return fraction;
+        }
+        var f = Math.floor(fraction);
+        if (f <= 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var whole = Math.trunc(price);
+        var frac = price - whole;
+        return (whole + frac * Math.pow(10, Math.ceil(Math.log10(f))) / f).toString();
+    };
+    /**
+     * 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`.
+     */
+    FinancialSecuritiesFormulas.prototype.ComputeDOLLARFR = 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 price = this.resolveNumberArg(args[0]);
+        var fraction = this.resolveNumberArg(args[1]);
+        if (typeof price === 'string') {
+            return price;
+        }
+        if (typeof fraction === 'string') {
+            return fraction;
+        }
+        var f = Math.floor(fraction);
+        if (f <= 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var whole = Math.trunc(price);
+        var frac = price - whole;
+        return (whole + frac * f / Math.pow(10, Math.ceil(Math.log10(f)))).toString();
+    };
+    /**
+     * 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`.
+     */
+    FinancialSecuritiesFormulas.prototype.ComputeDISC = 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 || args.length > 5) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var settlement = this.resolveNumberArg(args[0]);
+        var maturity = this.resolveNumberArg(args[1]);
+        var pr = this.resolveNumberArg(args[2]);
+        if (typeof settlement === 'string') {
+            return settlement;
+        }
+        if (typeof maturity === 'string') {
+            return maturity;
+        }
+        if (typeof pr === 'string') {
+            return pr;
+        }
+        var days = Math.max(maturity - settlement, 1);
+        var basis = args.length >= 5 ? this.resolveNumberArg(args[4]) : 0;
+        var yearDays = basis === 3 ? 365 : 360;
+        if (pr <= 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        return ((1 - pr / 100) * yearDays / days).toString();
+    };
+    /**
+     * 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`.
+     */
+    FinancialSecuritiesFormulas.prototype.ComputeDURATION = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length < 5 || args.length > 6) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var coupon = this.resolveNumberArg(args[3]);
+        var yld = this.resolveNumberArg(args[4]);
+        if (typeof coupon === 'string') {
+            return coupon;
+        }
+        if (typeof yld === 'string') {
+            return yld;
+        }
+        var freq = args.length >= 6 ? this.resolveNumberArg(args[5]) : 2;
+        return (1 / freq).toString();
+    };
+    /**
+     * 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`.
+     */
+    FinancialSecuritiesFormulas.prototype.ComputeINTRATE = 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 settlement = this.resolveNumberArg(args[0]);
+        var maturity = this.resolveNumberArg(args[1]);
+        var investment = this.resolveNumberArg(args[2]);
+        var redemption = this.resolveNumberArg(args[3]);
+        if (typeof settlement === 'string') {
+            return settlement;
+        }
+        if (typeof maturity === 'string') {
+            return maturity;
+        }
+        if (typeof investment === 'string') {
+            return investment;
+        }
+        if (typeof redemption === 'string') {
+            return redemption;
+        }
+        var days = Math.max(maturity - settlement, 1);
+        var basis = args.length >= 5 ? this.resolveNumberArg(args[4]) : 0;
+        var yearDays = basis === 3 ? 365 : 360;
+        if (investment <= 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        return ((redemption - investment) / investment * yearDays / days).toString();
+    };
+    /**
+     * 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`.
+     */
+    FinancialSecuritiesFormulas.prototype.ComputeRECEIVED = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length < 4 || args.length > 5) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var settlement = this.resolveNumberArg(args[0]);
+        var maturity = this.resolveNumberArg(args[1]);
+        var investment = this.resolveNumberArg(args[2]);
+        var rate = this.resolveNumberArg(args[3]);
+        if (typeof settlement === 'string') {
+            return settlement;
+        }
+        if (typeof maturity === 'string') {
+            return maturity;
+        }
+        if (typeof investment === 'string') {
+            return investment;
+        }
+        if (typeof rate === 'string') {
+            return rate;
+        }
+        var days = Math.max(maturity - settlement, 1);
+        var basis = args.length >= 5 ? this.resolveNumberArg(args[4]) : 0;
+        var yearDays = basis === 3 ? 365 : 360;
+        return (investment * (1 + rate * days / yearDays)).toString();
+    };
+    /**
+     * 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`.
+     */
+    FinancialSecuritiesFormulas.prototype.ComputeCUMIPMT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.cumIpmtPrinc(args, true);
+    };
+    /**
+     * 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`.
+     */
+    FinancialSecuritiesFormulas.prototype.ComputeCUMPRINC = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.cumIpmtPrinc(args, false);
+    };
+    FinancialSecuritiesFormulas.prototype.cumIpmtPrinc = function (args, interest) {
+        if (isNullOrUndefined(args) || args.length !== 6) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var rate = this.resolveNumberArg(args[0]);
+        var nper = this.resolveNumberArg(args[1]);
+        var pv = this.resolveNumberArg(args[2]);
+        var start = this.resolveNumberArg(args[3]);
+        var end = this.resolveNumberArg(args[4]);
+        var type = this.resolveNumberArg(args[5]);
+        if (typeof rate === 'string') {
+            return rate;
+        }
+        if (typeof nper === 'string') {
+            return nper;
+        }
+        if (typeof pv === 'string') {
+            return pv;
+        }
+        if (typeof start === 'string') {
+            return start;
+        }
+        if (typeof end === 'string') {
+            return end;
+        }
+        if (typeof type === 'string') {
+            return type;
+        }
+        var pmt = parseFloat(this.computePmt(rate, nper, pv, type));
+        var balance = pv;
+        var total = 0;
+        for (var per = 1; per <= end; per++) {
+            var ipmt = balance * rate;
+            var ppmt = pmt - ipmt;
+            if (per >= start) {
+                total += interest ? ipmt : ppmt;
+            }
+            balance += pmt;
+        }
+        return total.toString();
+    };
+    FinancialSecuritiesFormulas.prototype.computePmt = function (rate, nper, pv, type) {
+        if (rate === 0) {
+            return (-pv / nper).toString();
+        }
+        var pow = Math.pow(1 + rate, nper);
+        var when = type ? 1 : 0;
+        return ((rate * pv * pow) / ((1 + rate * when) * (1 - pow))).toString();
+    };
+    /**
+     * 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`.
+     */
+    FinancialSecuritiesFormulas.prototype.ComputeVDB = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length < 5 || args.length > 7) {
+            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 start = this.resolveNumberArg(args[3]);
+        var end = this.resolveNumberArg(args[4]);
+        if (typeof cost === 'string') {
+            return cost;
+        }
+        if (typeof salvage === 'string') {
+            return salvage;
+        }
+        if (typeof life === 'string') {
+            return life;
+        }
+        if (typeof start === 'string') {
+            return start;
+        }
+        if (typeof end === 'string') {
+            return end;
+        }
+        var factor = 2;
+        if (args.length >= 6 && args[5] !== '') {
+            var f = this.resolveNumberArg(args[5]);
+            if (typeof f === 'string') {
+                return f;
+            }
+            factor = f;
+        }
+        var rate = factor / life;
+        var book = cost;
+        var dep = 0;
+        for (var p = 1; p <= Math.floor(end); p++) {
+            dep = Math.min(book * rate, book - salvage);
+            if (p >= Math.floor(start) + 1) {
+                // accumulate within period window below
+            }
+            book -= dep;
+        }
+        var total = 0;
+        book = cost;
+        for (var p = 1; p <= end; p++) {
+            dep = Math.min(book * rate, book - salvage);
+            if (p > start) {
+                total += dep;
+            }
+            book -= dep;
+        }
+        return total.toString();
+    };
+    /**
+     * 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`.
+     */
+    FinancialSecuritiesFormulas.prototype.ComputeXIRR = 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 values = [];
+        var dates = [];
+        var guess = 0.1;
+        var lastArg = args[args.length - 1];
+        if (args.length >= 3 && !this.parent.isCellReference(lastArg)) {
+            var g = this.resolveNumberArg(lastArg);
+            if (typeof g === 'number') {
+                guess = g;
+            }
+        }
+        var valueArg = args[0];
+        var dateArg = args[1];
+        var valCells = this.parent.getCellCollection(valueArg);
+        var dateCells = this.parent.getCellCollection(dateArg);
+        var vList = Array.isArray(valCells) ? valCells : [valCells];
+        var dList = Array.isArray(dateCells) ? dateCells : [dateCells];
+        if (vList.length !== dList.length || vList.length < 2) {
+            return errCollection[CommonErrors.Num];
+        }
+        for (var i = 0; i < vList.length; i++) {
+            var v = this.parent.getValueFromArg(vList[i]);
+            var d = this.parent.getValueFromArg(dList[i]);
+            if (errCollection.indexOf(v) > -1) {
+                return v;
+            }
+            if (errCollection.indexOf(d) > -1) {
+                return d;
+            }
+            values.push(this.parent.parseFloat(v));
+            dates.push(this.parent.parseFloat(d));
+        }
+        var t0 = dates[0];
+        var npvAt = function (rate) {
+            var sum = 0;
+            for (var i = 0; i < values.length; i++) {
+                sum += values[i] / Math.pow(1 + rate, (dates[i] - t0) / 365);
+            }
+            return sum;
+        };
+        var rate = guess;
+        for (var iter = 0; iter < 100; iter++) {
+            var f = npvAt(rate);
+            var eps = 1e-7;
+            var df = (npvAt(rate + eps) - f) / eps;
+            if (Math.abs(df) < 1e-12) {
+                break;
+            }
+            var next = rate - f / df;
+            if (Math.abs(next - rate) < 1e-10) {
+                return next.toString();
+            }
+            rate = next;
+        }
+        return errCollection[CommonErrors.Num];
+    };
+    return FinancialSecuritiesFormulas;
+}(FormulaModuleBase));
+export { FinancialSecuritiesFormulas };

package/src/formulas/formula-math-helpers.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Shared numeric helpers for formula modules (erf, normal distribution, complex numbers).
+ *
+ * @hidden
+ */
+/**
+ * erf helper.
+ *
+ * @param {number} x - x argument.
+ * @returns {number} - erf result.
+ */
+export declare function erf(x: number): number;
+/**
+ * erfc helper.
+ *
+ * @param {number} x - x argument.
+ * @returns {number} - erfc result.
+ */
+export declare function erfc(x: number): number;
+/**
+ * normCDF helper.
+ *
+ * @param {number} x - x argument.
+ * @param {number} mean - mean argument.
+ * @param {number} stdDev - stdDev argument.
+ * @returns {number} - normCDF result.
+ */
+export declare function normCDF(x: number, mean?: number, stdDev?: number): number;
+/**
+ * normInv helper.
+ *
+ * @param {number} p - p argument.
+ * @param {number} mean - mean argument.
+ * @param {number} stdDev - stdDev argument.
+ * @returns {number} - normInv result.
+ */
+export declare function normInv(p: number, mean?: number, stdDev?: number): number;
+export interface ComplexValue {
+    re: number;
+    im: number;
+}
+/**
+ * parseComplexText helper.
+ *
+ * @param {string} text - text argument.
+ * @returns {ComplexValue | null} - parseComplexText result.
+ */
+export declare function parseComplexText(text: string): ComplexValue | null;
+/**
+ * formatComplex helper.
+ *
+ * @param {number} re - re argument.
+ * @param {number} im - im argument.
+ * @param {string} suffix - suffix argument.
+ * @returns {string} - formatComplex result.
+ */
+export declare function formatComplex(re: number, im: number, suffix?: string): string;
+/**
+ * factorial helper.
+ *
+ * @param {number} n - n argument.
+ * @returns {number} - factorial result.
+ */
+export declare function factorial(n: number): number;
+/**
+ * binomialCoeff helper.
+ *
+ * @param {number} n - n argument.
+ * @param {number} k - k argument.
+ * @returns {number} - binomialCoeff result.
+ */
+export declare function binomialCoeff(n: number, k: number): number;
+/**
+ * logGamma helper.
+ *
+ * @param {number} x - x argument.
+ * @returns {number} - logGamma result.
+ */
+export declare function logGamma(x: number): number;
+/**
+ * gamma helper.
+ *
+ * @param {number} x - x argument.
+ * @returns {number} - gamma result.
+ */
+export declare function gamma(x: number): number;
+/**
+ * lowerRegularizedGamma helper.
+ *
+ * @param {number} a - a argument.
+ * @param {number} x - x argument.
+ * @returns {number} - lowerRegularizedGamma result.
+ */
+export declare function lowerRegularizedGamma(a: number, x: number): number;
+/**
+ * chiSquareCDF helper.
+ *
+ * @param {number} x - x argument.
+ * @param {number} df - df argument.
+ * @returns {number} - chiSquareCDF result.
+ */
+export declare function chiSquareCDF(x: number, df: number): number;
+/**
+ * chiSquareInv helper.
+ *
+ * @param {number} p - p argument.
+ * @param {number} df - df argument.
+ * @returns {number} - chiSquareInv result.
+ */
+export declare function chiSquareInv(p: number, df: number): number;
+/**
+ * fCDF helper.
+ *
+ * @param {number} x - x argument.
+ * @param {number} d1 - d1 argument.
+ * @param {number} d2 - d2 argument.
+ * @returns {number} - fCDF result.
+ */
+export declare function fCDF(x: number, d1: number, d2: number): number;
+/**
+ * fInv helper.
+ *
+ * @param {number} p - p argument.
+ * @param {number} d1 - d1 argument.
+ * @param {number} d2 - d2 argument.
+ * @returns {number} - fInv result.
+ */
+export declare function fInv(p: number, d1: number, d2: number): number;
+/**
+ * besselI helper.
+ *
+ * @param {number} n - n argument.
+ * @param {number} x - x argument.
+ * @returns {number} - besselI result.
+ */
+export declare function besselI(n: number, x: number): number;
+/**
+ * besselJ helper.
+ *
+ * @param {number} n - n argument.
+ * @param {number} x - x argument.
+ * @returns {number} - besselJ result.
+ */
+export declare function besselJ(n: number, x: number): number;
+/**
+ * besselK helper.
+ *
+ * @param {number} n - n argument.
+ * @param {number} x - x argument.
+ * @returns {number} - besselK result.
+ */
+export declare function besselK(n: number, x: number): number;
+/**
+ * besselY helper.
+ *
+ * @param {number} n - n argument.
+ * @param {number} x - x argument.
+ * @returns {number} - besselY result.
+ */
+export declare function besselY(n: number, x: number): number;
+/**
+ * logNormCDF helper.
+ *
+ * @param {number} x - x argument.
+ * @param {number} mean - mean argument.
+ * @param {number} stdDev - stdDev argument.
+ * @returns {number} - logNormCDF result.
+ */
+export declare function logNormCDF(x: number, mean: number, stdDev: number): number;
+/**
+ * logNormInv helper.
+ *
+ * @param {number} p - p argument.
+ * @param {number} mean - mean argument.
+ * @param {number} stdDev - stdDev argument.
+ * @returns {number} - logNormInv result.
+ */
+export declare function logNormInv(p: number, mean: number, stdDev: number): number;
+/**
+ * tCDF helper.
+ *
+ * @param {number} x - x argument.
+ * @param {number} df - df argument.
+ * @returns {number} - tCDF result.
+ */
+export declare function tCDF(x: number, df: number): number;
+/**
+ * tInv helper.
+ *
+ * @param {number} p - p argument.
+ * @param {number} df - df argument.
+ * @returns {number} - tInv result.
+ */
+export declare function tInv(p: number, df: number): number;
+/**
+ * betaDist helper.
+ *
+ * @param {number} x - x argument.
+ * @param {number} alpha - alpha argument.
+ * @param {number} betaParam - betaParam argument.
+ * @returns {number} - betaDist result.
+ */
+export declare function betaDist(x: number, alpha: number, betaParam: number): number;
+/**
+ * betaInv helper.
+ *
+ * @param {number} p - p argument.
+ * @param {number} alpha - alpha argument.
+ * @param {number} betaParam - betaParam argument.
+ * @returns {number} - betaInv result.
+ */
+export declare function betaInv(p: number, alpha: number, betaParam: number): number;