@syncfusion/ej2-calculate 35.1.37

package/src/formulas/matrix-base.js

@@ -0,0 +1,169 @@
+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 { CommonErrors } from '../common/index';
+import { getRangeIndexes } from '../common/address';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Shared matrix helpers for MDETERM / MINVERSE / MMULT / TRANSPOSE.
+ *
+ * @hidden
+ */
+var MatrixFormulaBase = /** @class */ (function (_super) {
+    __extends(MatrixFormulaBase, _super);
+    function MatrixFormulaBase() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MatrixFormulaBase.prototype.readMatrix = function (ref) {
+        var errCollection = this.parent.getErrorStrings();
+        var stripped = ref.split('$').join('');
+        if (!this.parent.isCellReference(stripped.split(':')[0])) {
+            return errCollection[CommonErrors.Value];
+        }
+        var indexes = getRangeIndexes(stripped);
+        var rows = indexes[2] - indexes[0] + 1;
+        var cols = indexes[3] - indexes[1] + 1;
+        var cells = this.parent.getCellCollection(stripped);
+        var list = Array.isArray(cells) ? cells : [cells];
+        if (list.length !== rows * cols) {
+            return errCollection[CommonErrors.Value];
+        }
+        var matrix = [];
+        for (var r = 0; r < rows; r++) {
+            var row = [];
+            for (var c = 0; c < cols; c++) {
+                var val = this.parent.getValueFromArg(list[r * cols + c]);
+                if (errCollection.indexOf(val) > -1) {
+                    return val;
+                }
+                if (val === '' || !this.parent.isNumber(val)) {
+                    return errCollection[CommonErrors.Value];
+                }
+                row.push(this.parent.parseFloat(val));
+            }
+            matrix.push(row);
+        }
+        return matrix;
+    };
+    MatrixFormulaBase.prototype.flattenMatrix = function (matrix, transpose) {
+        if (transpose === void 0) { transpose = false; }
+        var sep = this.parent.getParseArgumentSeparator();
+        var rows = matrix.length;
+        var cols = matrix[0].length;
+        var parts = [];
+        if (transpose) {
+            for (var c = 0; c < cols; c++) {
+                for (var r = 0; r < rows; r++) {
+                    parts.push(matrix[r][c].toString());
+                }
+            }
+        }
+        else {
+            for (var r = 0; r < rows; r++) {
+                for (var c = 0; c < cols; c++) {
+                    parts.push(matrix[r][c].toString());
+                }
+            }
+        }
+        return parts.join(sep);
+    };
+    MatrixFormulaBase.prototype.determinant = function (m) {
+        var n = m.length;
+        if (n === 1) {
+            return m[0][0];
+        }
+        if (n === 2) {
+            return m[0][0] * m[1][1] - m[0][1] * m[1][0];
+        }
+        var det = 0;
+        for (var c = 0; c < n; c++) {
+            var minor = [];
+            for (var r = 1; r < n; r++) {
+                var row = [];
+                for (var k = 0; k < n; k++) {
+                    if (k !== c) {
+                        row.push(m[r][k]);
+                    }
+                }
+                minor.push(row);
+            }
+            det += (c % 2 === 0 ? 1 : -1) * m[0][c] * this.determinant(minor);
+        }
+        return det;
+    };
+    MatrixFormulaBase.prototype.inverse = function (m) {
+        var n = m.length;
+        var aug = [];
+        for (var i = 0; i < n; i++) {
+            aug.push(m[i].slice());
+            for (var j = 0; j < n; j++) {
+                aug[i].push(i === j ? 1 : 0);
+            }
+        }
+        for (var i = 0; i < n; i++) {
+            var maxRow = i;
+            for (var k = i + 1; k < n; k++) {
+                if (Math.abs(aug[k][i]) > Math.abs(aug[maxRow][i])) {
+                    maxRow = k;
+                }
+            }
+            var tmp = aug[i];
+            aug[i] = aug[maxRow];
+            aug[maxRow] = tmp;
+            var pivot = aug[i][i];
+            if (Math.abs(pivot) < 1e-12) {
+                return null;
+            }
+            for (var j = 0; j < 2 * n; j++) {
+                aug[i][j] /= pivot;
+            }
+            for (var k = 0; k < n; k++) {
+                if (k === i) {
+                    continue;
+                }
+                var factor = aug[k][i];
+                for (var j = 0; j < 2 * n; j++) {
+                    aug[k][j] -= factor * aug[i][j];
+                }
+            }
+        }
+        var inv = [];
+        for (var i = 0; i < n; i++) {
+            inv.push(aug[i].slice(n));
+        }
+        return inv;
+    };
+    MatrixFormulaBase.prototype.multiply = function (a, b) {
+        if (a[0].length !== b.length) {
+            return null;
+        }
+        var rows = a.length;
+        var cols = b[0].length;
+        var inner = b.length;
+        var result = [];
+        for (var i = 0; i < rows; i++) {
+            var row = [];
+            for (var j = 0; j < cols; j++) {
+                var sum = 0;
+                for (var k = 0; k < inner; k++) {
+                    sum += a[i][k] * b[k][j];
+                }
+                row.push(sum);
+            }
+            result.push(row);
+        }
+        return result;
+    };
+    return MatrixFormulaBase;
+}(FormulaModuleBase));
+export { MatrixFormulaBase };

