@cortex-js/compute-engine 0.32.1 → 0.33.0

package/dist/types/compute-engine/numerics/numeric-bignum.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare function gcd(a: BigNum, b: BigNum): BigNum;
 export declare function lcm(a: BigNum, b: BigNum): BigNum;
 export declare function factorial2(ce: IBigNum, n: BigNum): BigNum;

package/dist/types/compute-engine/numerics/numeric-complex.d.ts

@@ -1,3 +1,3 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare function gamma(c: Complex): Complex;
 export declare function gammaln(c: Complex): Complex;

package/dist/types/compute-engine/numerics/numeric.d.ts

@@ -1,11 +1,11 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const MACHINE_PRECISION_BITS = 53;
 export declare const MACHINE_PRECISION: number;
 export declare const DEFAULT_TOLERANCE = 1e-10;
 export declare const SMALL_INTEGER = 1000000;
 /** The largest number of digits of a bigint */
 export declare const MAX_BIGINT_DIGITS = 1024;
-export declare const MAX_ITERATION = 1000000;
+export declare const MAX_ITERATION = 10000;
 export declare const MAX_SYMBOLIC_TERMS = 200;
 /**
  * Returns the smallest floating-point number greater than x.

package/dist/types/compute-engine/numerics/primes.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare function primeFactors(n: number): {
     [factor: number]: number;
 };

package/dist/types/compute-engine/numerics/rationals.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare function isRational(x: any | null): x is Rational;
 export declare function isMachineRational(x: any | null): x is [SmallInteger, SmallInteger];
 export declare function isBigRational(x: any | null): x is [bigint, bigint];

package/dist/types/compute-engine/numerics/richardson.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 
     Translated from https://github.com/JuliaMath/Richardson.jl/blob/master/src/Richardson.jl
 

package/dist/types/compute-engine/numerics/special-functions.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 import type { BigNum } from './types';
 export declare function gammaln(z: number): number;
 export declare function gamma(z: number): number;

package/dist/types/compute-engine/numerics/statistics.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 import type { BigNum } from './types';
 export declare function mean(values: Iterable<number>): number;
 export declare function bigMean(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;

package/dist/types/compute-engine/numerics/strings.d.ts

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare function numberToString(num: number | bigint, fractionalDigits?: number | string): string;

package/dist/types/compute-engine/numerics/types.d.ts

@@ -1,4 +1,5 @@
-/* 0.32.1 */
+/* 0.33.0 */
+/** @internal */
 type IsInteger<N extends number> = `${N}` extends `${string}.${string}` ? never : `${N}` extends `-${string}.${string}` ? never : number;
 /** A `SmallInteger` is an integer < 1e6
  * @category Numerics

package/dist/types/compute-engine/symbolic/antiderivative.d.ts

@@ -1,3 +1,3 @@
-/* 0.32.1 */
+/* 0.33.0 */
 /** Calculate the antiderivative of fn, as an expression (not a function) */
 export declare function antiderivative(fn: BoxedExpression, index: string): BoxedExpression;

package/dist/types/compute-engine/symbolic/derivative.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 /**
  *
  * @param fn The function to differentiate, a function literal.

package/dist/types/compute-engine/symbolic/distribute.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 /**
  *
  */

package/dist/types/compute-engine/symbolic/fu-cost.d.ts

@@ -0,0 +1,33 @@
+/* 0.33.0 */
+ * Cost functions for the Fu trigonometric simplification algorithm.
+ *
+ * The primary objective is to minimize the number of trigonometric functions,
+ * with secondary consideration for overall expression complexity.
+ */
+import type { BoxedExpression } from '../global-types';
+/**
+ * Count the number of trigonometric function occurrences in an expression.
+ * This is the primary metric for the Fu algorithm.
+ */
+export declare function countTrigFunctions(expr: BoxedExpression): number;
+/**
+ * Count the number of leaves (atoms) in an expression.
+ * Includes symbols, numbers, and function names.
+ */
+export declare function countLeaves(expr: BoxedExpression): number;
+/**
+ * The default trig cost function for the Fu algorithm.
+ *
+ * Priority:
+ * 1. Minimize number of trig functions (weighted heavily)
+ * 2. Minimize leaf count (secondary)
+ *
+ * This ensures that expressions with fewer trig functions are always
+ * preferred, even if they have slightly more total operations.
+ */
+export declare function trigCost(expr: BoxedExpression): number;
+export type TrigCostFunction = (expr: BoxedExpression) => number;
+/**
+ * Default cost function for the Fu algorithm
+ */
+export declare const DEFAULT_TRIG_COST: TrigCostFunction;

