@cortex-js/compute-engine 0.32.0 → 0.32.1

package/dist/types/compute-engine/boxed-expression/polynomials.d.ts

@@ -0,0 +1,105 @@
+/* 0.32.1 */
+/**
+ * Coefficient of a univariate (single variable) polynomial.
+ *
+ * The first element is a constant.
+ * The second element is the coefficient of the variable.
+ * The third element is the coefficient of the variable squared.
+ * ...etc
+ *
+ * `3x^3 + 5x + √5 + 2` -> ['√5 + 2', 5, null, 3]
+ *
+ * If a coefficient does not apply (there are no corresponding term), it is `null`.
+ *
+ */
+export type UnivariateCoefficients = (null | BoxedExpression)[];
+export type MultivariateCoefficients = (null | (null | BoxedExpression)[])[];
+/**
+ * Return a list of coefficient of powers of `vars` in `poly`,
+ * starting with power 0.
+ *
+ * If `poly`  is not a polynomial, return `null`.
+ */
+export declare function coefficients(poly: BoxedExpression, vars: string): UnivariateCoefficients | null;
+export declare function coefficients(poly: BoxedExpression, vars: string[]): MultivariateCoefficients | null;
+/**
+ * The total degree of an expression is the sum of the
+ * positive integer degrees of the factors in the expression:
+ *
+ * `3√2x^5y^3` -> 5 + 3 = 8
+ */
+export declare function totalDegree(expr: BoxedExpression): number;
+/**
+ * The max degree of a polynomial is the largest positive integer degree
+ * in the factors (monomials) of the expression
+ *
+ * `3√2x^5y^3` -> 5
+ *
+ */
+export declare function maxDegree(expr: BoxedExpression): number;
+/**
+ * Return a lexicographic key of the expression, for example
+ * `xy^2` -> `x y`
+ * `x\frac{1}{y}` -> `x y`
+ * `2xy + y^2` -> `x y y`
+ *
+ */
+export declare function lex(expr: BoxedExpression): string;
+export declare function revlex(expr: BoxedExpression): string;
+/**
+ * Get the degree of a polynomial in a specific variable.
+ * Returns -1 if the expression is not a polynomial in the variable.
+ *
+ * Examples:
+ * - `polynomialDegree(x^3 + 2x + 1, 'x')` → 3
+ * - `polynomialDegree(x*y + y^2, 'x')` → 1
+ * - `polynomialDegree(sin(x), 'x')` → -1 (not a polynomial)
+ */
+export declare function polynomialDegree(expr: BoxedExpression, variable: string): number;
+/**
+ * Extract coefficients of a univariate polynomial.
+ * Returns an array where index i contains the coefficient of x^i.
+ * Returns null if the expression is not a polynomial in the variable.
+ *
+ * Examples:
+ * - `getPolynomialCoefficients(x^3 + 2x + 1, 'x')` → [1, 2, 0, 1]
+ * - `getPolynomialCoefficients(3x^2 - x + 5, 'x')` → [5, -1, 3]
+ */
+export declare function getPolynomialCoefficients(expr: BoxedExpression, variable: string): BoxedExpression[] | null;
+/**
+ * Construct a polynomial expression from its coefficients.
+ * coeffs[i] is the coefficient of x^i.
+ *
+ * Examples:
+ * - `fromCoefficients([1, 2, 0, 1], 'x')` → x^3 + 2x + 1
+ * - `fromCoefficients([5, -1, 3], 'x')` → 3x^2 - x + 5
+ */
+export declare function fromCoefficients(coeffs: BoxedExpression[], variable: string): BoxedExpression;
+/**
+ * Polynomial long division.
+ * Returns [quotient, remainder] such that dividend = divisor * quotient + remainder.
+ * Returns null if inputs are not valid polynomials or divisor is zero.
+ *
+ * Examples:
+ * - `polynomialDivide(x^3-1, x-1, 'x')` → [x^2+x+1, 0]
+ * - `polynomialDivide(x^3+2x+1, x+1, 'x')` → [x^2-x+3, -2]
+ */
+export declare function polynomialDivide(dividend: BoxedExpression, divisor: BoxedExpression, variable: string): [BoxedExpression, BoxedExpression] | null;
+/**
+ * Compute the GCD of two polynomials using the Euclidean algorithm.
+ * Returns a monic polynomial (leading coefficient = 1).
+ *
+ * Examples:
+ * - `polynomialGCD(x^2-1, x-1, 'x')` → x-1
+ * - `polynomialGCD(x^3-1, x^2-1, 'x')` → x-1
+ */
+export declare function polynomialGCD(a: BoxedExpression, b: BoxedExpression, variable: string): BoxedExpression;
+/**
+ * Cancel common polynomial factors in a rational expression (Divide).
+ * Returns the simplified expression.
+ *
+ * Examples:
+ * - `cancelCommonFactors((x^2-1)/(x-1), 'x')` → x+1
+ * - `cancelCommonFactors((x+1)/(x^2+3x+2), 'x')` → 1/(x+2)
+ */
+export declare function cancelCommonFactors(expr: BoxedExpression, variable: string): BoxedExpression;