package/src/formulas/matrix.d.ts

@@ -0,0 +1,64 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { MatrixFormulaBase } from './matrix-base';
+/**
+ * Matrix and linear-algebra helpers for array-oriented spreadsheet calculations.
+ *
+ * Registered functions: MDETERM, MINVERSE, MMULT, TRANSPOSE.
+ *
+ * @hidden
+ */
+export declare class MatrixFormulas extends MatrixFormulaBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns the matrix determinant of an array.
+     *
+     * Excel: `MDETERM(...)`.
+     *
+     * @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('=MDETERM(1)');
+     * ```
+     */
+    ComputeMDETERM(...args: string[]): string | number;
+    /**
+     * Returns the matrix inverse of an array.
+     *
+     * Excel: `MINVERSE(...)`.
+     *
+     * @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`.
+     */
+    ComputeMINVERSE(...args: string[]): string | number;
+    /**
+     * Returns the matrix product of two arrays.
+     *
+     * Excel: `MMULT(...)`.
+     *
+     * @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`.
+     */
+    ComputeMMULT(...args: string[]): string | number;
+    /**
+     * Returns the transpose of an array.
+     *
+     * Excel: `TRANSPOSE(...)`.
+     *
+     * @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`.
+     */
+    ComputeTRANSPOSE(...args: string[]): string | number;
+}

package/src/formulas/matrix.js

@@ -0,0 +1,161 @@
+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 { MatrixFormulaBase } from './matrix-base';
+/**
+ * Matrix and linear-algebra helpers for array-oriented spreadsheet calculations.
+ *
+ * Registered functions: MDETERM, MINVERSE, MMULT, TRANSPOSE.
+ *
+ * @hidden
+ */
+var MatrixFormulas = /** @class */ (function (_super) {
+    __extends(MatrixFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function MatrixFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'MDETERM', category: 'Math & Trig', description: 'Returns the matrix determinant of an array.' },
+            { formulaName: 'MINVERSE', category: 'Math & Trig', description: 'Returns the matrix inverse of an array.' },
+            { formulaName: 'MMULT', category: 'Math & Trig', description: 'Returns the matrix product of two arrays.' },
+            { formulaName: 'TRANSPOSE', category: 'Math & Trig', description: 'Returns the transpose of an array.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns the matrix determinant of an array.
+     *
+     * Excel: `MDETERM(...)`.
+     *
+     * @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('=MDETERM(1)');
+     * ```
+     */
+    MatrixFormulas.prototype.ComputeMDETERM = 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 matrix = this.readMatrix(args[0]);
+        if (typeof matrix === 'string') {
+            return matrix;
+        }
+        if (matrix.length !== matrix[0].length) {
+            return errCollection[CommonErrors.Value];
+        }
+        return this.determinant(matrix).toString();
+    };
+    /**
+     * Returns the matrix inverse of an array.
+     *
+     * Excel: `MINVERSE(...)`.
+     *
+     * @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`.
+     */
+    MatrixFormulas.prototype.ComputeMINVERSE = 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 matrix = this.readMatrix(args[0]);
+        if (typeof matrix === 'string') {
+            return matrix;
+        }
+        if (matrix.length !== matrix[0].length) {
+            return errCollection[CommonErrors.Value];
+        }
+        var inv = this.inverse(matrix);
+        if (!inv) {
+            return errCollection[CommonErrors.Num];
+        }
+        return this.flattenMatrix(inv);
+    };
+    /**
+     * Returns the matrix product of two arrays.
+     *
+     * Excel: `MMULT(...)`.
+     *
+     * @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`.
+     */
+    MatrixFormulas.prototype.ComputeMMULT = 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.readMatrix(args[0]);
+        var b = this.readMatrix(args[1]);
+        if (typeof a === 'string') {
+            return a;
+        }
+        if (typeof b === 'string') {
+            return b;
+        }
+        var product = this.multiply(a, b);
+        if (!product) {
+            return errCollection[CommonErrors.Value];
+        }
+        return this.flattenMatrix(product);
+    };
+    /**
+     * Returns the transpose of an array.
+     *
+     * Excel: `TRANSPOSE(...)`.
+     *
+     * @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`.
+     */
+    MatrixFormulas.prototype.ComputeTRANSPOSE = 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 matrix = this.readMatrix(args[0]);
+        if (typeof matrix === 'string') {
+            return matrix;
+        }
+        return this.flattenMatrix(matrix, true);
+    };
+    return MatrixFormulas;
+}(MatrixFormulaBase));
+export { MatrixFormulas };

