@syncfusion/ej2-calculate 35.1.37

package/src/formulas/basic.d.ts

@@ -0,0 +1,47 @@
+import { Calculate } from '../base/index';
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+/**
+ * Central registry that composes all built-in formula category modules and binds them to the Calculate engine.
+ *
+ * Instantiated by the {@link Calculate} constructor. Each category module contributes
+ * `formulas` metadata and `Compute*` handlers that are registered into
+ * {@link Calculate.getLibraryFormulas}.
+ *
+ * @example
+ * ```ts
+ * // Constructed automatically:
+ * const engine = new Calculate();
+ * engine.getFunction('SUM'); // bound ComputeSUM handler
+ * ```
+ * @hidden
+ */
+export declare class BasicFormulas implements FormulaOwner {
+    parent: Calculate;
+    /** Catalog of built-in formula metadata and bound Compute handlers. */
+    formulas: IBasicFormula[];
+    /** @hidden */
+    isConcat: boolean;
+    [key: string]: any;
+    /**
+     * @param {Object} parent - Calculate engine instance that owns formula registration.
+     */
+    constructor(parent?: Calculate);
+    /**
+     * init helper.
+     *
+     * @returns {void} - init result.
+     */
+    private init;
+    /**
+     * Registers one formula handler on the parent Calculate engine.
+     *
+     * @param {string} formulaName - Uppercase formula name key.
+     * @param {Function} functionName - Bound Compute handler.
+     * @param {string} formulaCategory - Formula category label.
+     * @param {string} description - Human-readable formula description.
+     * @returns {void}
+     * @internal
+     */
+    private addFormulaCollection;
+}

package/src/formulas/basic.js