package/dist/types/compute-engine/boxed-expression/product.d.ts

@@ -0,0 +1,66 @@
+/* 0.32.1 */
+import { NumericValue } from '../numeric-value/types';
+import type { Rational } from '../numerics/types';
+/**
+ * Group terms in a product by common term.
+ *
+ * All the terms should be canonical.
+ * - the arguments should have been flattened for `Multiply`
+ *
+ * - any argument of power been distributed, i.e.
+ *      (ab)^2 ->  a^2 b^2
+ * *
+ * 3 + √5 + √(x+1) + x^2 + (a+b)^2 + d
+ *  -> [ [[3, "d"], [1, 1]],
+ *       [[5, "x+1"], [1, 2]],
+ *       [[1, "a+b"], [2, 1]]
+ *      ]
+ *
+ */
+export declare class Product {
+    readonly options?: {
+        canonical?: boolean;
+    };
+    engine: ComputeEngine;
+    coefficient: NumericValue;
+    terms: {
+        term: BoxedExpression;
+        exponent: Rational;
+    }[];
+    private _isCanonical;
+    static from(expr: BoxedExpression): Product;
+    constructor(ce: ComputeEngine, xs?: ReadonlyArray<BoxedExpression>, options?: {
+        canonical?: boolean;
+    });
+    /**
+     * Add a term to the product.
+     *
+     * If `this._isCanonical` a running product of exact terms is kept.
+     * Otherwise, terms and their exponent are tallied.
+     */
+    mul(term: BoxedExpression, exp?: Rational): void;
+    /** Divide the product by a term of coefficient */
+    div(term: NumericValue | BoxedExpression): void;
+    /** The terms of the product, grouped by degrees.
+     *
+     * If `mode` is `rational`, rationals are split into separate numerator and
+     * denominator, so that a rational expression can be created later
+     * If `mode` is `expression`, a boxed expression is returned, without
+     * splitting rationals
+     * If `mode` is `numeric`, the literals are combined into one expression
+     *
+     */
+    groupedByDegrees(options?: {
+        mode?: 'rational' | 'expression' | 'numeric';
+    }): {
+        exponent: Rational;
+        terms: BoxedExpression[];
+    }[] | null;
+    asExpression(options?: {
+        numericApproximation: boolean;
+    }): BoxedExpression;
+    /** The product, expressed as a numerator and denominator */
+    asNumeratorDenominator(): [BoxedExpression, BoxedExpression];
+    asRationalExpression(): BoxedExpression;
+}
+export declare function commonTerms(lhs: Product, rhs: Product): [NumericValue, BoxedExpression];

package/dist/types/compute-engine/boxed-expression/rules.d.ts

