@syncfusion/ej2-calculate 35.1.37

package/src/formulas/statistical-extended.js

@@ -0,0 +1,340 @@
+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 { StatisticalSampleBase } from './statistical-sample-base';
+import { logGamma } from './formula-math-helpers';
+/**
+ * Large-sample and array statistical helpers beyond basic descriptive functions.
+ *
+ * Registers 11 functions including STDEVA, STDEVPA, VARA, VARPA, TRIMMEAN, and others.
+ *
+ * @hidden
+ */
+var StatisticalExtendedFormulas = /** @class */ (function (_super) {
+    __extends(StatisticalExtendedFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function StatisticalExtendedFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'STDEVA', category: 'Statistical', description: 'Estimates standard deviation based on a sample, including text and logicals.' },
+            { formulaName: 'STDEVPA', category: 'Statistical', description: 'Calculates standard deviation based on the entire population, including text and logicals.' },
+            { formulaName: 'VARA', category: 'Statistical', description: 'Estimates variance based on a sample, including text and logicals.' },
+            { formulaName: 'VARPA', category: 'Statistical', description: 'Calculates variance based on the entire population, including text and logicals.' },
+            { formulaName: 'TRIMMEAN', category: 'Statistical', description: 'Returns the mean of the interior of a data set.' },
+            { formulaName: 'FISHER', category: 'Statistical', description: 'Returns the Fisher transformation.' },
+            { formulaName: 'FISHERINV', category: 'Statistical', description: 'Returns the inverse of the Fisher transformation.' },
+            { formulaName: 'GAMMALN', category: 'Statistical', description: 'Returns the natural logarithm of the gamma function.' },
+            { formulaName: 'SUMX2MY2', category: 'Statistical', description: 'Returns the sum of the difference of squares of corresponding values in two arrays.' },
+            { formulaName: 'SUMX2PY2', category: 'Statistical', description: 'Returns the sum of the sum of squares of corresponding values in two arrays.' },
+            { formulaName: 'SUMXMY2', category: 'Statistical', description: 'Returns the sum of squares of differences of corresponding values in two arrays.' }
+        ];
+        return _this;
+    }
+    StatisticalExtendedFormulas.prototype.stdevVarA = function (args, population, asVar) {
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || (args.length === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        var nums = this.collectSample(args, true);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length < (population ? 1 : 2)) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        var avg = this.mean(nums);
+        var sumSq = 0;
+        for (var i = 0; i < nums.length; i++) {
+            var d = nums[i] - avg;
+            sumSq += d * d;
+        }
+        var denom = population ? nums.length : nums.length - 1;
+        var v = sumSq / denom;
+        return (asVar ? v : Math.sqrt(v)).toString();
+    };
+    /**
+     * Estimates standard deviation based on a sample, including text and logicals.
+     *
+     * Excel: `STDEVA(...)`.
+     *
+     * @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('=STDEVA(1)');
+     * ```
+     */
+    StatisticalExtendedFormulas.prototype.ComputeSTDEVA = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.stdevVarA(args, false, false);
+    };
+    /**
+     * Calculates standard deviation based on the entire population, including text and logicals.
+     *
+     * Excel: `STDEVPA(...)`.
+     *
+     * @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`.
+     */
+    StatisticalExtendedFormulas.prototype.ComputeSTDEVPA = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.stdevVarA(args, true, false);
+    };
+    /**
+     * Estimates variance based on a sample, including text and logicals.
+     *
+     * Excel: `VARA(...)`.
+     *
+     * @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`.
+     */
+    StatisticalExtendedFormulas.prototype.ComputeVARA = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.stdevVarA(args, false, true);
+    };
+    /**
+     * Calculates variance based on the entire population, including text and logicals.
+     *
+     * Excel: `VARPA(...)`.
+     *
+     * @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`.
+     */
+    StatisticalExtendedFormulas.prototype.ComputeVARPA = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.stdevVarA(args, true, true);
+    };
+    /**
+     * Returns the mean of the interior of a data set.
+     *
+     * Excel: `TRIMMEAN(...)`.
+     *
+     * @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`.
+     */
+    StatisticalExtendedFormulas.prototype.ComputeTRIMMEAN = 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 pct = this.resolveNumberArg(args[1]);
+        if (typeof pct === 'string') {
+            return pct;
+        }
+        if (pct < 0 || pct >= 1) {
+            return errCollection[CommonErrors.Num];
+        }
+        var nums = this.collectSample([args[0]], false);
+        if (typeof nums === 'string') {
+            return nums;
+        }
+        if (nums.length === 0) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        var sorted = nums.slice().sort(function (a, b) { return a - b; });
+        var trim = Math.floor(sorted.length * pct / 2);
+        var inner = sorted.slice(trim, sorted.length - trim);
+        if (inner.length === 0) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        return this.mean(inner).toString();
+    };
+    /**
+     * Returns the Fisher transformation.
+     *
+     * Excel: `FISHER(...)`.
+     *
+     * @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`.
+     */
+    StatisticalExtendedFormulas.prototype.ComputeFISHER = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var x = this.resolveNumberArg(args[0]);
+        if (typeof x === 'string') {
+            return x;
+        }
+        if (x <= -1 || x >= 1) {
+            return errCollection[CommonErrors.Num];
+        }
+        return (0.5 * Math.log((1 + x) / (1 - x))).toString();
+    };
+    /**
+     * Returns the inverse of the Fisher transformation.
+     *
+     * Excel: `FISHERINV(...)`.
+     *
+     * @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`.
+     */
+    StatisticalExtendedFormulas.prototype.ComputeFISHERINV = 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 y = this.resolveNumberArg(args[0]);
+        if (typeof y === 'string') {
+            return y;
+        }
+        var e2y = Math.exp(2 * y);
+        return ((e2y - 1) / (e2y + 1)).toString();
+    };
+    /**
+     * Returns the natural logarithm of the gamma function.
+     *
+     * Excel: `GAMMALN(...)`.
+     *
+     * @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`.
+     */
+    StatisticalExtendedFormulas.prototype.ComputeGAMMALN = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var x = this.resolveNumberArg(args[0]);
+        if (typeof x === 'string') {
+            return x;
+        }
+        if (x <= 0) {
+            return errCollection[CommonErrors.Num];
+        }
+        var result = logGamma(x);
+        if (!isFinite(result)) {
+            return errCollection[CommonErrors.Num];
+        }
+        return result.toString();
+    };
+    StatisticalExtendedFormulas.prototype.sumSquaresPair = function (args, mode) {
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length !== 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var pair = this.collectPair(args);
+        if (typeof pair === 'string') {
+            return pair;
+        }
+        var x = pair.x, y = pair.y;
+        if (x.length === 0) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        var sum = 0;
+        for (var i = 0; i < x.length; i++) {
+            if (mode === 'x2my2') {
+                sum += x[i] * x[i] - y[i] * y[i];
+            }
+            else if (mode === 'x2py2') {
+                sum += x[i] * x[i] + y[i] * y[i];
+            }
+            else {
+                var d = x[i] - y[i];
+                sum += d * d;
+            }
+        }
+        return sum.toString();
+    };
+    /**
+     * Returns the sum of the difference of squares of corresponding values in two arrays.
+     *
+     * Excel: `SUMX2MY2(...)`.
+     *
+     * @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`.
+     */
+    StatisticalExtendedFormulas.prototype.ComputeSUMX2MY2 = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.sumSquaresPair(args, 'x2my2');
+    };
+    /**
+     * Returns the sum of the sum of squares of corresponding values in two arrays.
+     *
+     * Excel: `SUMX2PY2(...)`.
+     *
+     * @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`.
+     */
+    StatisticalExtendedFormulas.prototype.ComputeSUMX2PY2 = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.sumSquaresPair(args, 'x2py2');
+    };
+    /**
+     * Returns the sum of squares of differences of corresponding values in two arrays.
+     *
+     * Excel: `SUMXMY2(...)`.
+     *
+     * @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`.
+     */
+    StatisticalExtendedFormulas.prototype.ComputeSUMXMY2 = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.sumSquaresPair(args, 'xmy2');
+    };
+    return StatisticalExtendedFormulas;
+}(StatisticalSampleBase));
+export { StatisticalExtendedFormulas };

