@cortex-js/compute-engine 0.35.6 → 0.50.1

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

@@ -1,10 +1,10 @@
-/* 0.35.6 */
+/* 0.50.1 */
 import type { Type, TypeString } from '../../common/type/types';
 import type { OneOf } from '../../common/one-of';
 import { BoxedType } from '../../common/type/boxed-type';
 import type { BigNum } from '../numerics/types';
 import { NumericValue } from '../numeric-value/types';
-import type { BoxedExpression, SimplifyOptions, PatternMatchOptions, ReplaceOptions, BoxedValueDefinition, BoxedOperatorDefinition, ComputeEngine, Metadata, CanonicalOptions, BoxedBaseDefinition, BoxedSubstitution, EvaluateOptions, Rule, BoxedRule, BoxedRuleSet, Substitution, Sign, BoxedDefinition, CollectionHandlers } from '../global-types';
+import type { Expression, SimplifyOptions, PatternMatchOptions, ReplaceOptions, BoxedValueDefinition, BoxedOperatorDefinition, IComputeEngine as ComputeEngine, Metadata, CanonicalOptions, BoxedBaseDefinition, BoxedSubstitution, EvaluateOptions, Rule, BoxedRule, BoxedRuleSet, Substitution, Sign, BoxedDefinition, CollectionHandlers, SymbolInterface } from '../global-types';
 import { _BoxedExpression } from './abstract-boxed-expression';
 /**
  * ### BoxedSymbol
@@ -34,7 +34,8 @@ import { _BoxedExpression } from './abstract-boxed-expression';
  * symbol may have no value).
  *
  */