@@ -0,0 +1,129 @@
+/* 0.32.1 */
+export declare const ConditionParent: {
+    boolean: string;
+    string: string;
+    expression: string;
+    numeric: string;
+    number: string;
+    symbol: string;
+    complex: string;
+    imaginary: string;
+    real: string;
+    notreal: string;
+    integer: string;
+    rational: string;
+    irrational: string;
+    notzero: string;
+    notone: string;
+    finite: string;
+    infinite: string;
+    positive: string;
+    negative: string;
+    nonnegative: string;
+    nonpositive: string;
+    even: string;
+    odd: string;
+    prime: string;
+    composite: string;
+    constant: string;
+    variable: string;
+    function: string;
+    operator: string;
+    relation: string;
+    equation: string;
+    inequality: string;
+    collection: string;
+    list: string;
+    set: string;
+    tuple: string;
+    single: string;
+    pair: string;
+    triple: string;
+    tensor: string;
+    vector: string;
+    matrix: string;
+    scalar: string;
+    unit: string;
+    dimension: string;
+    angle: string;
+    polynomial: string;
+};
+export declare const CONDITIONS: {
+    boolean: (x: BoxedExpression) => boolean;
+    string: (x: BoxedExpression) => boolean;
+    number: (x: BoxedExpression) => boolean;
+    symbol: (x: BoxedExpression) => boolean;
+    expression: (x: BoxedExpression) => boolean;
+    numeric: (x: BoxedExpression) => boolean;
+    integer: (x: BoxedExpression) => boolean;
+    rational: (x: BoxedExpression) => boolean;
+    irrational: (x: BoxedExpression) => boolean;
+    real: (x: BoxedExpression) => boolean;
+    notreal: (x: BoxedExpression) => boolean;
+    complex: (x: BoxedExpression) => boolean;
+    imaginary: (x: BoxedExpression) => boolean;
+    positive: (x: BoxedExpression) => boolean;
+    negative: (x: BoxedExpression) => boolean;
+    nonnegative: (x: BoxedExpression) => boolean;
+    nonpositive: (x: BoxedExpression) => boolean;
+    even: (x: BoxedExpression) => boolean;
+    odd: (x: BoxedExpression) => boolean;
+    prime: (x: BoxedExpression) => boolean;
+    composite: (x: BoxedExpression) => boolean;
+    notzero: (x: BoxedExpression) => boolean;
+    notone: (x: BoxedExpression) => boolean;
+    finite: (x: BoxedExpression) => boolean;
+    infinite: (x: BoxedExpression) => boolean;
+    constant: (x: BoxedExpression) => boolean;
+    variable: (x: BoxedExpression) => boolean;
+    function: (x: BoxedExpression) => boolean;
+    relation: (x: BoxedExpression) => boolean;
+    equation: (x: BoxedExpression) => boolean;
+    inequality: (x: BoxedExpression) => boolean;
+    collection: (x: BoxedExpression) => boolean;
+    list: (x: BoxedExpression) => boolean;
+    set: (x: BoxedExpression) => boolean;
+    tuple: (x: BoxedExpression) => boolean;
+    single: (x: BoxedExpression) => boolean;
+    pair: (x: BoxedExpression) => boolean;
+    triple: (x: BoxedExpression) => boolean;
+    scalar: (x: BoxedExpression) => boolean;
+    tensor: (x: BoxedExpression) => boolean;
+    vector: (x: BoxedExpression) => boolean;
+    matrix: (x: BoxedExpression) => boolean;
+    unit: (x: BoxedExpression) => boolean;
+    dimension: (x: BoxedExpression) => boolean;
+    angle: (x: BoxedExpression) => boolean;
+    polynomial: (x: BoxedExpression) => boolean;
+};
+export declare function checkConditions(x: BoxedExpression, conditions: string[]): boolean;
+/**
+ * Create a boxed rule set from a collection of non-boxed rules
+ */
+export declare function boxRules(ce: ComputeEngine, rs: Rule | ReadonlyArray<Rule | BoxedRule> | BoxedRuleSet | undefined | null, options?: {
+    canonical?: boolean;
+}): BoxedRuleSet;
+/**
+ * Apply a rule to an expression, assuming an incoming substitution
+ * @param rule the rule to apply
+ * @param expr the expression to apply the rule to
+ * @param substitution an incoming substitution
+ * @param options
+ * @returns A transformed expression, if the rule matched. `null` otherwise.
+ */
+export declare function applyRule(rule: Readonly<BoxedRule>, expr: BoxedExpression, substitution: BoxedSubstitution, options?: Readonly<Partial<ReplaceOptions>>): RuleStep | null;
+/**
+ * Apply the rules in the ruleset and return a modified expression
+ * and the set of rules that were applied.
+ *
+ * The `replace` function can be used to apply a rule to a non-canonical
+ * expression.
+ *
+ */
+export declare function replace(expr: BoxedExpression, rules: Rule | (Rule | BoxedRule)[] | BoxedRuleSet, options?: Partial<ReplaceOptions>): RuleSteps;
+/**
+ * For each rules in the rule set that match, return the `replace` of the rule
+ *
+ * @param rules
+ */
+export declare function matchAnyRules(expr: BoxedExpression, rules: BoxedRuleSet, sub: BoxedSubstitution, options?: Partial<ReplaceOptions>): BoxedExpression[];