package/dist/types/compute-engine/symbolic/fu-transforms.d.ts

@@ -0,0 +1,130 @@
+/* 0.33.0 */
+ * Fu Algorithm Transformation Rules
+ *
+ * Programmatic implementations of TR1-TR22 from the Fu trigonometric
+ * simplification algorithm.
+ *
+ * Reference: Fu, Hongguang, Xiuqin Zhong, and Zhenbing Zeng.
+ * "Automated and readable simplification of trigonometric expressions."
+ * Mathematical and Computer Modelling 44.11 (2006): 1169-1177.
+ *
+ * Each TR function applies a specific transformation to an expression.
+ * Returns the transformed expression, or undefined if the rule doesn't apply.
+ *
+ * IMPORTANT: These functions should NOT call .simplify() on their results
+ * to avoid infinite recursion when called from the simplification pipeline.
+ */
+import type { BoxedExpression } from '../global-types';
+/**
+ * Check if an expression contains any trigonometric functions
+ */
+export declare function hasTrigFunction(expr: BoxedExpression): boolean;
+/**
+ * Check if expression contains specific operators anywhere in the tree
+ */
+export declare function hasOperator(expr: BoxedExpression, ...ops: string[]): boolean;
+export declare function TR1(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR1 to all subexpressions
+ */
+export declare function applyTR1(expr: BoxedExpression): BoxedExpression;
+export declare function TR2(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR2 to all subexpressions
+ */
+export declare function applyTR2(expr: BoxedExpression): BoxedExpression;
+export declare function TR2i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR2i to all subexpressions
+ */
+export declare function applyTR2i(expr: BoxedExpression): BoxedExpression;
+export declare function TR3(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR3 to all subexpressions
+ */
+export declare function applyTR3(expr: BoxedExpression): BoxedExpression;
+export declare function TR5(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR5 to all subexpressions
+ */
+export declare function applyTR5(expr: BoxedExpression): BoxedExpression;
+export declare function TR6(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR6 to all subexpressions
+ */
+export declare function applyTR6(expr: BoxedExpression): BoxedExpression;
+export declare function TR7(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR7 to all subexpressions
+ */
+export declare function applyTR7(expr: BoxedExpression): BoxedExpression;
+export declare function TR7i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR7i to all subexpressions
+ */
+export declare function applyTR7i(expr: BoxedExpression): BoxedExpression;
+export declare function TR8(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR8 to all subexpressions
+ */
+export declare function applyTR8(expr: BoxedExpression): BoxedExpression;
+export declare function TR9(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR9 to all subexpressions
+ */
+export declare function applyTR9(expr: BoxedExpression): BoxedExpression;
+export declare function TR10(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR10 to all subexpressions
+ */
+export declare function applyTR10(expr: BoxedExpression): BoxedExpression;
+export declare function TR10i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR10i to all subexpressions
+ */
+export declare function applyTR10i(expr: BoxedExpression): BoxedExpression;
+export declare function TR11(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR11 to all subexpressions
+ */
+export declare function applyTR11(expr: BoxedExpression): BoxedExpression;
+export declare function TR11i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR11i to all subexpressions
+ */
+export declare function applyTR11i(expr: BoxedExpression): BoxedExpression;
+export declare function TR12(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR12 to all subexpressions
+ */
+export declare function applyTR12(expr: BoxedExpression): BoxedExpression;
+export declare function TR12i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR12i to all subexpressions
+ */
+export declare function applyTR12i(expr: BoxedExpression): BoxedExpression;
+export declare function TR13(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR13 to all subexpressions
+ */
+export declare function applyTR13(expr: BoxedExpression): BoxedExpression;
+export declare function TR22(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR22 to all subexpressions
+ */
+export declare function applyTR22(expr: BoxedExpression): BoxedExpression;
+export declare function TR22i(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TR22i to all subexpressions
+ */
+export declare function applyTR22i(expr: BoxedExpression): BoxedExpression;
+export declare function TRmorrie(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TRmorrie to all subexpressions
+ */
+export declare function applyTRmorrie(expr: BoxedExpression): BoxedExpression;
+export declare function TRpythagorean(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply TRpythagorean to all subexpressions
+ */
+export declare function applyTRpythagorean(expr: BoxedExpression): BoxedExpression;

package/dist/types/compute-engine/symbolic/fu.d.ts

@@ -0,0 +1,48 @@
+/* 0.33.0 */
+ * Fu Algorithm for Trigonometric Simplification
+ *
+ * Implementation of the algorithm by Fu, Zhong, and Zeng:
+ * "Automated and readable simplification of trigonometric expressions."
+ * Mathematical and Computer Modelling 44.11 (2006): 1169-1177.
+ *
+ * The algorithm uses a greedy approach with transformation rules (TR),
+ * combination transforms (CTR), and rule lists (RL) to simplify
+ * trigonometric expressions.
+ */
+import type { BoxedExpression, RuleStep } from '../global-types';
+import { TrigCostFunction } from './fu-cost';
+export interface FuOptions {
+    /**
+     * Cost function to evaluate expression complexity.
+     * Default minimizes trig function count, then leaf count.
+     */
+    measure?: TrigCostFunction;
+    /**
+     * Maximum iterations to prevent infinite loops.
+     * Default: 100
+     */
+    maxIterations?: number;
+}
+/**
+ * Apply the Fu algorithm to simplify a trigonometric expression.
+ *
+ * The algorithm:
+ * 1. Converts sec/csc to reciprocal forms (TR1) if present
+ * 2. For tan/cot expressions, applies RL1
+ * 3. If tan/cot remain, converts to sin/cos ratios (TR2)
+ * 4. For sin/cos expressions, applies RL2
+ * 5. Tries to convert back to tan/cot (TR2i)
+ * 6. Selects the best result based on the cost function
+ *
+ * @param expr The expression to simplify
+ * @param options Configuration options
+ * @returns RuleStep with simplified expression, or undefined if no simplification
+ */
+export declare function fu(expr: BoxedExpression, options?: FuOptions): RuleStep | undefined;
+/**
+ * Simplified entry point that returns the expression directly.
+ */
+export declare function fuSimplify(expr: BoxedExpression, options?: FuOptions): BoxedExpression;
+export { hasTrigFunction, hasOperator } from './fu-transforms';
+export { trigCost, countTrigFunctions, countLeaves } from './fu-cost';
+export type { TrigCostFunction } from './fu-cost';

package/dist/types/compute-engine/symbolic/simplify-abs.d.ts

@@ -0,0 +1,12 @@
+/* 0.33.0 */
+export declare function simplifyAbs(x: BoxedExpression): RuleStep | undefined;
+/**
+ * Simplify expressions where Abs appears as the base of a power.
+ * |x|^n -> x^n when n is even
+ */
+export declare function simplifyAbsPower(x: BoxedExpression): RuleStep | undefined;
+/**
+ * Even functions: f(|x|) -> f(x)
+ * This rule handles Cos, Sec, Cosh, Sech with Abs argument
+ */
+export declare function simplifyEvenFunctionAbs(x: BoxedExpression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-divide.d.ts

@@ -0,0 +1,15 @@
+/* 0.33.0 */
+/**
+ * Division simplification rules consolidated from simplify-rules.ts.
+ * Handles ~5 patterns for simplifying Divide expressions.
+ *
+ * Patterns:
+ * - a/a -> 1 (when a ≠ 0)
+ * - 1/(1/a) -> a (when a ≠ 0)
+ * - a/(1/b) -> a*b (when b ≠ 0)
+ * - a/(b/c) -> a*c/b (when c ≠ 0)
+ * - 0/a -> 0 (when a ≠ 0)
+ *
+ * IMPORTANT: Do not call .simplify() on results to avoid infinite recursion.
+ */
+export declare function simplifyDivide(x: BoxedExpression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-hyperbolic.d.ts

@@ -0,0 +1,2 @@
+/* 0.33.0 */
+export declare function simplifyHyperbolic(x: BoxedExpression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-infinity.d.ts

@@ -0,0 +1,14 @@
+/* 0.33.0 */
+/**
+ * Infinity simplification rules consolidated from simplify-rules.ts.
+ * Handles ~20 patterns for simplifying expressions involving infinity.
+ *
+ * Groups rules by operation type:
+ * - Multiply with infinity
+ * - Divide with infinity
+ * - Power with infinity
+ * - Indeterminate forms
+ *
+ * IMPORTANT: Do not call .simplify() on results to avoid infinite recursion.
+ */
+export declare function simplifyInfinity(x: BoxedExpression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-log.d.ts

@@ -0,0 +1,15 @@
+/* 0.33.0 */
+/**
+ * Logarithm simplification rules consolidated from simplify-rules.ts.
+ * Handles ~30 patterns for simplifying Ln and Log expressions.
+ *
+ * Categories:
+ * - Ln power rules: ln(x^n) -> n*ln(x)
+ * - Log power rules: log_c(x^n) -> n*log_c(x)
+ * - Logarithm combinations: ln(x) + ln(y) -> ln(xy)
+ * - Change of base rules
+ * - Logarithm with infinity
+ *
+ * IMPORTANT: Do not call .simplify() on results to avoid infinite recursion.
+ */
+export declare function simplifyLog(x: BoxedExpression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-power.d.ts

@@ -0,0 +1,15 @@
+/* 0.33.0 */
+/**
+ * Power simplification rules consolidated from simplify-rules.ts.
+ * Handles ~25 patterns for simplifying Power expressions.
+ *
+ * Categories:
+ * - Basic power rules: x^0, x^1, 0^x, 1^x
+ * - Power combination: x^n * x^m -> x^{n+m}
+ * - Nested powers: (x^n)^m -> x^{n*m}
+ * - Root simplifications: sqrt(x^2) -> |x|
+ * - Negative exponent in denominator
+ *
+ * IMPORTANT: Do not call .simplify() on results to avoid infinite recursion.
+ */
+export declare function simplifyPower(x: BoxedExpression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-product.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 /**
  * Product simplification rules extracted from simplify-rules.ts.
  * Handles 13 patterns for simplifying Product expressions.

package/dist/types/compute-engine/symbolic/simplify-rules.d.ts

@@ -1,14 +1,4 @@
-/* 0.32.1 */
-/**
- * @todo: a set to "tidy" an expression. Different from a canonical form, but
- * inline with the user's expectations.
- *
- * Example:
- *
- * - a^n * a^m -> a^(n+m)
- * - a / √b -> (a * √b) / b
- *
- */
+/* 0.33.0 */
 /**
  * A set of simplification rules.
  *

package/dist/types/compute-engine/symbolic/simplify-sum.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 /**
  * Sum simplification rules extracted from simplify-rules.ts.
  * Handles 16 patterns for simplifying Sum expressions.

package/dist/types/compute-engine/symbolic/simplify-trig.d.ts

@@ -0,0 +1,2 @@
+/* 0.33.0 */
+export declare function simplifyTrig(x: BoxedExpression): RuleStep | undefined;

package/dist/types/compute-engine/tensor/tensor-fields.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 import { BoxedExpression, ComputeEngine, DataTypeMap, TensorDataType, TensorField } from '../global-types';
 /** @category Tensors */
 export declare function makeTensorField<DT extends keyof DataTypeMap>(ce: ComputeEngine, dtype: DT): TensorField<DataTypeMap[DT]>;

package/dist/types/compute-engine/tensor/tensors.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 /** @category Tensors */
 export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> implements Tensor<DT> {
     private ce;
@@ -60,7 +60,7 @@ export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> imple
      */
     at(...indices: number[]): DataTypeMap[DT];
     diagonal(axis1?: number, axis2?: number): undefined | DataTypeMap[DT][];
-    trace(axis1?: number, axis2?: number): undefined | DataTypeMap[DT];
+    trace(axis1?: number, axis2?: number): undefined | DataTypeMap[DT] | AbstractTensor<DT>;
     /**
      * Change the shape of the tensor
      *
@@ -70,7 +70,7 @@ export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> imple
     slice(index: number): AbstractTensor<DT>;
     flatten(): DataTypeMap[DT][];
     upcast<DT extends keyof DataTypeMap>(dtype: DT): AbstractTensor<DT>;
-    /** Transpose the first and second axis */
+    /** Transpose the last two axes (default) */
     transpose(): undefined | AbstractTensor<DT>;
     /** Transpose two axes. */
     transpose(axis1: number, axis2: number, fn?: (v: DataTypeMap[DT]) => DataTypeMap[DT]): undefined | AbstractTensor<DT>;

package/dist/types/compute-engine/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export * from '../math-json/types';
 export * from '../common/type/boxed-type';
 export * from '../common/type/types';

package/dist/types/compute-engine.d.ts

@@ -1,3 +1,3 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export { ComputeEngine } from './compute-engine/index';
 export * from './compute-engine/types';

package/dist/types/math-json/symbols.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
  * Return true if the string is a valid symbol.
  *
  * Check for symbols matching a profile of [Unicode UAX31](https://unicode.org/reports/tr31/)

package/dist/types/math-json/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
  * The following properties can be added to any MathJSON expression
  * to provide additional information about the expression.
  *

package/dist/types/math-json/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const MISSING: Expression;
 export declare function isNumberExpression(expr: Expression | null): expr is number | string | MathJsonNumberObject;
 export declare function isNumberObject(expr: Expression | null): expr is MathJsonNumberObject;

package/dist/types/math-json.d.ts

@@ -1,3 +1,3 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export { isSymbolObject, isStringObject, isFunctionObject, stringValue, operator, operand, symbol, mapArgs, dictionaryFromExpression, } from './math-json/utils';
-export declare const version = "0.32.1";
+export declare const version = "0.33.0";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.32.1",
+  "version": "0.33.0",
   "scripts": {
     "doc": "bash ./scripts/doc.sh",
     "build": "bash ./scripts/build.sh",

package/dist/types/compute-engine/compilation/base-compiler.d.ts

@@ -1,31 +0,0 @@
-/* 0.32.1 */
-import type { CompileTarget, TargetSource } from './types';
-/**
- * Base compiler class containing language-agnostic compilation logic
- */
-export declare class BaseCompiler {
-    /**
-     * Compile an expression to target language source code
-     */
-    static compile(expr: BoxedExpression | undefined, target: CompileTarget, prec?: number): TargetSource;
-    /**
-     * Compile a function expression
-     */
-    static compileExpr(engine: ComputeEngine, h: string, args: ReadonlyArray<BoxedExpression>, prec: number, target: CompileTarget): TargetSource;
-    /**
-     * Compile a block expression
-     */
-    private static compileBlock;
-    /**
-     * Compile loop constructs (Sum/Product)
-     */
-    private static compileLoop;
-    /**
-     * Generate a temporary variable name
-     */
-    static tempVar(): string;
-    /**
-     * Inline or wrap expression in IIFE based on complexity
-     */
-    static inlineExpression(body: string, x: string): string;
-}

package/dist/types/compute-engine/compilation/javascript-target.d.ts

@@ -1,68 +0,0 @@
-/* 0.32.1 */
-import { chop, factorial, gcd, lcm, limit } from '../numerics/numeric';
-import { gamma, gammaln } from '../numerics/special-functions';
-import { interquartileRange, kurtosis, mean, median, mode, populationStandardDeviation, populationVariance, quartiles, skewness, standardDeviation, variance } from '../numerics/statistics';
-import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompiledExecutable } from './types';
-/**
- * JavaScript-specific function extension that provides system functions
- */
-export declare class ComputeEngineFunction extends Function {
-    SYS: {
-        chop: typeof chop;
-        factorial: typeof factorial;
-        gamma: typeof gamma;
-        gcd: typeof gcd;
-        integrate: (f: any, a: any, b: any) => number;
-        lcm: typeof lcm;
-        lngamma: typeof gammaln;
-        limit: typeof limit;
-        mean: typeof mean;
-        median: typeof median;
-        variance: typeof variance;
-        populationVariance: typeof populationVariance;
-        standardDeviation: typeof standardDeviation;
-        populationStandardDeviation: typeof populationStandardDeviation;
-        kurtosis: typeof kurtosis;
-        skewness: typeof skewness;
-        mode: typeof mode;
-        quartiles: typeof quartiles;
-        interquartileRange: typeof interquartileRange;
-    };
-    constructor(body: string, preamble?: string);
-}
-/**
- * JavaScript function literal with parameters
- */
-export declare class ComputeEngineFunctionLiteral extends Function {
-    SYS: {
-        chop: typeof chop;
-        factorial: typeof factorial;
-        gamma: typeof gamma;
-        gcd: typeof gcd;
-        integrate: (f: any, a: any, b: any) => number;
-        lcm: typeof lcm;
-        lngamma: typeof gammaln;
-        limit: typeof limit;
-        mean: typeof mean;
-        median: typeof median;
-        variance: typeof variance;
-        populationVariance: typeof populationVariance;
-        standardDeviation: typeof standardDeviation;
-        populationStandardDeviation: typeof populationStandardDeviation;
-        kurtosis: typeof kurtosis;
-        skewness: typeof skewness;
-        mode: typeof mode;
-        quartiles: typeof quartiles;
-        interquartileRange: typeof interquartileRange;
-    };
-    constructor(body: string, args: string[]);
-}
-/**
- * JavaScript language target implementation
- */
-export declare class JavaScriptTarget implements LanguageTarget {
-    getOperators(): CompiledOperators;
-    getFunctions(): CompiledFunctions;
-    createTarget(options?: Partial<CompileTarget>): CompileTarget;
-    compileToExecutable(expr: BoxedExpression, options?: CompilationOptions): CompiledExecutable;
-}