package/src/formulas/regression-ecma.d.ts

@@ -0,0 +1,66 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { StatisticalSampleBase } from './statistical-sample-base';
+/**
+ * ECMA-376 linear and exponential regression/trend functions (LINEST, LOGEST, TREND, GROWTH).
+ *
+ * Registered functions: LINEST, LOGEST, GROWTH, TREND.
+ *
+ * @hidden
+ */
+export declare class RegressionEcmaFormulas extends StatisticalSampleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    private linearRegression;
+    private expRegression;
+    /**
+     * Returns statistics that describe a linear trend (slope when spill unavailable).
+     *
+     * Excel: `LINEST(...)`.
+     *
+     * @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('=LINEST(1)');
+     * ```
+     */
+    ComputeLINEST(...args: string[]): string | number;
+    /**
+     * Returns statistics that describe an exponential curve (first coefficient when spill unavailable).
+     *
+     * Excel: `LOGEST(...)`.
+     *
+     * @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`.
+     */
+    ComputeLOGEST(...args: string[]): string | number;
+    /**
+     * Returns y values along a linear trend (first predicted value when spill unavailable).
+     *
+     * Excel: `TREND(...)`.
+     *
+     * @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`.
+     */
+    ComputeTREND(...args: string[]): string | number;
+    /**
+     * Returns y values along an exponential growth trend (first predicted value when spill unavailable).
+     *
+     * Excel: `GROWTH(...)`.
+     *
+     * @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`.
+     */
+    ComputeGROWTH(...args: string[]): string | number;
+}

package/src/formulas/regression-ecma.js