package/src/formulas/statistical-ifs.d.ts

@@ -0,0 +1,46 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Conditional statistical aggregates (AVERAGEIFS, SUMIFS) over multi-criteria ranges.
+ *
+ * Registered functions: MAXIFS, MINIFS.
+ *
+ * @hidden
+ */
+export declare class StatisticalIfsFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns the maximum value among cells specified by criteria.
+     *
+     * Excel: `MAXIFS(...)`.
+     *
+     * @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('=MAXIFS(1)');
+     * ```
+     */
+    ComputeMAXIFS(...args: string[]): string | number;
+    /**
+     * Returns the minimum value among cells specified by criteria.
+     *
+     * Excel: `MINIFS(...)`.
+     *
+     * @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`.
+     */
+    ComputeMINIFS(...args: string[]): string | number;
+    private aggregateIfs;
+    private matchesCriteria;
+}

package/src/formulas/statistical-ifs.js

@@ -0,0 +1,180 @@
+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';
+/**
+ * Conditional statistical aggregates (AVERAGEIFS, SUMIFS) over multi-criteria ranges.
+ *
+ * Registered functions: MAXIFS, MINIFS.
+ *
+ * @hidden
+ */
+var StatisticalIfsFormulas = /** @class */ (function (_super) {
+    __extends(StatisticalIfsFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function StatisticalIfsFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'MAXIFS', category: 'Statistical', description: 'Returns the maximum value among cells specified by criteria.' },
+            { formulaName: 'MINIFS', category: 'Statistical', description: 'Returns the minimum value among cells specified by criteria.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns the maximum value among cells specified by criteria.
+     *
+     * Excel: `MAXIFS(...)`.
+     *
+     * @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('=MAXIFS(1)');
+     * ```
+     */
+    StatisticalIfsFormulas.prototype.ComputeMAXIFS = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.aggregateIfs(args, true);
+    };
+    /**
+     * Returns the minimum value among cells specified by criteria.
+     *
+     * Excel: `MINIFS(...)`.
+     *
+     * @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`.
+     */
+    StatisticalIfsFormulas.prototype.ComputeMINIFS = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.aggregateIfs(args, false);
+    };
+    StatisticalIfsFormulas.prototype.aggregateIfs = function (args, isMax) {
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length < 3 || args.length % 2 === 0) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var valueRange = args[0];
+        var valueCells = this.parent.getCellCollection(valueRange);
+        var values = Array.isArray(valueCells) ? valueCells : [valueCells];
+        var criteriaPairs = [];
+        for (var i = 1; i < args.length; i += 2) {
+            criteriaPairs.push([args[i], args[i + 1]]);
+        }
+        var criteriaCellsList = [];
+        for (var p = 0; p < criteriaPairs.length; p++) {
+            var cells = this.parent.getCellCollection(criteriaPairs[p][0]);
+            var list = Array.isArray(cells) ? cells : [cells];
+            if (list.length !== values.length) {
+                return errCollection[CommonErrors.Value];
+            }
+            criteriaCellsList.push(list);
+        }
+        var result = null;
+        var matched = false;
+        for (var i = 0; i < values.length; i++) {
+            var ok = true;
+            for (var p = 0; p < criteriaPairs.length; p++) {
+                var cellVal = this.parent.getValueFromArg(criteriaCellsList[p][i]);
+                if (!this.matchesCriteria(cellVal, criteriaPairs[p][1])) {
+                    ok = false;
+                    break;
+                }
+            }
+            if (!ok) {
+                continue;
+            }
+            var valStr = this.parent.getValueFromArg(values[i]);
+            if (errCollection.indexOf(valStr) > -1) {
+                return valStr;
+            }
+            if (valStr === '' || !this.parent.isNumber(valStr)) {
+                continue;
+            }
+            var num = this.parent.parseFloat(valStr);
+            matched = true;
+            if (result === null) {
+                result = num;
+            }
+            else if (isMax ? num > result : num < result) {
+                result = num;
+            }
+        }
+        if (!matched || result === null) {
+            return '0';
+        }
+        return result.toString();
+    };
+    StatisticalIfsFormulas.prototype.matchesCriteria = function (cellVal, criteriaArg) {
+        var criteria = criteriaArg.trim();
+        var isStringVal = criteria.startsWith(this.parent.tic) && criteria.endsWith(this.parent.tic);
+        if (isStringVal) {
+            criteria = this.parent.removeTics(criteria);
+        }
+        else if (this.parent.isCellReference(criteria)) {
+            criteria = this.parent.getValueFromArg(criteria);
+        }
+        else {
+            criteria = this.parent.getValueFromArg(criteria);
+            if (!this.parent.isCellReference(criteriaArg)) {
+                criteria = this.parent.removeTics(criteria);
+            }
+        }
+        var op = 'equal';
+        if (criteria.startsWith('<=')) {
+            op = 'lessEq';
+            criteria = criteria.substring(2);
+        }
+        else if (criteria.startsWith('>=')) {
+            op = 'greaterEq';
+            criteria = criteria.substring(2);
+        }
+        else if (criteria.startsWith('<>')) {
+            op = 'notEq';
+            criteria = criteria.substring(2);
+        }
+        else if (criteria.startsWith('<')) {
+            op = 'less';
+            criteria = criteria.substring(1);
+        }
+        else if (criteria.startsWith('>')) {
+            op = 'greater';
+            criteria = criteria.substring(1);
+        }
+        else if (criteria.startsWith('=')) {
+            op = 'equal';
+            criteria = criteria.substring(1);
+        }
+        criteria = criteria.trim();
+        if (criteria.startsWith(this.parent.tic)) {
+            criteria = this.parent.removeTics(criteria);
+        }
+        return this.parent.processLogical([cellVal.toLowerCase(), criteria.toLowerCase()], op) === this.parent.trueValue;
+    };
+    return StatisticalIfsFormulas;
+}(FormulaModuleBase));
+export { StatisticalIfsFormulas };