package/dist/types/compute-engine/boxed-expression/serialize.d.ts

@@ -0,0 +1,3 @@
+/* 0.32.1 */
+import type { ComputeEngine, BoxedExpression, JsonSerializationOptions } from '../global-types';
+export declare function serializeJson(ce: ComputeEngine, expr: BoxedExpression, options: Readonly<JsonSerializationOptions>): Expression;

package/dist/types/compute-engine/boxed-expression/sgn.d.ts

@@ -0,0 +1,46 @@
+/* 0.32.1 */
+export declare function sgn(expr: BoxedExpression): Sign | undefined;
+/**
+ * Sign `s` is > 0.
+ *
+ * :::info[Note]
+ * Returns `undefined` for cases where the given sign is either non-applicable to real numbers
+ * ('nan', 'unsigned', 'complex-infinity') or does not convey enough information (e.g. 'real',
+ * 'not-zero', 'real-not-zero', 'non-negative').
+ * :::
+ *
+ * @param s
+ */
+export declare function positiveSign(s: Sign | undefined): boolean | undefined;
+/**
+ * Sign `s` is >= 0.
+ *
+ *
+ * **note**: returns *undefined* where sign does not apply to the field of reals, or does not convey
+ * enough information.
+ *
+ * @param s
+ */
+export declare function nonNegativeSign(s: Sign | undefined): boolean | undefined;
+/**
+ * Sign `s` is < 0.
+ *
+ * :::info[Note]
+ * Returns `undefined` for cases where the given sign is either non-applicable to real numbers
+ * ('nan', 'unsigned', 'complex-infinity') or does not convey enough information (e.g. 'real',
+ * 'not-zero', 'real-not-zero', 'non-positive').
+ * :::
+ *
+ * @param s
+ */
+export declare function negativeSign(s: Sign | undefined): boolean | undefined;
+/**
+ * Sign `s` is <= 0.
+ *
+ *
+ * **note**: returns *undefined* where sign does not apply to the field of reals, or does not convey
+ * enough information.
+ *
+ * @param s
+ */
+export declare function nonPositiveSign(s: Sign | undefined): boolean | undefined;

package/dist/types/compute-engine/boxed-expression/simplify.d.ts

@@ -0,0 +1,6 @@
+/* 0.32.1 */
+type InternalSimplifyOptions = SimplifyOptions & {
+    useVariations: boolean;
+};
+export declare function simplify(expr: BoxedExpression, options?: Partial<InternalSimplifyOptions>, steps?: RuleSteps): RuleSteps;
+export {};

package/dist/types/compute-engine/boxed-expression/solve.d.ts

@@ -0,0 +1,20 @@
+/* 0.32.1 */
+export declare const UNIVARIATE_ROOTS: Rule[];
+/**
+ * Expression is a function of a single variable (`x`) or an Equality
+ *
+ * Return the roots of that variable
+ *
+ */
+export declare function findUnivariateRoots(expr: BoxedExpression, x: string): ReadonlyArray<BoxedExpression>;
+/** Expr is an equation with an operator of
+ * - `Equal`, `Less`, `Greater`, `LessEqual`, `GreaterEqual`
+ *
+ * Return an expression with the same operator, but with the first argument
+ * a variable, if possible:
+ * `2x < 4` => `x < 2`
+ */
+export declare function univariateSolve(expr: BoxedExpression, x: string): ReadonlyArray<BoxedExpression> | null;
+/** Harmonization rules transform an expr into one or more equivalent
+ * expressions that are easier to solve */
+export declare const HARMONIZATION_RULES: Rule[];

package/dist/types/compute-engine/boxed-expression/terms.d.ts

@@ -0,0 +1,10 @@
+/* 0.32.1 */
+export declare class Terms {
+    private engine;
+    private terms;
+    constructor(ce: ComputeEngine, terms: ReadonlyArray<BoxedExpression>);
+    private add;
+    private find;
+    N(): BoxedExpression;
+    asExpression(): BoxedExpression;
+}

package/dist/types/compute-engine/boxed-expression/trigonometry.d.ts