@@ -0,0 +1,181 @@
+import { getValue } from '@syncfusion/ej2-base';
+import { MathAggregateFormulas } from './math-aggregate';
+import { MathRoundingFormulas } from './math-rounding';
+import { MathMiscFormulas } from './math-misc';
+import { MathTrigFormulas } from './math-trig';
+import { MathTrigHyperbolicFormulas } from './math-trig-hyperbolic';
+import { MathCombinatoricsFormulas } from './math-combinatorics';
+import { MathNumberFormulas } from './math-number';
+import { MatrixFormulas } from './matrix';
+import { EngineeringBaseFormulas } from './engineering-base';
+import { EngineeringMiscFormulas } from './engineering-misc';
+import { EngineeringConvertFormulas } from './engineering-convert';
+import { EngineeringBesselFormulas } from './engineering-bessel';
+import { FinancialAnnuityFormulas } from './financial-annuity';
+import { FinancialDepreciationFormulas } from './financial-depreciation';
+import { FinancialRatesFormulas } from './financial-rates';
+import { FinancialCashflowFormulas } from './financial-cashflow';
+import { FinancialSecuritiesFormulas } from './financial-securities';
+import { StatisticalFormulas } from './statistical';
+import { StatisticalAdvancedFormulas } from './statistical-advanced';
+import { StatisticalDispersionFormulas } from './statistical-dispersion';
+import { StatisticalMomentsFormulas } from './statistical-moments';
+import { StatisticalCorrelationFormulas } from './statistical-correlation';
+import { StatisticalPercentileFormulas } from './statistical-percentile';
+import { StatisticalDistributionFormulas } from './statistical-distribution';
+import { StatisticalIfsFormulas } from './statistical-ifs';
+import { StatisticalExtendedFormulas } from './statistical-extended';
+import { StatisticalDistributionExtendedFormulas } from './statistical-distribution-extended';
+import { ComplexNumbersFormulas } from './complex-numbers';
+import { DateTimeFormulas } from './date-time';
+import { DateTimeExtraFormulas } from './date-time-extra';
+import { LogicalFormulas } from './logical';
+import { LogicalExtraFormulas } from './logical-extra';
+import { LookupFormulas } from './lookup';
+import { LookupRefFormulas } from './lookup-ref';
+import { LookupRefExtraFormulas } from './lookup-ref-extra';
+import { LookupArrayFormulas } from './lookup-array';
+import { ArrayFormulas } from './array';
+import { TextFormulas } from './text';
+import { TextExtraFormulas } from './text-extra';
+import { TextAdvancedFormulas } from './text-advanced';
+import { InformationFormulas } from './information';
+import { InformationExtraFormulas } from './information-extra';
+import { InformationAdvancedFormulas } from './information-advanced';
+import { DateTimeIntlFormulas } from './date-time-intl';
+import { MathCeilingEcmaFormulas } from './math-ceiling-ecma';
+import { InformationEcmaFormulas } from './information-ecma';
+import { TextEcmaFormulas } from './text-ecma';
+import { FinancialCouponsFormulas } from './financial-coupons';
+import { FinancialAmortizationEcmaFormulas } from './financial-amortization-ecma';
+import { StatisticalEcmaFormulas } from './statistical-ecma';
+import { DatabaseFormulas } from './database';
+import { RegressionEcmaFormulas } from './regression-ecma';
+/**
+ * Central registry that composes all built-in formula category modules and binds them to the Calculate engine.
+ *
+ * Instantiated by the {@link Calculate} constructor. Each category module contributes
+ * `formulas` metadata and `Compute*` handlers that are registered into
+ * {@link Calculate.getLibraryFormulas}.
+ *
+ * @example
+ * ```ts
+ * // Constructed automatically:
+ * const engine = new Calculate();
+ * engine.getFunction('SUM'); // bound ComputeSUM handler
+ * ```
+ * @hidden
+ */
+var BasicFormulas = /** @class */ (function () {
+    /**
+     * @param {Object} parent - Calculate engine instance that owns formula registration.
+     */
+    function BasicFormulas(parent) {
+        /** Catalog of built-in formula metadata and bound Compute handlers. */
+        this.formulas = [];
+        /** @hidden */
+        this.isConcat = false;
+        this.parent = parent;
+        var modules = [
+            new MathAggregateFormulas(this),
+            new MathRoundingFormulas(this),
+            new MathMiscFormulas(this),
+            new MathTrigFormulas(this),
+            new MathTrigHyperbolicFormulas(this),
+            new MathCombinatoricsFormulas(this),
+            new MathNumberFormulas(this),
+            new MatrixFormulas(this),
+            new EngineeringBaseFormulas(this),
+            new EngineeringMiscFormulas(this),
+            new EngineeringConvertFormulas(this),
+            new EngineeringBesselFormulas(this),
+            new FinancialAnnuityFormulas(this),
+            new FinancialDepreciationFormulas(this),
+            new FinancialRatesFormulas(this),
+            new FinancialCashflowFormulas(this),
+            new FinancialSecuritiesFormulas(this),
+            new StatisticalFormulas(this),
+            new StatisticalAdvancedFormulas(this),
+            new StatisticalDispersionFormulas(this),
+            new StatisticalMomentsFormulas(this),
+            new StatisticalCorrelationFormulas(this),
+            new StatisticalPercentileFormulas(this),
+            new StatisticalDistributionFormulas(this),
+            new StatisticalIfsFormulas(this),
+            new StatisticalExtendedFormulas(this),
+            new StatisticalDistributionExtendedFormulas(this),
+            new ComplexNumbersFormulas(this),
+            new DateTimeFormulas(this),
+            new DateTimeExtraFormulas(this),
+            new LogicalFormulas(this),
+            new LogicalExtraFormulas(this),
+            new LookupFormulas(this),
+            new LookupRefFormulas(this),
+            new LookupRefExtraFormulas(this),
+            new LookupArrayFormulas(this),
+            new ArrayFormulas(this),
+            new TextFormulas(this),
+            new TextExtraFormulas(this),
+            new TextAdvancedFormulas(this),
+            new InformationFormulas(this),
+            new InformationExtraFormulas(this),
+            new InformationAdvancedFormulas(this),
+            new DateTimeIntlFormulas(this),
+            new MathCeilingEcmaFormulas(this),
+            new InformationEcmaFormulas(this),
+            new TextEcmaFormulas(this),
+            new FinancialCouponsFormulas(this),
+            new FinancialAmortizationEcmaFormulas(this),
+            new StatisticalEcmaFormulas(this),
+            new DatabaseFormulas(this),
+            new RegressionEcmaFormulas(this)
+        ];
+        for (var m = 0; m < modules.length; m++) {
+            var mod = modules[m];
+            for (var i = 0; i < mod.formulas.length; i++) {
+                var formula = mod.formulas[i];
+                this.formulas.push(formula);
+                var methodName = 'Compute' + formula.formulaName;
+                var handler = formula.formulaName.indexOf('.') > -1
+                    // eslint-disable-next-line security/detect-object-injection
+                    ? mod[methodName]
+                    : getValue(methodName, mod);
+                if (handler) {
+                    // eslint-disable-next-line security/detect-object-injection
+                    this[methodName] = handler.bind(mod);
+                }
+            }
+        }
+        this.init();
+    }
+    /**
+     * init helper.
+     *
+     * @returns {void} - init result.
+     */
+    BasicFormulas.prototype.init = function () {
+        for (var i = 0; i < this.formulas.length; i++) {
+            var formula = this.formulas[i];
+            var fn = this['Compute' + formula.formulaName];
+            this.addFormulaCollection(formula.formulaName.toUpperCase(), fn, formula.category, formula.description);
+        }
+    };
+    /**
+     * Registers one formula handler on the parent Calculate engine.
+     *
+     * @param {string} formulaName - Uppercase formula name key.
+     * @param {Function} functionName - Bound Compute handler.
+     * @param {string} formulaCategory - Formula category label.
+     * @param {string} description - Human-readable formula description.
+     * @returns {void}
+     * @internal
+     */
+    BasicFormulas.prototype.addFormulaCollection = function (formulaName, functionName, formulaCategory, description) {
+        this.parent.libraryFormulas = {
+            fName: formulaName, handler: functionName, category: formulaCategory,
+            description: description
+        };
+    };
+    return BasicFormulas;
+}());
+export { BasicFormulas };

package/src/formulas/complex-numbers.d.ts

@@ -0,0 +1,207 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Complex-number arithmetic, polar/rectangular conversion, and complex transcendental functions.
+ *
+ * Registers 18 functions including COMPLEX, IMABS, IMAGINARY, IMREAL, IMCONJUGATE, and others.
+ *
+ * @hidden
+ */
+export declare class ComplexNumbersFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    private resolveComplex;
+    /**
+     * 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)');
+     * ```
+     */
+    ComputeCOMPLEX(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeIMABS(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeIMAGINARY(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeIMREAL(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeIMCONJUGATE(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeIMSUM(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeIMSUB(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeIMPRODUCT(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeIMDIV(...args: string[]): string | number;
+    private complexReduce;
+    /**
+     * 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`.
+     */
+    ComputeIMEXP(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeIMLN(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeIMLOG10(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeIMLOG2(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeIMSQRT(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeIMPOWER(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeIMARGUMENT(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeIMSIN(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeIMCOS(...args: string[]): string | number;
+}