package/src/formulas/statistical-moments.d.ts

@@ -0,0 +1,84 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { StatisticalSampleBase } from './statistical-sample-base';
+/**
+ * Distribution shape metrics: skewness, kurtosis, and moment-based descriptive statistics.
+ *
+ * Registered functions: AVEDEV, DEVSQ, HARMEAN, SKEW, KURT, STANDARDIZE.
+ *
+ * @hidden
+ */
+export declare class StatisticalMomentsFormulas extends StatisticalSampleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns the average of the absolute deviations of data points from their mean.
+     *
+     * Excel: `AVEDEV(...)`.
+     *
+     * @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('=AVEDEV(1)');
+     * ```
+     */
+    ComputeAVEDEV(...args: string[]): string | number;
+    /**
+     * Returns the sum of squares of deviations.
+     *
+     * Excel: `DEVSQ(...)`.
+     *
+     * @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`.
+     */
+    ComputeDEVSQ(...args: string[]): string | number;
+    /**
+     * Returns the harmonic mean.
+     *
+     * Excel: `HARMEAN(...)`.
+     *
+     * @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`.
+     */
+    ComputeHARMEAN(...args: string[]): string | number;
+    /**
+     * Returns the skewness of a distribution.
+     *
+     * Excel: `SKEW(...)`.
+     *
+     * @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`.
+     */
+    ComputeSKEW(...args: string[]): string | number;
+    /**
+     * Returns the kurtosis of a data set.
+     *
+     * Excel: `KURT(...)`.
+     *
+     * @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`.
+     */
+    ComputeKURT(...args: string[]): string | number;
+    /**
+     * Returns a normalized value from a distribution.
+     *
+     * Excel: `STANDARDIZE(...)`.
+     *
+     * @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`.
+     */
+    ComputeSTANDARDIZE(...args: string[]): string | number;
+}