@@ -0,0 +1,9 @@
+/* 0.32.1 */
+export declare function Fu(exp: BoxedExpression): RuleStep | undefined;
+/** Assuming x in an expression in radians, convert to current angular unit. */
+export declare function radiansToAngle(x: BoxedExpression | undefined): BoxedExpression | undefined;
+export declare function evalTrig(name: string, op: BoxedExpression | undefined): BoxedExpression | undefined;
+export declare function processInverseFunction(ce: ComputeEngine, xs: ReadonlyArray<BoxedExpression>): BoxedExpression | undefined;
+export declare function trigSign(operator: string, x: BoxedExpression): Sign | undefined;
+export declare function isConstructible(x: string | BoxedExpression): boolean;
+export declare function constructibleValues(operator: string, x: BoxedExpression | undefined): undefined | BoxedExpression;

package/dist/types/compute-engine/boxed-expression/utils.d.ts

@@ -0,0 +1,64 @@
+/* 0.32.1 */
+import { Type } from '../../common/type/types';
+import { NumericValue } from '../numeric-value/types';
+/**
+ * Check if an expression contains symbolic transcendental functions of constants
+ * (like ln(2), sin(1), etc.) that should not be evaluated numerically.
+ *
+ * This excludes transcendentals that simplify to exact values, such as:
+ * - ln(e) -> 1
+ * - sin(0) -> 0
+ * - cos(0) -> 1
+ */
+export declare function hasSymbolicTranscendental(expr: BoxedExpression): boolean;
+export declare function isDictionary(expr: any | null | undefined): expr is DictionaryInterface;
+export declare function isBoxedExpression(x: unknown): x is BoxedExpression;
+/**
+ * For any numeric result, if `bignumPreferred()` is true, calculate using
+ * bignums. If `bignumPreferred()` is false, calculate using machine numbers
+ */
+export declare function bignumPreferred(ce: ComputeEngine): boolean;
+export declare function hashCode(s: string): number;
+export declare function normalizedUnknownsForSolve(syms: string | Iterable<string> | BoxedExpression | Iterable<BoxedExpression> | null | undefined): string[];
+/** Return the local variables in the expression.
+ *
+ * A local variable is a symbol that is declared with a `Declare`
+ * expression in a `Block` expression.
+ *
+ */
+export declare function getLocalVariables(expr: BoxedExpression): string[];
+export declare function domainToType(expr: BoxedExpression): Type;
+/**
+ * Return the angle in the range [0, 2π) that is equivalent to the given angle.
+ *
+ * @param x
+ * @returns
+ */
+export declare function canonicalAngle(x: BoxedExpression | undefined): BoxedExpression | undefined;
+/**
+ * Return a multiple of the imaginary unit, e.g.
+ * - 'ImaginaryUnit'  -> 1
+ * - ['Negate', 'ImaginaryUnit']  -> -1
+ * - ['Negate', ['Multiply', 3, 'ImaginaryUnit']] -> -3
+ * - ['Multiply', 5, 'ImaginaryUnit'] -> 5
+ * - ['Multiply', 'ImaginaryUnit', 5] -> 5
+ * - ['Divide', 'ImaginaryUnit', 2] -> 0.5
+ *
+ */
+export declare function getImaginaryFactor(expr: number | BoxedExpression): BoxedExpression | undefined;
+/**
+ * `true` if expr is a number with imaginary part 1 and real part 0, or a symbol with a definition
+ * matching this. Does not bind expr if a symbol.
+ *
+ * @export
+ * @param expr
+ * @returns
+ */
+export declare function isImaginaryUnit(expr: BoxedExpression): boolean;
+export declare function getPiTerm(expr: BoxedExpression): [k: NumericValue, t: NumericValue];
+export declare function isValidOperatorDef(def: any): def is Partial<OperatorDefinition>;
+export declare function isValidValueDef(def: any): def is Partial<ValueDefinition>;
+export declare function isValueDef(def: BoxedDefinition | undefined): def is TaggedValueDefinition;
+export declare function isOperatorDef(def: BoxedDefinition | undefined): def is TaggedOperatorDefinition;
+export declare function updateDef(ce: ComputeEngine, name: string, def: BoxedDefinition, newDef: Partial<OperatorDefinition> | BoxedOperatorDefinition | Partial<ValueDefinition> | BoxedValueDefinition): void;
+export declare function placeholderDef(ce: ComputeEngine, name: string): BoxedDefinition;

