@cortex-js/compute-engine 0.29.1 → 0.30.1

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

@@ -1,27 +1,31 @@
-/* 0.29.1 */
-import type { SimplifyOptions, ReplaceOptions, PatternMatchOptions, BoxedExpression, BoxedBaseDefinition, BoxedFunctionDefinition, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, EvaluateOptions, ComputeEngine, Metadata, Rule, RuntimeScope, Sign, Substitution } from '../global-types';
-import { NumericValue } from '../numeric-value/types';
-import { _BoxedExpression } from './abstract-boxed-expression';
+/* 0.30.1 */
+import type { SimplifyOptions, ReplaceOptions, PatternMatchOptions, BoxedExpression, BoxedBaseDefinition, BoxedOperatorDefinition, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, EvaluateOptions, ComputeEngine, Metadata, Rule, Sign, Substitution, Scope, BoxedValueDefinition } from '../global-types';
 import { Type } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';
+import { NumericValue } from '../numeric-value/types';
+import { _BoxedExpression } from './abstract-boxed-expression';
 /**
- * A boxed function represent an expression that can be represented by a
- * function call.
+ * A boxed function expression represent an expression composed of an operator
+ * (the name of the function) and a list of arguments. For example:
+ * `["Add", 1, 2]` is a function expression with the operator "Add" and two
+ * arguments 1 and 2.
  *
- * It is composed of an operator (the name of the function) and a list of
- * arguments.
+ * If canonical, it has a definition associated with it, based on the operator.
  *
- * It has a definition associated with it, based on the operator.
- * The definition contains the signature of the function, and the
- * implementation of the function.
+ * The definition contains its signature and its evaluation handler.
  *
  */
 export declare class BoxedFunction extends _BoxedExpression {
-    private readonly _name;
+    private readonly _operator;
     private readonly _ops;
-    private _canonical;
-    private _scope;
-    _def: BoxedFunctionDefinition | undefined;
+    private _def;
+    /** @todo: wrong. If the function is scoped (has its own lexical scope), the captured eval context. This includes the lexical scope for this expression
+     */
+    private _capturedContext;
+    /** If the operator is scoped, the local scope associated with
+     * the function expression
+     */
+    private _localScope;
     private _isPure;
     private _isStructural;
     private _hash;
@@ -29,35 +33,47 @@ export declare class BoxedFunction extends _BoxedExpression {
     private _valueN;
     private _sgn;
     private _type;
-    constructor(ce: ComputeEngine, name: string, ops: ReadonlyArray<BoxedExpression>, options?: {
+    constructor(ce: ComputeEngine, operator: string, ops: ReadonlyArray<BoxedExpression>, options?: {
         metadata?: Metadata;
         canonical?: boolean;
         structural?: boolean;
+        scope?: Scope;
     });
     get hash(): number;
-    infer(t: Type): boolean;
+    /**
+     * For function expressions, `infer()` infers the result type of the function
+     * based on the provided type and inference mode.
+     */
+    infer(t: Type, inferenceMode?: 'narrow' | 'widen'): boolean;
     bind(): void;
     reset(): void;
+    get value(): BoxedExpression | undefined;
     get isCanonical(): boolean;
-    set isCanonical(val: boolean);
     get isPure(): boolean;
-    /** The value of the function is constant if the function is
-     * pure, and all its arguments are constant.
-     */
     get isConstant(): boolean;
+    get constantValue(): number | boolean | string | object | undefined;
     get json(): Expression;
-    get scope(): RuntimeScope | null;
     get operator(): string;
     get ops(): ReadonlyArray<BoxedExpression>;
     get nops(): number;
     get op1(): BoxedExpression;
     get op2(): BoxedExpression;
     get op3(): BoxedExpression;
+    get isScoped(): boolean;
+    get localScope(): Scope | undefined;
     get isValid(): boolean;
+    /** Note: if the expression is not canonical, this will return a canonical
+     * version of the expression in the current lexical scope.
+     */
     get canonical(): BoxedExpression;
     get structural(): BoxedExpression;
     get isStructural(): boolean;
     toNumericValue(): [NumericValue, BoxedExpression];
+    /**
+     * Note: the result is bound to the current scope, not the scope of the
+     * original expression.
+     * <!-- This may or may not be desirable -->
+     */
     subs(sub: Substitution, options?: {
         canonical?: CanonicalOptions;
     }): BoxedExpression;
@@ -89,7 +105,8 @@ export declare class BoxedFunction extends _BoxedExpression {
     ln(semiBase?: number | BoxedExpression): BoxedExpression;
     get complexity(): number | undefined;
     get baseDefinition(): BoxedBaseDefinition | undefined;
-    get functionDefinition(): BoxedFunctionDefinition | undefined;
+    get operatorDefinition(): BoxedOperatorDefinition | undefined;
+    get valueDefinition(): BoxedValueDefinition | undefined;
     get isNumber(): boolean | undefined;
     get isInteger(): boolean | undefined;
     get isRational(): boolean | undefined;
@@ -103,12 +120,16 @@ export declare class BoxedFunction extends _BoxedExpression {
     N(): BoxedExpression;
     solve(vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
     get isCollection(): boolean;
-    contains(rhs: BoxedExpression): boolean;
-    get size(): number;
-    each(start?: number, count?: number): Iterator<BoxedExpression, undefined>;
+    get isIndexedCollection(): boolean;
+    get isLazyCollection(): boolean;
+    xcontains(rhs: BoxedExpression): boolean | undefined;
+    get xsize(): number | undefined;
+    get isEmptyCollection(): boolean | undefined;
+    get isFiniteCollection(): boolean | undefined;
+    each(): Generator<BoxedExpression>;
     at(index: number): BoxedExpression | undefined;
     get(index: BoxedExpression | string): BoxedExpression | undefined;
-    indexOf(expr: BoxedExpression): number;
+    indexWhere(predicate: (element: BoxedExpression) => boolean): number | undefined;
     subsetOf(rhs: BoxedExpression, strict: boolean): boolean;
     _computeValue(options?: Partial<EvaluateOptions>): () => BoxedExpression;
     _computeValueAsync(options?: Partial<EvaluateOptions>): () => Promise<BoxedExpression>;

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

@@ -1,6 +1,6 @@
-/* 0.29.1 */
+/* 0.30.1 */
 import { Decimal } from 'decimal.js';
-import type { Expression, MathJsonNumber } from '../../math-json';
+import type { Expression, MathJsonNumberObject } from '../../math-json';
 import type { Rational, SmallInteger } from '../numerics/types';
 import { ExactNumericValueData, NumericValue, NumericValueData } from '../numeric-value/types';
 import { _BoxedExpression } from './abstract-boxed-expression';
@@ -27,7 +27,6 @@ export declare class BoxedNumber extends _BoxedExpression {
      */
     constructor(ce: ComputeEngine, value: SmallInteger | NumericValueData | ExactNumericValueData | NumericValue, options?: {
         metadata?: Metadata;
-        canonical?: boolean;
     });
     get hash(): number;
     get json(): Expression;
@@ -36,6 +35,18 @@ export declare class BoxedNumber extends _BoxedExpression {
     get isCanonical(): boolean;
     set isCanonical(val: boolean);
     get complexity(): number;
+    /**
+     *
+     * Return a JavaScript number when possible (most cases); else return a
+     * string representation of the number (ComplexInfinity and complex numbers
+     * for example).
+     *
+     * When a JavaScript number is returned, it may have fewer digits than the
+     * original number, but it will be a close approximation.
+     *
+     * @returns {number | string} The value of the number.
+     */
+    valueOf(): number | string;
     get numericValue(): number | NumericValue;
     get isNumberLiteral(): boolean;
     get re(): number;
@@ -52,6 +63,7 @@ export declare class BoxedNumber extends _BoxedExpression {
     root(exp: number | BoxedExpression): BoxedExpression;
     sqrt(): BoxedExpression;
     ln(semiBase?: number | BoxedExpression): BoxedExpression;
+    get value(): BoxedExpression;
     get type(): BoxedType;
     get sgn(): Sign | undefined;
     get numerator(): BoxedExpression;
@@ -79,7 +91,7 @@ export declare class BoxedNumber extends _BoxedExpression {
     get isInteger(): boolean;
     get isRational(): boolean;
     get isReal(): boolean;
-    is(rhs: any): boolean;
+    is(other: BoxedExpression | number | bigint | boolean): boolean;
     get canonical(): BoxedExpression;
     get isStructural(): boolean;
     get structural(): BoxedExpression;
@@ -88,4 +100,4 @@ export declare class BoxedNumber extends _BoxedExpression {
     evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
     N(): BoxedExpression;
 }
-export declare function canonicalNumber(ce: ComputeEngine, value: number | bigint | string | Decimal | Complex | Rational | NumericValue | MathJsonNumber): number | NumericValue;
+export declare function canonicalNumber(ce: ComputeEngine, value: number | bigint | string | Decimal | Complex | Rational | NumericValue | MathJsonNumberObject): number | NumericValue;

package/dist/types/compute-engine/boxed-expression/{boxed-function-definition.d.ts → boxed-operator-definition.d.ts}

@@ -1,14 +1,13 @@
-/* 0.29.1 */
-import { OneOf } from '../../common/one-of';
+/* 0.30.1 */
 import { BoxedType } from '../../common/type/boxed-type';
-import type { FunctionDefinition, BoxedExpression, BoxedFunctionDefinition, CollectionHandlers, CompiledExpression, EvaluateOptions, ComputeEngine, RuntimeScope, Sign } from '../global-types';
-export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition {
+import type { OperatorDefinition, BoxedExpression, BoxedOperatorDefinition, CollectionHandlers, CompiledExpression, EvaluateOptions, ComputeEngine, Sign } from '../global-types';
+export declare class _BoxedOperatorDefinition implements BoxedOperatorDefinition {
     engine: ComputeEngine;
-    scope: RuntimeScope;
     name: string;
     description?: string | string[];
+    url?: string;
     wikidata?: string;
-    threadable: boolean;
+    broadcastable: boolean;
     associative: boolean;
     commutative: boolean;
     commutativeOrder: ((a: BoxedExpression, b: BoxedExpression) => number) | undefined;
@@ -17,6 +16,7 @@ export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition
     pure: boolean;
     complexity: number;
     lazy: boolean;
+    scoped: boolean;
     signature: BoxedType;
     inferredSignature: boolean;
     type?: (ops: ReadonlyArray<BoxedExpression>, options: {
@@ -43,11 +43,11 @@ export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition
         engine: ComputeEngine;
     }) => BoxedExpression;
     compile?: (expr: BoxedExpression) => CompiledExpression;
-    collection?: Partial<CollectionHandlers>;
-    constructor(ce: ComputeEngine, name: string, def: FunctionDefinition);
+    collection?: CollectionHandlers;
+    constructor(ce: ComputeEngine, name: string, def: OperatorDefinition);
+    /** For debugging */
+    toJSON(): any;
     infer(sig: Type): void;
-    update(def: FunctionDefinition): void;
-    reset(): void;
+    update(def: OperatorDefinition): void;
+    onConfigurationChange(): void;
 }
-export declare function makeFunctionDefinition(engine: ComputeEngine, name: string, def: OneOf<[FunctionDefinition | BoxedFunctionDefinition]>): BoxedFunctionDefinition;
-export declare function isBoxedFunctionDefinition(x: any): x is BoxedFunctionDefinition;

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 import type { BoxedExpression } from '../global-types';
 export declare function isWildcard(expr: BoxedExpression): expr is BoxedSymbol;
 export declare function wildcardName(expr: BoxedExpression): string | null;

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedType } from '../../common/type/boxed-type';
 /**
@@ -6,7 +6,10 @@ import { BoxedType } from '../../common/type/boxed-type';
  *
  */
 export declare class BoxedString extends _BoxedExpression {
+    [Symbol.toStringTag]: string;
     private readonly _string;
+    private _utf8Buffer?;
+    private _unicodeScalarValues?;
     constructor(ce: ComputeEngine, expr: string, metadata?: Metadata);
     get json(): string;
     get hash(): number;
@@ -14,15 +17,11 @@ export declare class BoxedString extends _BoxedExpression {
     get isPure(): boolean;
     get isCanonical(): boolean;
     set isCanonical(_va: boolean);
+    get value(): BoxedExpression;
     get type(): BoxedType;
     get complexity(): number;
     get string(): string;
+    get buffer(): Uint8Array;
+    get unicodeScalars(): number[];
     match(pattern: BoxedExpression, _options?: PatternMatchOptions): BoxedSubstitution | null;
-    get isCollection(): boolean;
-    contains(rhs: BoxedExpression): boolean;
-    get size(): number;
-    each(start?: number, count?: number): Iterator<BoxedExpression, undefined>;
-    at(index: number): BoxedExpression | undefined;
-    get(key: string | BoxedExpression): BoxedExpression | undefined;
-    indexOf(expr: BoxedExpression): number;
 }

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

@@ -1,58 +1,62 @@
-/* 0.29.1 */
-import type { Expression } from '../../math-json/types';
+/* 0.30.1 */
 import type { Type, TypeString } from '../../common/type/types';
-import type { BoxedExpression, SimplifyOptions, PatternMatchOptions, ReplaceOptions, RuntimeScope, BoxedSymbolDefinition, BoxedFunctionDefinition, ComputeEngine, Metadata, CanonicalOptions, BoxedBaseDefinition, BoxedSubstitution, EvaluateOptions, Rule, BoxedRule, BoxedRuleSet, Substitution, Sign } from '../global-types';
-import { NumericValue } from '../numeric-value/types';
-import { _BoxedExpression } from './abstract-boxed-expression';
-import type { BigNum } from '../numerics/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 { _BoxedExpression } from './abstract-boxed-expression';
 /**
- * BoxedSymbol
+ * ### BoxedSymbol
+ *
+ * A boxed symbol is a reference to a `BoxedDefinition`.
+ *
+ * A `BoxedDefinition` "owns" all the information about a symbol, its
+ * type and various attributes (is it a constant?, etc...).
  *
- * A boxed symbol is a reference to a `BoxedSymbolDefinition` or a
- * `BoxedFunctionDefinition`.
+ * Boxed symbols are bound to a definition during construction if they
+ * are canonical.
  *
- * If a `BoxedSymbolDefinition`, it "owns" all the information
- * about the symbol, its value, domain and various attributes.
+ * If a symbol is not canonical (and thus not bound to a definition),
+ * some properties and methods will return `undefined`, for example
+ * `isInteger`, `isRational`, `isReal`, etc...
  *
- * If a `BoxedFunctionDefinition`, it it a reference to a function name,
- * not a function expression, i.e. `Sin`, not `["Sin", "Pi"]`. This is used
- * for example in `["InverseFunction", "Sin"]`
+ * There is a single value definition for each symbol but the value of a
+ * symbol can be different in different evaluation contexts, for example
+ * a local variable during a recursion.
  *
+ * The value of a symbol is tracked in the evaluation context and
+ * not in the value definition.
+ *
+ * The `value` property of a boxed symbol is the value of the symbol
+ * in the current evaluation context. It is `undefined` if the symbol
+ * is not bound to a definition or if the value is not known (a bound
+ * symbol may have no value).
  *
  */
 export declare class BoxedSymbol extends _BoxedExpression {
-    private _scope;
-    protected _id: string;
     private _hash;
-    private _def;
-    private _isStructural;
-    constructor(ce: ComputeEngine, name: string, options?: {
+    /** The name of the symbol */
+    protected _id: MathJsonSymbol;
+    /**
+     * The definition of the symbol, if the symbol is bound/canonical.
+     */
+    private readonly _def;
+    /** Note: to indicate that the symbol should be canonical, pass a def. */
+    constructor(ce: ComputeEngine, name: MathJsonSymbol, options?: {
         metadata?: Metadata;
-        canonical?: CanonicalOptions;
-        structural?: boolean;
-        def?: OneOf<[BoxedSymbolDefinition, BoxedFunctionDefinition]>;
+        def?: BoxedDefinition;
     });
     get json(): Expression;
     get hash(): number;
     get isPure(): boolean;
-    get isStructural(): boolean;
-    get structural(): BoxedExpression;
-    get scope(): RuntimeScope | null;
     get isConstant(): boolean;
-    private _lookupDef;
-    /** This method returns the definition associated with the value of this symbol, or associated with the symbol if it has no value. This is the definition to use with most operations on the symbol. Indeed, "x[2]" is accessing the second element of **the value** of "x".*/
-    private _getDef;
-    /**
-     * Associate a definition with this symbol
-     */
     bind(): void;
     reset(): void;
     get isCanonical(): boolean;
     set isCanonical(val: boolean);
-    is(rhs: any): boolean;
     get canonical(): BoxedExpression;
+    is(other: any): boolean;
     toNumericValue(): [NumericValue, BoxedExpression];
     neg(): BoxedExpression;
     inv(): BoxedExpression;
@@ -66,20 +70,40 @@ export declare class BoxedSymbol extends _BoxedExpression {
     ln(semiBase?: number | BoxedExpression): BoxedExpression;
     solve(vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
     get complexity(): number;
-    get operator(): string;
-    get symbol(): string;
+    get operator(): MathJsonSymbol;
+    get symbol(): MathJsonSymbol;
     get baseDefinition(): BoxedBaseDefinition | undefined;
-    get symbolDefinition(): BoxedSymbolDefinition | undefined;
-    get functionDefinition(): BoxedFunctionDefinition | undefined;
+    get valueDefinition(): BoxedValueDefinition | undefined;
+    get operatorDefinition(): BoxedOperatorDefinition | undefined;
     /**
-     * Subsequent inferences will narrow the domain of the symbol.
-     * f: integer -> real, g: real -> real
-     * g(x) => x: real
-     * f(x) => x: integer narrowed from integer to real
+     *
+     * Assuming the symbol is used as an argument, subsequent inferences will
+     * narrow the domain of the symbol:
+     *
+     * ```
+     * f: real -> number, g: integer -> number
+     * f(x) => x: inferred to real
+     * g(x) => x: narrowed to integer
+     * ```
+     *
+     * If the symbol is used as a return value, its domain should be widened:
+     *
+     * ```
+     * f: number -> integer, g: number -> real
+     * x = f(2) => x: inferred to integer
+     * x = g(2) => x: widened to real
+     * ```
+     *
+     * Arguments accumulate constraints and narrow.
+     * Return values accumulate possibilities and widen.
+     *
+     * @inheritdoc
      */
-    infer(t: Type): boolean;
-    get value(): number | boolean | string | object | undefined;
-    set value(value: boolean | string | Decimal | number[] | OneOf<[
+    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;
+    set value(value: boolean | string | BigNum | number[] | OneOf<[
         {
             re: number;
             im: number;
@@ -89,21 +113,32 @@ export declare class BoxedSymbol extends _BoxedExpression {
             denom: number;
         },
         BoxedExpression
-    ]> | number | object | undefined);
+    ]> | number | undefined);
+    /**
+     * The type of the symbol.
+     *
+     * Note that the type of the value of the symbol may be more specific.'
+     * For example, a symbol could have a type of 'number' but the value
+     * could be 'integer'.
+     *
+     * If the symbol is not canonical (not bound to a definition), the type is
+     * 'unknown'
+     */
     get type(): BoxedType;
     set type(t: Type | TypeString | BoxedType);
-    get sgn(): Sign | undefined;
-    has(x: string | string[]): boolean;
+    has(x: MathJsonSymbol | MathJsonSymbol[]): boolean;
     match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
-    get isFunction(): boolean | undefined;
+    get sgn(): Sign | undefined;
     get isOdd(): boolean | undefined;
     get isEven(): boolean | undefined;
+    get isFinite(): boolean | undefined;
     get isInfinity(): boolean | undefined;
     get isNaN(): boolean | undefined;
     get isPositive(): boolean | undefined;
     get isNonPositive(): boolean | undefined;
     get isNegative(): boolean | undefined;
     get isNonNegative(): boolean | undefined;
+    get isFunction(): boolean | undefined;
     get isNumber(): boolean | undefined;
     get isInteger(): boolean | undefined;
     get isRational(): boolean | undefined;
@@ -119,13 +154,17 @@ export declare class BoxedSymbol extends _BoxedExpression {
     subs(sub: Substitution, options?: {
         canonical?: CanonicalOptions;
     }): BoxedExpression;
+    get _asCollection(): CollectionHandlers | undefined;
     get isCollection(): boolean;
-    contains(rhs: BoxedExpression): boolean;
-    get size(): number;
-    each(start?: number, count?: number): Iterator<BoxedExpression, undefined>;
+    get isIndexedCollection(): boolean;
+    get isLazyCollection(): boolean;
+    xcontains(rhs: BoxedExpression): boolean | undefined;
+    get xsize(): number;
+    get isEmptyCollection(): boolean;
+    get isFiniteCollection(): boolean | undefined;
+    each(): Generator<BoxedExpression>;
     at(index: number): BoxedExpression | undefined;
     get(index: BoxedExpression | string): BoxedExpression | undefined;
-    indexOf(expr: BoxedExpression): number;
+    indexWhere(predicate: (element: BoxedExpression) => boolean): number | undefined;
     subsetOf(rhs: BoxedExpression, strict: boolean): boolean;
 }
-export declare function makeCanonicalSymbol(ce: ComputeEngine, name: string): BoxedExpression;

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

@@ -1,9 +1,8 @@
-/* 0.29.1 */
+/* 0.30.1 */
+import type { ComputeEngine, TensorDataType, Metadata, BoxedBaseDefinition, BoxedOperatorDefinition, BoxedSubstitution, EvaluateOptions, BoxedExpression, SimplifyOptions, PatternMatchOptions, Tensor } from '../global-types';
+import { BoxedType } from '../../common/type/boxed-type';
 import { NumericValue } from '../numeric-value/types';
 import { _BoxedExpression } from './abstract-boxed-expression';
-import { AbstractTensor } from '../tensor/tensors';
-import { BoxedType } from '../../common/type/boxed-type';
-import type { ComputeEngine, TensorDataType, Metadata, BoxedBaseDefinition, BoxedFunctionDefinition, BoxedSubstitution, EvaluateOptions, TensorData, BoxedExpression, SimplifyOptions, PatternMatchOptions } from '../global-types';
 /**
  * A boxed tensor represents an expression that can be represented by a tensor.
  * This could be a vector, matrix or multi-dimensional array.
@@ -15,33 +14,32 @@ import type { ComputeEngine, TensorDataType, Metadata, BoxedBaseDefinition, Boxe
  * if input is expression) is created lazily.
  *
  */
-export declare class BoxedTensor extends _BoxedExpression {
+export declare class BoxedTensor<T extends TensorDataType> extends _BoxedExpression {
+    readonly input: {
+        ops: ReadonlyArray<BoxedExpression>;
+        shape: number[];
+        dtype: T;
+    };
     readonly options?: {
         metadata?: Metadata;
-        canonical?: boolean;
     };
     private _tensor;
-    private readonly _operator?;
-    private readonly _ops?;
-    private _expression;
+    private _expression?;
     constructor(ce: ComputeEngine, input: {
-        op?: string;
         ops: ReadonlyArray<BoxedExpression>;
-    } | AbstractTensor<'expression'>, options?: {
+        shape: number[];
+        dtype: T;
+    }, options?: {
         metadata?: Metadata;
-        canonical?: boolean;
     });
     get structural(): BoxedExpression;
     /** Create the tensor on demand */
-    get tensor(): AbstractTensor<'expression'>;
+    get tensor(): Tensor<T>;
     get baseDefinition(): BoxedBaseDefinition | undefined;
-    get functionDefinition(): BoxedFunctionDefinition | undefined;
-    bind(): void;
-    reset(): void;
+    get operatorDefinition(): BoxedOperatorDefinition | undefined;
     get hash(): number;
     get canonical(): BoxedExpression;
     get isCanonical(): boolean;
-    set isCanonical(val: boolean);
     get isPure(): boolean;
     get isValid(): boolean;
     get complexity(): number;
@@ -68,19 +66,18 @@ export declare class BoxedTensor extends _BoxedExpression {
     /** Mathematical equality */
     isEqual(rhs: number | BoxedExpression): boolean | undefined;
     get isCollection(): boolean;
-    contains(rhs: BoxedExpression): boolean;
-    get size(): number;
-    each(start?: number, count?: number): Iterator<BoxedExpression, undefined>;
-    at(_index: number): BoxedExpression | undefined;
-    indexOf(_expr: BoxedExpression): number;
+    get isIndexedCollection(): boolean;
+    xcontains(other: BoxedExpression): boolean | undefined;
+    get xsize(): 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;
 }
-export declare function isBoxedTensor(val: unknown): val is BoxedTensor;
+export declare function isBoxedTensor(val: unknown): val is BoxedTensor<any>;
 export declare function expressionTensorInfo(operator: string, rows: ReadonlyArray<BoxedExpression>): {
     shape: number[];
-    dtype: TensorDataType | undefined;
+    dtype: TensorDataType;
 } | undefined;
-export declare function expressionAsTensor<T extends TensorDataType = 'expression'>(operator: string, rows: ReadonlyArray<BoxedExpression>): TensorData<T> | undefined;

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

@@ -0,0 +1,46 @@
+/* 0.30.1 */
+import type { Type, TypeString } from '../../common/type/types';
+import { BoxedType } from '../../common/type/boxed-type';
+import { ConfigurationChangeListener } from '../../common/configuration-change';
+/**
+ * ### THEORY OF OPERATIONS
+ *
+ * - The value in the definition is the initial value of the symbol when
+ *   entering an evaluation context. Unless it is a constant, it is not the
+ *   value of the symbol itself, which is stored in the evaluation context.
+ *
+ * - The value or type of a constant cannot be changed.
+ *
+ * - When the type is changed, the value is preserved if it is compatible
+ *   with the new type, otherwise it is reset to no value.
+ *
+ * - When the value is changed, the type is unaffected. If the value is not
+ *   compatible with the type (setting a def with a numeric type to a value
+ *   of `True` for example), the value is discarded.
+ *
+ */
+export declare class _BoxedValueDefinition implements BoxedValueDefinition, ConfigurationChangeListener {
+    readonly name: string; /** Used for debugging and error messages */
+    wikidata?: string;
+    description?: string | string[];
+    url?: string;
+    private _engine;
+    private _defValue?;
+    private _value;
+    private _type;
+    inferredType: boolean;
+    _isConstant: boolean;
+    holdUntil: 'never' | 'evaluate' | 'N';
+    eq?: (a: BoxedExpression) => boolean | undefined;
+    neq?: (a: BoxedExpression) => boolean | undefined;
+    cmp?: (a: BoxedExpression) => '=' | '>' | '<' | undefined;
+    collection?: CollectionHandlers;
+    constructor(ce: ComputeEngine, name: string, def: Partial<ValueDefinition>);
+    /** For debugging */
+    toJSON(): any;
+    get isConstant(): boolean;
+    get value(): BoxedExpression | 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.29.1 */
+/* 0.30.1 */
     value: T | null;
     generation: number | undefined;
 };

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 /**
  * Structural equality of boxed expressions.
  */

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.1 */
 export declare function expandProducts(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression | null;
 export declare function choose(n: number, k: number): number;
 /** Attempt to transform the expression (h, ops) into a sum */