@@ -0,0 +1,234 @@
+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';
+/**
+ * ECMA-376 linear and exponential regression/trend functions (LINEST, LOGEST, TREND, GROWTH).
+ *
+ * Registered functions: LINEST, LOGEST, GROWTH, TREND.
+ *
+ * @hidden
+ */
+var RegressionEcmaFormulas = /** @class */ (function (_super) {
+    __extends(RegressionEcmaFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function RegressionEcmaFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'LINEST', category: 'Statistical', description: 'Returns statistics that describe a linear trend.' },
+            { formulaName: 'LOGEST', category: 'Statistical', description: 'Returns statistics that describe an exponential curve.' },
+            { formulaName: 'GROWTH', category: 'Statistical', description: 'Returns numbers in an exponential growth trend.' },
+            { formulaName: 'TREND', category: 'Statistical', description: 'Returns numbers in a linear trend.' }
+        ];
+        return _this;
+    }
+    RegressionEcmaFormulas.prototype.linearRegression = function (yArg, xArg) {
+        var pair = this.collectPair([xArg, yArg]);
+        if (typeof pair === 'string') {
+            return pair;
+        }
+        var x = pair.x, y = pair.y;
+        if (x.length < 2) {
+            return this.parent.getErrorStrings()[CommonErrors.NA];
+        }
+        var meanX = this.mean(x);
+        var meanY = this.mean(y);
+        var sxx = 0;
+        var sxy = 0;
+        for (var i = 0; i < x.length; i++) {
+            var dx = x[i] - meanX;
+            sxx += dx * dx;
+            sxy += dx * (y[i] - meanY);
+        }
+        if (sxx === 0) {
+            return this.parent.getErrorStrings()[CommonErrors.DivZero];
+        }
+        var slope = sxy / sxx;
+        var intercept = meanY - slope * meanX;
+        return { slope: slope, intercept: intercept };
+    };
+    RegressionEcmaFormulas.prototype.expRegression = function (yArg, xArg) {
+        var pair = this.collectPair([xArg, yArg]);
+        if (typeof pair === 'string') {
+            return pair;
+        }
+        var x = pair.x, y = pair.y;
+        var errCollection = this.parent.getErrorStrings();
+        if (x.length < 2) {
+            return errCollection[CommonErrors.NA];
+        }
+        var lnY = [];
+        for (var i = 0; i < y.length; i++) {
+            if (y[i] <= 0) {
+                return errCollection[CommonErrors.Num];
+            }
+            lnY.push(Math.log(y[i]));
+        }
+        var meanX = this.mean(x);
+        var meanLnY = this.mean(lnY);
+        var sxx = 0;
+        var sxy = 0;
+        for (var i = 0; i < x.length; i++) {
+            var dx = x[i] - meanX;
+            sxx += dx * dx;
+            sxy += dx * (lnY[i] - meanLnY);
+        }
+        if (sxx === 0) {
+            return errCollection[CommonErrors.DivZero];
+        }
+        var m = sxy / sxx;
+        var b = Math.exp(meanLnY - m * meanX);
+        return { b: b, m: m };
+    };
+    /**
+     * Returns statistics that describe a linear trend (slope when spill unavailable).
+     *
+     * Excel: `LINEST(...)`.
+     *
+     * @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('=LINEST(1)');
+     * ```
+     */
+    RegressionEcmaFormulas.prototype.ComputeLINEST = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length < 2 || args.length > 4) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var reg = this.linearRegression(args[0], args[1]);
+        if (typeof reg === 'string') {
+            return reg;
+        }
+        return reg.slope.toString();
+    };
+    /**
+     * Returns statistics that describe an exponential curve (first coefficient when spill unavailable).
+     *
+     * Excel: `LOGEST(...)`.
+     *
+     * @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`.
+     */
+    RegressionEcmaFormulas.prototype.ComputeLOGEST = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length < 2 || args.length > 4) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var reg = this.expRegression(args[0], args[1]);
+        if (typeof reg === 'string') {
+            return reg;
+        }
+        return reg.b.toString();
+    };
+    /**
+     * Returns y values along a linear trend (first predicted value when spill unavailable).
+     *
+     * Excel: `TREND(...)`.
+     *
+     * @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`.
+     */
+    RegressionEcmaFormulas.prototype.ComputeTREND = 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 reg = this.linearRegression(args[0], args[1]);
+        if (typeof reg === 'string') {
+            return reg;
+        }
+        var xVal;
+        if (args.length === 3 && args[2] !== '') {
+            var xNew = this.collectSample([args[2]], false);
+            if (typeof xNew === 'string') {
+                return xNew;
+            }
+            if (xNew.length === 0) {
+                return this.parent.getErrorStrings()[CommonErrors.NA];
+            }
+            xVal = xNew[0];
+        }
+        else {
+            var xData = this.collectSample([args[1]], false);
+            if (typeof xData === 'string') {
+                return xData;
+            }
+            xVal = xData[xData.length - 1] + 1;
+        }
+        return (reg.intercept + reg.slope * xVal).toString();
+    };
+    /**
+     * Returns y values along an exponential growth trend (first predicted value when spill unavailable).
+     *
+     * Excel: `GROWTH(...)`.
+     *
+     * @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`.
+     */
+    RegressionEcmaFormulas.prototype.ComputeGROWTH = 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 reg = this.expRegression(args[0], args[1]);
+        if (typeof reg === 'string') {
+            return reg;
+        }
+        var xVal;
+        if (args.length === 3 && args[2] !== '') {
+            var xNew = this.collectSample([args[2]], false);
+            if (typeof xNew === 'string') {
+                return xNew;
+            }
+            if (xNew.length === 0) {
+                return this.parent.getErrorStrings()[CommonErrors.NA];
+            }
+            xVal = xNew[0];
+        }
+        else {
+            var xData = this.collectSample([args[1]], false);
+            if (typeof xData === 'string') {
+                return xData;
+            }
+            xVal = xData[xData.length - 1] + 1;
+        }
+        return (reg.b * Math.pow(Math.E, reg.m * xVal)).toString();
+    };
+    return RegressionEcmaFormulas;
+}(StatisticalSampleBase));
+export { RegressionEcmaFormulas };