@syncfusion/ej2-calculate 35.1.37

package/src/formulas/complex-numbers.js

@@ -0,0 +1,549 @@
+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 { parseComplexText, formatComplex } from './formula-math-helpers';
+/**
+ * Complex-number arithmetic, polar/rectangular conversion, and complex transcendental functions.
+ *
+ * Registers 18 functions including COMPLEX, IMABS, IMAGINARY, IMREAL, IMCONJUGATE, and others.
+ *
+ * @hidden
+ */
+var ComplexNumbersFormulas = /** @class */ (function (_super) {
+    __extends(ComplexNumbersFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function ComplexNumbersFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'COMPLEX', category: 'Engineering', description: 'Converts real and imaginary coefficients into a complex number.' },
+            { formulaName: 'IMABS', category: 'Engineering', description: 'Returns the absolute value (modulus) of a complex number.' },
+            { formulaName: 'IMAGINARY', category: 'Engineering', description: 'Returns the imaginary coefficient of a complex number.' },
+            { formulaName: 'IMREAL', category: 'Engineering', description: 'Returns the real coefficient of a complex number.' },
+            { formulaName: 'IMCONJUGATE', category: 'Engineering', description: 'Returns the complex conjugate of a complex number.' },
+            { formulaName: 'IMSUM', category: 'Engineering', description: 'Returns the sum of complex numbers.' },
+            { formulaName: 'IMSUB', category: 'Engineering', description: 'Returns the difference between two complex numbers.' },
+            { formulaName: 'IMPRODUCT', category: 'Engineering', description: 'Returns the product of complex numbers.' },
+            { formulaName: 'IMDIV', category: 'Engineering', description: 'Returns the quotient of two complex numbers.' },
+            { formulaName: 'IMSIN', category: 'Engineering', description: 'Returns the sine of a complex number.' },
+            { formulaName: 'IMCOS', category: 'Engineering', description: 'Returns the cosine of a complex number.' },
+            { formulaName: 'IMEXP', category: 'Engineering', description: 'Returns the exponential of a complex number.' },
+            { formulaName: 'IMLN', category: 'Engineering', description: 'Returns the natural logarithm of a complex number.' },
+            { formulaName: 'IMSQRT', category: 'Engineering', description: 'Returns the square root of a complex number.' },
+            { formulaName: 'IMPOWER', category: 'Engineering', description: 'Returns a complex number raised to an integer power.' },
+            { formulaName: 'IMARGUMENT', category: 'Engineering', description: 'Returns the argument theta of a complex number in radians.' },
+            { formulaName: 'IMLOG10', category: 'Engineering', description: 'Returns the base-10 logarithm of a complex number.' },
+            { formulaName: 'IMLOG2', category: 'Engineering', description: 'Returns the base-2 logarithm of a complex number.' }
+        ];
+        return _this;
+    }
+    ComplexNumbersFormulas.prototype.resolveComplex = function (arg) {
+        var errCollection = this.parent.getErrorStrings();
+        var text = this.resolveTextArg(arg);
+        if (errCollection.indexOf(text) > -1) {
+            return text;
+        }
+        var parsed = parseComplexText(text);
+        if (!parsed) {
+            return errCollection[CommonErrors.Num];
+        }
+        return parsed;
+    };
+    /**
+     * Converts real and imaginary coefficients into a complex number.
+     *
+     * Excel: `COMPLEX(...)`.
+     *
+     * @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('=COMPLEX(1)');
+     * ```
+     */
+    ComplexNumbersFormulas.prototype.ComputeCOMPLEX = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length < 2 || args.length > 3) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var re = this.resolveNumberArg(args[0]);
+        var im = this.resolveNumberArg(args[1]);
+        if (typeof re === 'string') {
+            return re;
+        }
+        if (typeof im === 'string') {
+            return im;
+        }
+        var suffix = 'i';
+        if (args.length === 3) {
+            suffix = this.resolveTextArg(args[2]);
+            if (suffix !== 'i' && suffix !== 'j') {
+                return this.parent.getErrorStrings()[CommonErrors.Value];
+            }
+        }
+        return formatComplex(re, im, suffix);
+    };
+    /**
+     * Returns the absolute value (modulus) of a complex number.
+     *
+     * Excel: `IMABS(...)`.
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMABS = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var c = this.resolveComplex(args[0]);
+        if (typeof c === 'string') {
+            return c;
+        }
+        return Math.sqrt(c.re * c.re + c.im * c.im).toString();
+    };
+    /**
+     * Returns the imaginary coefficient of a complex number.
+     *
+     * Excel: `IMAGINARY(...)`.
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMAGINARY = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var c = this.resolveComplex(args[0]);
+        if (typeof c === 'string') {
+            return c;
+        }
+        return c.im.toString();
+    };
+    /**
+     * Returns the real coefficient of a complex number.
+     *
+     * Excel: `IMREAL(...)`.
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMREAL = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var c = this.resolveComplex(args[0]);
+        if (typeof c === 'string') {
+            return c;
+        }
+        return c.re.toString();
+    };
+    /**
+     * Returns the complex conjugate of a complex number.
+     *
+     * Excel: `IMCONJUGATE(...)`.
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMCONJUGATE = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var c = this.resolveComplex(args[0]);
+        if (typeof c === 'string') {
+            return c;
+        }
+        return formatComplex(c.re, -c.im);
+    };
+    /**
+     * Returns the sum of complex numbers.
+     *
+     * Excel: `IMSUM(...)`.
+     *
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMSUM = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.complexReduce(args, function (a, b) { return ({ re: a.re + b.re, im: a.im + b.im }); });
+    };
+    /**
+     * Returns the difference between two complex numbers.
+     *
+     * Excel: `IMSUB(...)`.
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMSUB = 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 a = this.resolveComplex(args[0]);
+        var b = this.resolveComplex(args[1]);
+        if (typeof a === 'string') {
+            return a;
+        }
+        if (typeof b === 'string') {
+            return b;
+        }
+        return formatComplex(a.re - b.re, a.im - b.im);
+    };
+    /**
+     * Returns the product of complex numbers.
+     *
+     * Excel: `IMPRODUCT(...)`.
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMPRODUCT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.complexReduce(args, function (a, b) { return ({
+            re: a.re * b.re - a.im * b.im,
+            im: a.re * b.im + a.im * b.re
+        }); }, { re: 1, im: 0 });
+    };
+    /**
+     * Returns the quotient of two complex numbers.
+     *
+     * Excel: `IMDIV(...)`.
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMDIV = 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 a = this.resolveComplex(args[0]);
+        var b = this.resolveComplex(args[1]);
+        if (typeof a === 'string') {
+            return a;
+        }
+        if (typeof b === 'string') {
+            return b;
+        }
+        var denom = b.re * b.re + b.im * b.im;
+        if (denom === 0) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        return formatComplex((a.re * b.re + a.im * b.im) / denom, (a.im * b.re - a.re * b.im) / denom);
+    };
+    ComplexNumbersFormulas.prototype.complexReduce = function (args, fn, initial) {
+        if (isNullOrUndefined(args) || args.length < 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var acc = initial !== undefined ? initial : this.resolveComplex(args[0]);
+        if (typeof acc === 'string') {
+            return acc;
+        }
+        var start = initial ? 0 : 1;
+        for (var i = start; i < args.length; i++) {
+            var b = this.resolveComplex(args[i]);
+            if (typeof b === 'string') {
+                return b;
+            }
+            acc = fn(acc, b);
+        }
+        return formatComplex(acc.re, acc.im);
+    };
+    /**
+     * Returns the exponential of a complex number.
+     *
+     * Excel: `IMEXP(...)`.
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMEXP = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var c = this.resolveComplex(args[0]);
+        if (typeof c === 'string') {
+            return c;
+        }
+        var expRe = Math.exp(c.re);
+        return formatComplex(expRe * Math.cos(c.im), expRe * Math.sin(c.im));
+    };
+    /**
+     * Returns the natural logarithm of a complex number.
+     *
+     * Excel: `IMLN(...)`.
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMLN = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var c = this.resolveComplex(args[0]);
+        if (typeof c === 'string') {
+            return c;
+        }
+        var r = Math.sqrt(c.re * c.re + c.im * c.im);
+        if (r === 0) {
+            return this.parent.getErrorStrings()[CommonErrors.Num];
+        }
+        return formatComplex(Math.log(r), Math.atan2(c.im, c.re));
+    };
+    /**
+     * Returns the base-10 logarithm of a complex number.
+     *
+     * Excel: `IMLOG10(...)`.
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMLOG10 = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var ln = this.ComputeIMLN.apply(this, args);
+        if (typeof ln === 'string' && this.parent.getErrorStrings().indexOf(ln) > -1) {
+            return ln;
+        }
+        var c = parseComplexText(ln.toString());
+        if (!c) {
+            return ln;
+        }
+        var log10e = 1 / Math.LN10;
+        return formatComplex(c.re * log10e, c.im * log10e);
+    };
+    /**
+     * Returns the base-2 logarithm of a complex number.
+     *
+     * Excel: `IMLOG2(...)`.
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMLOG2 = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var ln = this.ComputeIMLN.apply(this, args);
+        if (typeof ln === 'string' && this.parent.getErrorStrings().indexOf(ln) > -1) {
+            return ln;
+        }
+        var c = parseComplexText(ln.toString());
+        if (!c) {
+            return ln;
+        }
+        var log2e = 1 / Math.LN2;
+        return formatComplex(c.re * log2e, c.im * log2e);
+    };
+    /**
+     * Returns the square root of a complex number.
+     *
+     * Excel: `IMSQRT(...)`.
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMSQRT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var c = this.resolveComplex(args[0]);
+        if (typeof c === 'string') {
+            return c;
+        }
+        var r = Math.sqrt(c.re * c.re + c.im * c.im);
+        var theta = Math.atan2(c.im, c.re);
+        var sqrtR = Math.sqrt(r);
+        return formatComplex(sqrtR * Math.cos(theta / 2), sqrtR * Math.sin(theta / 2));
+    };
+    /**
+     * Returns a complex number raised to an integer power.
+     *
+     * Excel: `IMPOWER(...)`.
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMPOWER = 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 c = this.resolveComplex(args[0]);
+        var nArg = this.resolveNumberArg(args[1]);
+        if (typeof c === 'string') {
+            return c;
+        }
+        if (typeof nArg === 'string') {
+            return nArg;
+        }
+        var n = Math.floor(nArg);
+        var r = Math.sqrt(c.re * c.re + c.im * c.im);
+        if (r === 0 && n <= 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var theta = Math.atan2(c.im, c.re);
+        var rn = Math.pow(r, n);
+        var angle = n * theta;
+        return formatComplex(rn * Math.cos(angle), rn * Math.sin(angle));
+    };
+    /**
+     * Returns the argument theta of a complex number in radians.
+     *
+     * Excel: `IMARGUMENT(...)`.
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMARGUMENT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var c = this.resolveComplex(args[0]);
+        if (typeof c === 'string') {
+            return c;
+        }
+        if (c.re === 0 && c.im === 0) {
+            return this.parent.getErrorStrings()[CommonErrors.DivZero];
+        }
+        return Math.atan2(c.im, c.re).toString();
+    };
+    /**
+     * Returns the sine of a complex number.
+     *
+     * Excel: `IMSIN(...)`.
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMSIN = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var c = this.resolveComplex(args[0]);
+        if (typeof c === 'string') {
+            return c;
+        }
+        return formatComplex(Math.sin(c.re) * Math.cosh(c.im), Math.cos(c.re) * Math.sinh(c.im));
+    };
+    /**
+     * Returns the cosine of a complex number.
+     *
+     * Excel: `IMCOS(...)`.
+     *
+     * @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`.
+     */
+    ComplexNumbersFormulas.prototype.ComputeIMCOS = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var c = this.resolveComplex(args[0]);
+        if (typeof c === 'string') {
+            return c;
+        }
+        return formatComplex(Math.cos(c.re) * Math.cosh(c.im), -Math.sin(c.re) * Math.sinh(c.im));
+    };
+    return ComplexNumbersFormulas;
+}(FormulaModuleBase));
+export { ComplexNumbersFormulas };