-export declare class BoxedSymbol extends _BoxedExpression {
+export declare class BoxedSymbol extends _BoxedExpression implements SymbolInterface {
+    readonly _kind = "symbol";
     private _hash;
     /** The name of the symbol */
     protected _id: MathJsonSymbol;
@@ -47,7 +48,7 @@ export declare class BoxedSymbol extends _BoxedExpression {
         metadata?: Metadata;
         def?: BoxedDefinition;
     });
-    get json(): Expression;
+    get json(): MathJsonExpression;
     get hash(): number;
     get isPure(): boolean;
     get isConstant(): boolean;
@@ -55,20 +56,20 @@ export declare class BoxedSymbol extends _BoxedExpression {
     reset(): void;
     get isCanonical(): boolean;
     set isCanonical(val: boolean);
-    get canonical(): BoxedExpression;
-    is(other: any): boolean;
-    toNumericValue(): [NumericValue, BoxedExpression];
-    neg(): BoxedExpression;
-    inv(): BoxedExpression;
-    abs(): BoxedExpression;
-    add(rhs: number | BoxedExpression): BoxedExpression;
-    mul(rhs: NumericValue | number | BoxedExpression): BoxedExpression;
-    div(rhs: number | BoxedExpression): BoxedExpression;
-    pow(exp: number | BoxedExpression): BoxedExpression;
-    root(n: number | BoxedExpression): BoxedExpression;
-    sqrt(): BoxedExpression;
-    ln(semiBase?: number | BoxedExpression): BoxedExpression;
-    solve(vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
+    get canonical(): Expression;
+    is(other: unknown): boolean;
+    toNumericValue(): [NumericValue, Expression];
+    neg(): Expression;
+    inv(): Expression;
+    abs(): Expression;
+    add(rhs: number | Expression): Expression;
+    mul(rhs: NumericValue | number | Expression): Expression;
+    div(rhs: number | Expression): Expression;
+    pow(exp: number | Expression): Expression;
+    root(n: number | Expression): Expression;
+    sqrt(): Expression;
+    ln(semiBase?: number | Expression): Expression;
+    solve(vars?: Iterable<string> | string | Expression | Iterable<Expression>): null | ReadonlyArray<Expression>;
     get complexity(): number;
     get operator(): MathJsonSymbol;
     get symbol(): MathJsonSymbol;
@@ -101,8 +102,8 @@ export declare class BoxedSymbol extends _BoxedExpression {
      */
     infer(t: Type, inferenceMode?: 'narrow' | 'widen'): boolean;
     /** Return the value of the symbol, undefined if an operator or not bound */
-    get _value(): BoxedExpression | undefined;
-    get value(): BoxedExpression | undefined;
+    get _value(): Expression | undefined;
+    get value(): Expression | undefined;
     set value(value: boolean | string | BigNum | number[] | OneOf<[
         {
             re: number;
@@ -112,7 +113,7 @@ export declare class BoxedSymbol extends _BoxedExpression {
             num: number;
             denom: number;
         },
-        BoxedExpression
+        Expression
     ]> | number | undefined);
     /**
      * The type of the symbol.
@@ -127,7 +128,7 @@ export declare class BoxedSymbol extends _BoxedExpression {
     get type(): BoxedType;
     set type(t: Type | TypeString | BoxedType);
     has(x: MathJsonSymbol | MathJsonSymbol[]): boolean;
-    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    match(pattern: Expression, options?: PatternMatchOptions): BoxedSubstitution | null;
     /** The shape of the tensor (dimensions), derived from the type */
     get shape(): number[];
     /** The rank of the tensor (number of dimensions), derived from the type */
@@ -151,24 +152,24 @@ export declare class BoxedSymbol extends _BoxedExpression {
     get im(): number;
     get bignumRe(): BigNum | undefined;
     get bignumIm(): BigNum | undefined;
-    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
-    evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
-    N(): BoxedExpression;
-    replace(rules: Rule | (Rule | BoxedRule)[] | BoxedRuleSet, options?: Partial<ReplaceOptions>): BoxedExpression | null;
+    simplify(options?: Partial<SimplifyOptions>): Expression;
+    evaluate(options?: Partial<EvaluateOptions>): Expression;
+    N(): Expression;
+    replace(rules: Rule | (Rule | BoxedRule)[] | BoxedRuleSet, options?: Partial<ReplaceOptions>): Expression | null;
     subs(sub: Substitution, options?: {
         canonical?: CanonicalOptions;
-    }): BoxedExpression;
+    }): Expression;
     get _asCollection(): CollectionHandlers | undefined;
     get isCollection(): boolean;
     get isIndexedCollection(): boolean;
     get isLazyCollection(): boolean;
-    contains(rhs: BoxedExpression): boolean | undefined;
+    contains(rhs: Expression): boolean | undefined;
     get count(): number;
     get isEmptyCollection(): boolean;
     get isFiniteCollection(): boolean | undefined;
-    each(): Generator<BoxedExpression>;
-    at(index: number): BoxedExpression | undefined;
-    get(index: BoxedExpression | string): BoxedExpression | undefined;
-    indexWhere(predicate: (element: BoxedExpression) => boolean): number | undefined;
-    subsetOf(rhs: BoxedExpression, strict: boolean): boolean;
+    each(): Generator<Expression>;
+    at(index: number): Expression | undefined;
+    get(index: Expression | string): Expression | undefined;
+    indexWhere(predicate: (element: Expression) => boolean): number | undefined;
+    subsetOf(rhs: Expression, strict: boolean): boolean;
 }

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

@@ -1,5 +1,5 @@
-/* 0.35.6 */
-import type { ComputeEngine, TensorDataType, Metadata, BoxedBaseDefinition, BoxedOperatorDefinition, BoxedSubstitution, EvaluateOptions, BoxedExpression, SimplifyOptions, PatternMatchOptions, Tensor } from '../global-types';
+/* 0.50.1 */
+import type { IComputeEngine as ComputeEngine, TensorDataType, Metadata, BoxedBaseDefinition, BoxedOperatorDefinition, BoxedSubstitution, EvaluateOptions, Expression, SimplifyOptions, PatternMatchOptions, Tensor, TensorInterface } from '../global-types';
 import { BoxedType } from '../../common/type/boxed-type';
 import { NumericValue } from '../numeric-value/types';
 import { _BoxedExpression } from './abstract-boxed-expression';
@@ -14,71 +14,72 @@ import { _BoxedExpression } from './abstract-boxed-expression';
  * if input is expression) is created lazily.
  *
  */
-export declare class BoxedTensor<T extends TensorDataType> extends _BoxedExpression {
+export declare class BoxedTensor<T extends TensorDataType> extends _BoxedExpression implements TensorInterface {
     readonly input: {
-        ops: ReadonlyArray<BoxedExpression>;
+        ops: ReadonlyArray<Expression>;
         shape: number[];
         dtype: T;
     };
     readonly options?: {
         metadata?: Metadata;
     };
+    readonly _kind = "tensor";
     private _tensor;
     private _expression?;
     constructor(ce: ComputeEngine, input: {
-        ops: ReadonlyArray<BoxedExpression>;
+        ops: ReadonlyArray<Expression>;
         shape: number[];
         dtype: T;
     }, options?: {
         metadata?: Metadata;
     });
-    get structural(): BoxedExpression;
+    get structural(): Expression;
     /** Create the tensor on demand */
     get tensor(): Tensor<T>;
     get baseDefinition(): BoxedBaseDefinition | undefined;
     get operatorDefinition(): BoxedOperatorDefinition | undefined;
     get hash(): number;
-    get canonical(): BoxedExpression;
+    get canonical(): Expression;
     get isCanonical(): boolean;
     get isPure(): boolean;
     get isValid(): boolean;
     get complexity(): number;
     get operator(): string;
     get nops(): number;
-    get ops(): ReadonlyArray<BoxedExpression>;
-    get op1(): BoxedExpression;
-    get op2(): BoxedExpression;
-    get op3(): BoxedExpression;
-    neg(): BoxedExpression;
-    inv(): BoxedExpression;
-    abs(): BoxedExpression;
-    add(rhs: number | BoxedExpression): BoxedExpression;
-    sub(rhs: BoxedExpression): BoxedExpression;
-    mul(rhs: NumericValue | number | BoxedExpression): BoxedExpression;
-    div(rhs: number | BoxedExpression): BoxedExpression;
-    pow(exp: number | BoxedExpression): BoxedExpression;
-    root(exp: number | BoxedExpression): BoxedExpression;
-    sqrt(): BoxedExpression;
+    get ops(): ReadonlyArray<Expression>;
+    get op1(): Expression;
+    get op2(): Expression;
+    get op3(): Expression;
+    neg(): Expression;
+    inv(): Expression;
+    abs(): Expression;
+    add(rhs: number | Expression): Expression;
+    sub(rhs: Expression): Expression;
+    mul(rhs: NumericValue | number | Expression): Expression;
+    div(rhs: number | Expression): Expression;
+    pow(exp: number | Expression): Expression;
+    root(exp: number | Expression): Expression;
+    sqrt(): Expression;
     get shape(): number[];
     get rank(): number;
     get type(): BoxedType;
-    get json(): Expression;
+    get json(): MathJsonExpression;
     /** Mathematical equality */
-    isEqual(rhs: number | BoxedExpression): boolean | undefined;
+    isEqual(rhs: number | Expression): boolean | undefined;
     get isCollection(): boolean;
     get isIndexedCollection(): boolean;
-    contains(other: BoxedExpression): boolean | undefined;
+    contains(other: Expression): boolean | undefined;
     get count(): number;
-    each(): Generator<BoxedExpression>;
-    at(index: number): BoxedExpression | undefined;
-    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
-    evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
-    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
-    N(): BoxedExpression;
-    solve(vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression> | Record<string, BoxedExpression> | Array<Record<string, BoxedExpression>>;
+    each(): Generator<Expression>;
+    at(index: number): Expression | undefined;
+    match(pattern: Expression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    evaluate(options?: Partial<EvaluateOptions>): Expression;
+    simplify(options?: Partial<SimplifyOptions>): Expression;
+    N(): Expression;
+    solve(vars?: Iterable<string> | string | Expression | Iterable<Expression>): null | ReadonlyArray<Expression> | Record<string, Expression> | Array<Record<string, Expression>>;
 }
-export declare function isBoxedTensor(val: unknown): val is BoxedTensor<any>;
-export declare function expressionTensorInfo(operator: string, rows: ReadonlyArray<BoxedExpression>): {
+export declare function isTensor(val: unknown): val is BoxedTensor<TensorDataType>;
+export declare function expressionTensorInfo(operator: string, rows: ReadonlyArray<Expression>): {
     shape: number[];
     dtype: TensorDataType;
 } | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 import type { Type, TypeString } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';
 import { ConfigurationChangeListener } from '../../common/configuration-change';
@@ -31,19 +31,19 @@ export declare class _BoxedValueDefinition implements BoxedValueDefinition, Conf
     inferredType: boolean;
     _isConstant: boolean;
     holdUntil: 'never' | 'evaluate' | 'N';
-    eq?: (a: BoxedExpression) => boolean | undefined;
-    neq?: (a: BoxedExpression) => boolean | undefined;
-    cmp?: (a: BoxedExpression) => '=' | '>' | '<' | undefined;
+    eq?: (a: Expression) => boolean | undefined;
+    neq?: (a: Expression) => boolean | undefined;
+    cmp?: (a: Expression) => '=' | '>' | '<' | undefined;
     collection?: CollectionHandlers;
-    subscriptEvaluate?: (subscript: BoxedExpression, options: {
+    subscriptEvaluate?: (subscript: Expression, options: {
         engine: ComputeEngine;
         numericApproximation?: boolean;
-    }) => BoxedExpression | undefined;
+    }) => Expression | undefined;
     constructor(ce: ComputeEngine, name: string, def: Partial<ValueDefinition>);
     /** For debugging */
-    toJSON(): any;
+    toJSON(): Record<string, unknown>;
     get isConstant(): boolean;
-    get value(): BoxedExpression | undefined;
+    get value(): Expression | undefined;
     get type(): BoxedType;
     set type(t: Type | TypeString | BoxedType);
     onConfigurationChange(): void;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
     value: T | null;
     generation: number | undefined;
 };

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

@@ -1,5 +1,5 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /**
  * Ensure all expressions in the array are in canonical form
  */
-export declare function canonical(ce: ComputeEngine, xs: ReadonlyArray<BoxedExpression>, scope?: Scope): ReadonlyArray<BoxedExpression>;
+export declare function canonical(ce: ComputeEngine, xs: ReadonlyArray<Expression>, scope?: Scope): ReadonlyArray<Expression>;

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

@@ -1,2 +1,2 @@
-/* 0.35.6 */
-export declare function canonicalForm(expr: BoxedExpression, forms: CanonicalOptions, scope?: Scope): BoxedExpression;
+/* 0.50.1 */
+export declare function canonicalForm(expr: Expression, forms: CanonicalOptions, scope?: Scope): Expression;

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

@@ -1,13 +1,16 @@
-/* 0.35.6 */
+/* 0.50.1 */
+import type { expand as _ExpandFn } from './expand';
+/** @internal */
+export declare function _setExpand(fn: typeof _ExpandFn): void;
 /**
  * Structural equality of boxed expressions.
  */
-export declare function same(a: BoxedExpression, b: BoxedExpression): boolean;
+export declare function same(a: Expression, b: Expression): boolean;
 /**
  * Mathematical equality of two boxed expressions.
  *
  * In general, it is impossible to always prove equality
  * ([Richardson's theorem](https://en.wikipedia.org/wiki/Richardson%27s_theorem)) but this works often...
  */
-export declare function eq(a: BoxedExpression, inputB: number | BoxedExpression): boolean | undefined;
-export declare function cmp(a: BoxedExpression, b: number | BoxedExpression): '<' | '=' | '>' | '>=' | '<=' | undefined;
+export declare function eq(a: Expression, inputB: number | Expression): boolean | undefined;
+export declare function cmp(a: Expression, b: number | Expression): '<' | '=' | '>' | '>=' | '<=' | undefined;

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

@@ -0,0 +1,6 @@
+/* 0.50.1 */
+ * Leaf module for shared constants used across boxed-expression modules.
+ * No imports from sibling modules to avoid circular dependencies.
+ */
+/** Default complexity for operators that don't specify one */
+export declare const DEFAULT_COMPLEXITY = 100000;

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

@@ -1,8 +1,7 @@
-/* 0.35.6 */
-export declare function expandProducts(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression | null;
+/* 0.50.1 */
 export declare function choose(n: number, k: number): number;
 /** Attempt to transform the expression (h, ops) into a sum */
-export declare function expandFunction(ce: ComputeEngine, h: string, ops: ReadonlyArray<BoxedExpression>): BoxedExpression | null;
+export declare function expandFunction(ce: ComputeEngine, h: string, ops: ReadonlyArray<Expression>): Expression | null;
 /** Apply the distributive law if the expression is a product of sums.
  * For example, a(b + c) = ab + ac
  * Expand the expression if it is a power of a sum.
@@ -11,10 +10,10 @@ export declare function expandFunction(ce: ComputeEngine, h: string, ops: Readon
  * If the exression is a relational operator, expand the operands.
  * Return null if the expression cannot be expanded.
  */
-export declare function expand(expr: BoxedExpression | undefined): BoxedExpression | null;
+export declare function expand(expr: Expression | undefined): Expression | null;
 /**
  * Recursive expand of all terms in the expression.
  *
  * `expand()` only expands the top level of the expression.
  */
-export declare function expandAll(expr: BoxedExpression): BoxedExpression | null;
+export declare function expandAll(expr: Expression): Expression | null;

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

@@ -1,12 +1,12 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare class ExpressionMap<U> implements ExpressionMapInterface<U> {
-    readonly _items: Map<BoxedExpression, U>;
-    constructor(source?: ExpressionMapInterface<U> | readonly (readonly [BoxedExpression, U])[]);
-    has(expr: BoxedExpression): boolean;
-    get(expr: BoxedExpression): U | undefined;
+    readonly _items: Map<Expression, U>;
+    constructor(source?: ExpressionMapInterface<U> | readonly (readonly [Expression, U])[]);
+    has(expr: Expression): boolean;
+    get(expr: Expression): U | undefined;
     clear(): void;
-    set(expr: BoxedExpression, value: U): void;
-    delete(expr: BoxedExpression): void;
-    [Symbol.iterator](): IterableIterator<[BoxedExpression, U]>;
-    entries(): IterableIterator<[BoxedExpression, U]>;
+    set(expr: Expression, value: U): void;
+    delete(expr: Expression): void;
+    [Symbol.iterator](): IterableIterator<[Expression, U]>;
+    entries(): IterableIterator<[Expression, U]>;
 }

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

@@ -1,6 +1,6 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /** Combine rational expressions into a single fraction */
-export declare function together(op: BoxedExpression): BoxedExpression;
+export declare function together(op: Expression): Expression;
 /**
  * Detect if an expression is a perfect square trinomial.
  * Returns the factored form (a±b)² if successful, null otherwise.
@@ -14,7 +14,7 @@ export declare function together(op: BoxedExpression): BoxedExpression;
  *
  * IMPORTANT: Does not call .simplify() to avoid infinite recursion.
  */
-export declare function factorPerfectSquare(expr: BoxedExpression): BoxedExpression | null;
+export declare function factorPerfectSquare(expr: Expression): Expression | null;
 /**
  * Detect if an expression is a difference of squares.
  * Returns the factored form (a-b)(a+b) if successful, null otherwise.
@@ -23,7 +23,7 @@ export declare function factorPerfectSquare(expr: BoxedExpression): BoxedExpress
  *
  * IMPORTANT: Does not call .simplify() on the result to avoid infinite recursion.
  */
-export declare function factorDifferenceOfSquares(expr: BoxedExpression): BoxedExpression | null;
+export declare function factorDifferenceOfSquares(expr: Expression): Expression | null;
 /**
  * Factor a quadratic polynomial using the quadratic formula.
  * Returns factored form if successful, null otherwise.
@@ -34,7 +34,7 @@ export declare function factorDifferenceOfSquares(expr: BoxedExpression): BoxedE
  *
  * IMPORTANT: Does not call .simplify() to avoid infinite recursion.
  */
-export declare function factorQuadratic(expr: BoxedExpression, variable: string): BoxedExpression | null;
+export declare function factorQuadratic(expr: Expression, variable: string): Expression | null;
 /**
  * Factor a polynomial expression.
  * Attempts various factoring strategies:
@@ -46,11 +46,11 @@ export declare function factorQuadratic(expr: BoxedExpression, variable: string)
  *
  * IMPORTANT: Does not call .simplify() to avoid infinite recursion.
  */
-export declare function factorPolynomial(expr: BoxedExpression, variable?: string): BoxedExpression;
+export declare function factorPolynomial(expr: Expression, variable?: string): Expression;
 /**
  * Return an expression factored as a product.
  * - 2x + 4 -> 2(x + 2)
  * - 2x < 4 -> x < 2
  * - (2x) * (2y) -> 4xy
  */
-export declare function factor(expr: BoxedExpression): BoxedExpression;
+export declare function factor(expr: Expression): Expression;

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

@@ -1,7 +1,7 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /**
  *
- * Make all the arguments canonical.
+ * Optionally make all the arguments canonical (default).
  *
  * "Lift" Sequence expressions to the top level.
  * e.g. `["Add", 1, ["Sequence", 2, 3]]` -> `["Add", 1, 2, 3]`
@@ -12,14 +12,5 @@
  *
  * Note: *not* recursive
  */
-export declare function flatten<T extends ReadonlyArray<BoxedExpression> | BoxedExpression[]>(ops: T, operator?: string): T;
-/**
- * Flatten the arguments.
- * @fixme replace with just flatten.
- * @fixme consider adding flatternSort()
- */
-export declare function flattenOps<T extends ReadonlyArray<BoxedExpression> | BoxedExpression[]>(ops: T, operator: string): T;
-/**
- * @todo: this function should probably not be recursive. As it, it is semi-recursive.
- */
-export declare function flattenSequence(xs: ReadonlyArray<BoxedExpression>): ReadonlyArray<BoxedExpression>;
+export declare function flatten<T extends ReadonlyArray<Expression> | Expression[]>(ops: T, operator?: string, canonicalize?: boolean): T;
+export declare function flattenSequence(xs: ReadonlyArray<Expression>): ReadonlyArray<Expression>;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /** Apply the function `f` to each operand of the expression `expr`,
  * account for the 'lazy' property of the operator definition:
  *
@@ -6,5 +6,5 @@
  *
  * If `f` returns `null`, the element is not added to the result
  */
-export declare function holdMap(expr: BoxedExpression, f: (x: BoxedExpression) => BoxedExpression | null): ReadonlyArray<BoxedExpression>;
-export declare function holdMapAsync(expr: BoxedExpression, f: (x: BoxedExpression) => Promise<BoxedExpression | null>): Promise<ReadonlyArray<BoxedExpression>>;
+export declare function holdMap(expr: Expression, f: (x: Expression) => Expression | null): ReadonlyArray<Expression>;
+export declare function holdMapAsync(expr: Expression, f: (x: Expression) => Promise<Expression | null>): Promise<ReadonlyArray<Expression>>;

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

@@ -0,0 +1,21 @@
+/* 0.50.1 */
+/**
+ * Get inequality bounds for a symbol from the assumption database.
+ *
+ * For example, if `x > 4` is assumed, this returns `{ lowerBound: 4, lowerStrict: true }`.
+ * If `x <= 10` is assumed, this returns `{ upperBound: 10, upperStrict: false }`.
+ *
+ * Note: Assumptions are normalized to forms like:
+ * - `x > 4` becomes `Less(Add(Negate(x), 4), 0)` i.e., `4 - x < 0`
+ * - `x > 0` becomes `Less(Negate(x), 0)` i.e., `-x < 0`
+ *
+ * @param ce - The compute engine instance
+ * @param symbol - The symbol name to query
+ * @returns An object with lowerBound, upperBound, and strictness flags
+ */
+export declare function getInequalityBoundsFromAssumptions(ce: ComputeEngine, symbol: string): {
+    lowerBound?: Expression;
+    lowerStrict?: boolean;
+    upperBound?: Expression;
+    upperStrict?: boolean;
+};

package/dist/types/compute-engine/boxed-expression/init-lazy-refs.d.ts

@@ -0,0 +1 @@
+/* 0.50.1 */

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

@@ -0,0 +1,4 @@
+/* 0.50.1 */
+export declare function canonicalInvisibleOperator(ops: ReadonlyArray<Expression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): Expression | null;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /**
  * The function attempts to match a subject expression to a
  * [pattern](/compute-engine/guides/patterns-and-rules/).
@@ -38,4 +38,4 @@
  * -->
  *
  */
-export declare function match(subject: BoxedExpression, pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+export declare function match(subject: Expression, pattern: Expression, options?: PatternMatchOptions): BoxedSubstitution | null;

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

@@ -1,5 +1,5 @@
-/* 0.35.6 */
-export declare function canonicalNegate(expr: BoxedExpression): BoxedExpression;
+/* 0.50.1 */
+export declare function canonicalNegate(expr: Expression): Expression;
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an
  * addition or multiplication or another `Negate`.
@@ -7,5 +7,5 @@ export declare function canonicalNegate(expr: BoxedExpression): BoxedExpression;
  * It is important to do all these to handle cases like
  * `-3x` -> ["Negate, ["Multiply", 3, "x"]] -> ["Multiply, -3, x]
  */
-export declare function negate(expr: BoxedExpression): BoxedExpression;
-export declare function negateProduct(ce: ComputeEngine, args: ReadonlyArray<BoxedExpression>): BoxedExpression;
+export declare function negate(expr: Expression): Expression;
+export declare function negateProduct(ce: ComputeEngine, args: ReadonlyArray<Expression>): Expression;

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

@@ -1,10 +1,10 @@
-/* 0.35.6 */
+/* 0.50.1 */
 import { Decimal } from 'decimal.js';
 import type { Rational } from '../numerics/types';
-import type { BoxedExpression, SemiBoxedExpression } from '../global-types';
-export declare function asRational(expr: BoxedExpression): Rational | undefined;
-export declare function asBigint(x: Complex | Decimal | SemiBoxedExpression | undefined): bigint | null;
-export declare function asBignum(expr: BoxedExpression | undefined): Decimal | null;
+import type { Expression, ExpressionInput } from '../global-types';
+export declare function asRational(expr: Expression): Rational | undefined;
+export declare function asBigint(x: Complex | Decimal | ExpressionInput | undefined): bigint | null;
+export declare function asBignum(expr: Expression | undefined): Decimal | null;
 /**
  * Validate if the expression is a small integer.
  * A small integer is an integer between -SMALL_INTEGER and SMALL_INTEGER (inclusive).
@@ -13,7 +13,7 @@ export declare function asBignum(expr: BoxedExpression | undefined): Decimal | n
  * Unlike `toInteger()` this functions fails if the expression is not an
  * integer. `toInteger()` will round the value to the nearest integer.
  */
-export declare function asSmallInteger(expr: number | BoxedExpression | undefined): number | null;
+export declare function asSmallInteger(expr: number | Expression | undefined): number | null;
 /**
  * Convert a boxed expression to an integer.
  * Returns null if the expression cannot be converted to an integer.
@@ -25,10 +25,10 @@ export declare function asSmallInteger(expr: number | BoxedExpression | undefine
  * value to the nearest integer if it is a number.
  *
  */
-export declare function toInteger(expr: BoxedExpression | undefined): number | null;
+export declare function toInteger(expr: Expression | undefined): number | null;
 /** Convert a boxed expression to a bigint.
  * Returns null if the expression cannot be converted to a bigint.
  * If the expression is a complex number, only the real part is considered.
  * If the real part is not an integer, it is rounded to the nearest integer.
  */
-export declare function toBigint(expr: BoxedExpression | undefined): bigint | null;
+export declare function toBigint(expr: Expression | undefined): bigint | null;

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

@@ -1,6 +1,7 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
-export declare const DEFAULT_COMPLEXITY = 100000;
+import { DEFAULT_COMPLEXITY } from './constants';
+export { DEFAULT_COMPLEXITY };
 /**
  * The sorting order of arguments of the Add function uses a modified degrevlex:
  * - Sort by total degree (sum of degree)
@@ -13,8 +14,8 @@ export declare const DEFAULT_COMPLEXITY = 100000;
  * - 2x^2 + 3x + 1
  * - 2x^2y^3 + 5x^3y
  */
-export declare function addOrder(a: BoxedExpression, b: BoxedExpression): number;
-export declare function equalOrder(a: BoxedExpression, b: BoxedExpression): number;
+export declare function addOrder(a: Expression, b: Expression): number;
+export declare function equalOrder(a: Expression, b: Expression): number;
 declare const RANKS: readonly ["integer", "rational", "radical", "real", "complex", "constant", "symbol", "multiply", "divide", "add", "trig", "fn", "power", "string", "other"];
 export type Rank = (typeof RANKS)[number];
 /**
@@ -50,22 +51,21 @@ export type Rank = (typeof RANKS)[number];
  * description of the ordering of expressions in Mathematica.
  *
  */
-export declare function order(a: BoxedExpression, b: BoxedExpression): number;
+export declare function order(a: Expression, b: Expression): number;
 /** Return a version of the expression with its arguments sorted in
  * canonical order
  */
-export declare function canonicalOrder(expr: BoxedExpression, { recursive }: {
+export declare function canonicalOrder(expr: Expression, { recursive }: {
     recursive?: boolean;
-}): BoxedExpression;
-export declare function sortOperands(operator: string, xs: ReadonlyArray<BoxedExpression>): ReadonlyArray<BoxedExpression>;
+}): Expression;
+export declare function sortOperands(operator: string, xs: ReadonlyArray<Expression>): ReadonlyArray<Expression>;
 /**
  * Sort the terms of a polynomial expression (`Add` expression) according
  * to the deglex polynomial ordering
  *
  */
-export declare function polynomialOrder(expr: BoxedExpression): BoxedExpression;
-export declare function lexicographicOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): BoxedExpression;
-export declare function degreeLexicographicOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): BoxedExpression;
-export declare function degreeReverseLexicographicOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): BoxedExpression;
-export declare function eliminationOrder(expr: BoxedExpression, vars?: ReadonlyArray<string>): BoxedExpression;
-export {};
+export declare function polynomialOrder(expr: Expression): Expression;
+export declare function lexicographicOrder(expr: Expression, vars?: ReadonlyArray<string>): Expression;
+export declare function degreeLexicographicOrder(expr: Expression, vars?: ReadonlyArray<string>): Expression;
+export declare function degreeReverseLexicographicOrder(expr: Expression, vars?: ReadonlyArray<string>): Expression;
+export declare function eliminationOrder(expr: Expression, vars?: ReadonlyArray<string>): Expression;