package/dist/types/compute-engine/boxed-expression/validate.d.ts

@@ -0,0 +1,58 @@
+/* 0.32.1 */
+import type { BoxedExpression, ComputeEngine } from '../global-types';
+/**
+ * Check that the number of arguments is as expected.
+ *
+ * Converts the arguments to canonical, and flattens the sequence.
+ */
+export declare function checkArity(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>, count: number): ReadonlyArray<BoxedExpression>;
+/**
+ * Validation of arguments is normally done by checking the signature of the
+ * function vs the arguments of the expression. However, we have a fastpath
+ * for some common operations (add, multiply, power, neg, etc...) that bypasses
+ * the regular checks. This is its replacements.
+ *
+ * Since all those fastpath functions are numeric (i.e. have numeric arguments
+ * and a numeric result), we do a simple numeric check of all arguments, and
+ * verify we have the number of expected arguments.
+ *
+ * We also assume that the function is threadable.
+ *
+ * The arguments are made canonical.
+ *
+ * Flattens sequence expressions.
+ */
+export declare function checkNumericArgs(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>, options?: number | {
+    count?: number;
+    flatten?: string;
+}): ReadonlyArray<BoxedExpression>;
+/**
+ * Check that an argument is of the expected type.
+ *
+ * Converts the arguments to canonical
+ */
+export declare function checkType(ce: ComputeEngine, arg: BoxedExpression | undefined | null, type: Type | undefined): BoxedExpression;
+export declare function checkTypes(ce: ComputeEngine, args: ReadonlyArray<BoxedExpression>, types: Type[]): ReadonlyArray<BoxedExpression>;
+/**
+ * Check that the argument is pure.
+ */
+export declare function checkPure(ce: ComputeEngine, arg: BoxedExpression | BoxedExpression | undefined | null): BoxedExpression;
+/**
+ *
+ * If the arguments match the parameters, return null.
+ *
+ * Otherwise return a list of expressions indicating the mismatched
+ * arguments.
+ *
+ * <!--
+ * @todo?:
+ * - Some permutations of operands should perhaps always be treated as invalid. Consider:
+ *   - A sequence wildcard (non-optional, i.e. '__') followed by either a universal wildcard ('_'),
+ *   or another non-optional sequence wildcard. (note that an optional sequence wildcard is
+ *   unproblematic here.)
+ *
+ * -->
+ *
+ */
+export declare function validateArguments(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>, signature: Type, lazy?: boolean, threadable?: boolean): ReadonlyArray<BoxedExpression> | null;
+export declare function spellCheckMessage(expr: BoxedExpression): string;

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

@@ -0,0 +1,35 @@
+/* 0.32.1 */
+/** If a collection has fewer than this many elements, eagerly evaluate it.
+ *
+ * For example, evaluate the Union of two sets with 10 elements each will
+ * result in a set with 20 elements.
+ *
+ * If the sum of the sizes of the two sets is greater than
+ * `MAX_SIZE_EAGER_COLLECTION`, the result is a Union expression
+ *
+ */
+export declare const MAX_SIZE_EAGER_COLLECTION = 100;
+export declare function isFiniteIndexedCollection(col: BoxedExpression): boolean;
+export declare function repeat(value: BoxedExpression, count?: number): Iterator<BoxedExpression>;
+/**
+ * Zips together multiple collections into a single iterator.
+ *
+ * Example:
+ * ```typescript
+ * const a = ce.box(['List', 1, 2, 3]);
+ * const b = ce.box(['List', 4, 5, 6]);
+ * const zipped = zip([a, b]);
+ * for (const [x, y] of zipped) {
+ *   console.log(x, y); // 1 4, 2 5, 3 6
+ * }
+ * ```
+ */
+export declare function zip(items: ReadonlyArray<BoxedExpression>): Iterator<BoxedExpression[]>;
+/**
+ * Default collection handlers suitable for collections that store their
+ * elements as operands.
+ *
+ * This is the case for List, Tuple, etc.
+ */
+export declare function basicIndexedCollectionHandlers(): CollectionHandlers;
+export declare function defaultCollectionHandlers(def: undefined | CollectionHandlers): CollectionHandlers | undefined;

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

@@ -0,0 +1,31 @@
+/* 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

@@ -0,0 +1,68 @@
+/* 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;
+}