package/src/formulas/database.d.ts

@@ -0,0 +1,152 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Database-style conditional aggregates (DSUM, DCOUNT, DGET) over structured table ranges.
+ *
+ * Registers 12 functions including DAVERAGE, DCOUNT, DCOUNTA, DGET, DMAX, and others.
+ *
+ * @hidden
+ */
+export declare class DatabaseFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    private readRange;
+    private fieldIndex;
+    private matchCriteria;
+    private matchesCriterion;
+    private collectMatching;
+    private requireThree;
+    private mean;
+    private variance;
+    /**
+     * Averages the values in a column of a list or database that match criteria.
+     *
+     * Excel: `DAVERAGE(...)`.
+     *
+     * @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('=DAVERAGE(1)');
+     * ```
+     */
+    ComputeDAVERAGE(...args: string[]): string | number;
+    /**
+     * Counts the cells that contain numbers in a column of a list or database that match criteria.
+     *
+     * Excel: `DCOUNT(...)`.
+     *
+     * @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`.
+     */
+    ComputeDCOUNT(...args: string[]): string | number;
+    /**
+     * Counts nonblank cells in a column of a list or database that match criteria.
+     *
+     * Excel: `DCOUNTA(...)`.
+     *
+     * @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`.
+     */
+    ComputeDCOUNTA(...args: string[]): string | number;
+    /**
+     * Extracts a single value from a column of a list or database that matches criteria.
+     *
+     * Excel: `DGET(...)`.
+     *
+     * @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`.
+     */
+    ComputeDGET(...args: string[]): string | number;
+    /**
+     * Returns the maximum value from a column of a list or database that matches criteria.
+     *
+     * Excel: `DMAX(...)`.
+     *
+     * @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`.
+     */
+    ComputeDMAX(...args: string[]): string | number;
+    /**
+     * Returns the minimum value from a column of a list or database that matches criteria.
+     *
+     * Excel: `DMIN(...)`.
+     *
+     * @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`.
+     */
+    ComputeDMIN(...args: string[]): string | number;
+    /**
+     * Multiplies values in a column of a list or database that match criteria.
+     *
+     * Excel: `DPRODUCT(...)`.
+     *
+     * @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`.
+     */
+    ComputeDPRODUCT(...args: string[]): string | number;
+    /**
+     * Adds the numbers in the field column of records in the database that match the criteria.
+     *
+     * Excel: `DSUM(...)`.
+     *
+     * @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`.
+     */
+    ComputeDSUM(...args: string[]): string | number;
+    /**
+     * Estimates the standard deviation of a population based on a sample of entries that match criteria.
+     *
+     * Excel: `DSTDEV(...)`.
+     *
+     * @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`.
+     */
+    ComputeDSTDEV(...args: string[]): string | number;
+    /**
+     * Calculates the standard deviation of a population based on entries that match criteria.
+     *
+     * Excel: `DSTDEVP(...)`.
+     *
+     * @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`.
+     */
+    ComputeDSTDEVP(...args: string[]): string | number;
+    /**
+     * Estimates variance based on a sample of entries that match criteria.
+     *
+     * Excel: `DVAR(...)`.
+     *
+     * @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`.
+     */
+    ComputeDVAR(...args: string[]): string | number;
+    /**
+     * Calculates variance based on the entire population of entries that match criteria.
+     *
+     * Excel: `DVARP(...)`.
+     *
+     * @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`.
+     */
+    ComputeDVARP(...args: string[]): string | number;
+}