@cortex-js/compute-engine 0.25.1 → 0.26.2

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

@@ -1,19 +1,20 @@
-/* 0.25.1 */
+/* 0.26.2 */
 import { Decimal } from 'decimal.js';
-import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, NOptions, PatternMatchOptions, SimplifyOptions, BoxedSubstitution, EvaluateOptions, SemiBoxedExpression } from '../public';
+import type { BoxedExpression, IComputeEngine, Metadata, PatternMatchOptions, BoxedSubstitution, EvaluateOptions, BoxedRuleSet, ReplaceOptions, Rule, Substitution, CanonicalOptions, SimplifyOptions, Sign } from '../public';
+import type { Expression, MathJsonNumber } from '../../math-json';
+import { SmallInteger } from '../numerics/numeric';
 import { Rational } from '../numerics/rationals';
+import { ExactNumericValueData, NumericValue, NumericValueData } from '../numeric-value/public';
 import { _BoxedExpression } from './abstract-boxed-expression';
-import { Expression } from '../../math-json';
+import { Type } from '../../common/type/types';
 /**
  * BoxedNumber
  *
  * @noInheritDoc
  */
 export declare class BoxedNumber extends _BoxedExpression {
-    protected readonly _value: number | Decimal | Complex | Rational;
-    private _domain;
+    protected readonly _value: SmallInteger | NumericValue;
     private _hash;
-    protected _isCanonical: boolean;
     /**
      * By the time the constructor is called, the `value` should have been
      * screened for cases where it's a well-known value (0, NaN, +Infinity,
@@ -26,33 +27,43 @@ export declare class BoxedNumber extends _BoxedExpression {
      * We may store as a machine number if a Decimal is passed that is in machine
      * range
      */
-    constructor(ce: IComputeEngine, value: number | Decimal | Complex | Rational, options?: {
+    constructor(ce: IComputeEngine, value: SmallInteger | NumericValueData | ExactNumericValueData | NumericValue, options?: {
         metadata?: Metadata;
         canonical?: boolean;
     });
     get hash(): number;
     get json(): Expression;
-    get head(): string;
+    get operator(): string;
     get isPure(): boolean;
-    get isExact(): boolean;
     get isCanonical(): boolean;
     set isCanonical(val: boolean);
     get complexity(): number;
-    get numericValue(): number | Decimal | Complex | Rational;
-    get domain(): BoxedDomain;
-    get sgn(): -1 | 0 | 1 | undefined | null;
-    isSame(rhs: BoxedExpression): boolean;
-    isEqual(rhs: BoxedExpression): boolean;
-    match(pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
-    /** Compare this with another BoxedNumber.
-     * `rhs` must be a BoxedNumber. Use `isEqualWithTolerance(rhs.N())`
-     * if necessary.
-     */
-    isEqualWithTolerance(rhs: BoxedExpression, tolerance: number): boolean;
-    isLess(rhs: BoxedExpression): boolean | undefined;
-    isLessEqual(rhs: BoxedExpression): boolean | undefined;
-    isGreater(rhs: BoxedExpression): boolean | undefined;
-    isGreaterEqual(rhs: BoxedExpression): boolean | undefined;
+    get numericValue(): number | NumericValue;
+    get isNumberLiteral(): boolean;
+    get re(): number;
+    get im(): number;
+    get bignumRe(): Decimal | undefined;
+    get bignumIm(): Decimal | undefined;
+    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(exp: number | BoxedExpression): BoxedExpression;
+    sqrt(): BoxedExpression;
+    ln(semiBase?: number | BoxedExpression): BoxedExpression;
+    get type(): Type;
+    get sgn(): Sign | undefined;
+    get numerator(): BoxedExpression;
+    get denominator(): BoxedExpression;
+    get numeratorDenominator(): [BoxedExpression, BoxedExpression];
+    subs(sub: Substitution, options?: {
+        canonical?: CanonicalOptions;
+    }): BoxedExpression;
+    replace(rules: BoxedRuleSet | Rule | Rule[], options?: Partial<ReplaceOptions>): BoxedExpression | null;
+    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
     /** x > 0, same as `isGreater(0)` */
     get isPositive(): boolean | undefined;
     /** x >= 0, same as `isGreaterEqual(0)` */
@@ -61,28 +72,22 @@ export declare class BoxedNumber extends _BoxedExpression {
     get isNegative(): boolean | undefined;
     /** x <= 0, same as `isLessEqual(0)` */
     get isNonPositive(): boolean | undefined;
-    get isZero(): boolean;
-    get isNotZero(): boolean;
-    get isOne(): boolean;
-    get isNegativeOne(): boolean;
     get isOdd(): boolean | undefined;
     get isEven(): boolean | undefined;
-    get isPrime(): boolean | undefined;
-    get isComposite(): boolean | undefined;
     get isInfinity(): boolean;
     get isNaN(): boolean;
     get isFinite(): boolean;
     get isNumber(): true;
     get isInteger(): boolean;
     get isRational(): boolean;
-    get isAlgebraic(): boolean | undefined;
     get isReal(): boolean;
-    get isExtendedReal(): boolean;
-    get isComplex(): boolean | undefined;
-    get isImaginary(): boolean | undefined;
-    get isExtendedComplex(): boolean | undefined;
+    is(rhs: any): boolean;
     get canonical(): BoxedExpression;
-    simplify(_options?: SimplifyOptions): BoxedExpression;
+    get isStructural(): boolean;
+    get structural(): BoxedExpression;
+    toNumericValue(): [NumericValue, BoxedExpression];
+    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
     evaluate(options?: EvaluateOptions): BoxedExpression;
-    N(_options?: NOptions): BoxedExpression;
+    N(): BoxedExpression;
 }
+export declare function canonicalNumber(ce: IComputeEngine, value: number | bigint | string | Decimal | Complex | Rational | NumericValue | MathJsonNumber): number | NumericValue;

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

@@ -1,4 +1,4 @@
-/* 0.25.1 */
-import { BoxedExpression } from './public';
+/* 0.26.2 */
+import type { BoxedExpression } from './public';
 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,7 +1,6 @@
-/* 0.25.1 */
-import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, PatternMatchOptions, BoxedSubstitution, SemiBoxedExpression } from './public';
-import Complex from 'complex.js';
-import Decimal from 'decimal.js';
+/* 0.26.2 */
+import { _BoxedExpression } from './abstract-boxed-expression';
+import { Type } from '../../common/type/types';
 /**
  * BoxedString
  *
@@ -12,14 +11,19 @@ export declare class BoxedString extends _BoxedExpression {
     constructor(ce: IComputeEngine, expr: string, metadata?: Metadata);
     get json(): string;
     get hash(): number;
-    get head(): string;
+    get operator(): string;
     get isPure(): boolean;
     get isCanonical(): boolean;
     set isCanonical(_va: boolean);
-    get domain(): BoxedDomain;
+    get type(): Type;
     get complexity(): number;
     get string(): string;
-    isEqual(rhs: BoxedExpression): boolean;
-    isSame(rhs: BoxedExpression): boolean;
-    match(pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, _options?: PatternMatchOptions): BoxedSubstitution | null;
+    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-definition.d.ts

@@ -1,21 +1,28 @@
-/* 0.25.1 */
+/* 0.26.2 */
+import { Type } from '../../common/type/types';
 /**
  * ### THEORY OF OPERATIONS
  *
- * - The value or domain of a constant cannot be changed.
+ * - The value or type of a constant cannot be changed.
+ *
  * - If set explicitly, the value is the source of truth: it overrides any
- *  flags.
- * - Once the domain has been set, it can only be changed from a numeric domain
- * to another numeric domain (some expressions may have been validated with
- * assumptions that the domain was numeric).
- * - When the domain is changed, the value is preserved if it is compatible
- *  with the new domain, otherwise it is reset to no value. Flags are adjusted
- * to match the domain (discarded if not a numeric domain).
- * - When the value is changed, the domain is unaffected. If the value is not
- *  compatible with the domain (setting a def with a numeric domain to a value
- *  of `True` for example), the value is discarded.
+ *   flags.
+ *
+ * - Once the type has been set, it can only be changed from a numeric type
+ *   to another numeric type (some expressions may have been validated with
+ *   assumptions that the just a number).
+ *
+ * - When the type is changed, the value is preserved if it is compatible
+ *   with the new type, otherwise it is reset to no value. Flags are adjusted
+ *   to match the type (discarded if not a numeric type).
+ *
+ * - 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.
+ *
  * - When getting a flag, if a value is available, it is the source of truth.
- * Otherwise, the stored flags are (the stored flags are also set when the domain is changed)
+ *   Otherwise, the stored flags are (the stored flags are also set when the
+ *   type is changed)
  *
  */
 export declare class _BoxedSymbolDefinition implements BoxedSymbolDefinition {
@@ -27,69 +34,30 @@ export declare class _BoxedSymbolDefinition implements BoxedSymbolDefinition {
     readonly scope: RuntimeScope | undefined;
     private _defValue?;
     private _value;
-    private _domain;
-    inferredDomain: boolean;
-    private _flags;
+    private _type;
+    inferredType: boolean;
     constant: boolean;
-    holdUntil: 'never' | 'simplify' | 'evaluate' | 'N';
-    prototype?: BoxedFunctionDefinition;
-    self?: unknown;
+    holdUntil: 'never' | 'evaluate' | 'N';
+    private _flags;
+    eq?: (a: BoxedExpression) => boolean | undefined;
+    neq?: (a: BoxedExpression) => boolean | undefined;
+    cmp?: (a: BoxedExpression) => '=' | '>' | '<' | undefined;
+    collection?: Partial<CollectionHandlers>;
     constructor(ce: IComputeEngine, name: string, def: SymbolDefinition);
+    get isFunction(): boolean;
+    get isConstant(): boolean;
     /** The symbol was previously inferred, but now it has a declaration. Update the def accordingly (we can't replace defs, as other expressions may be referencing them) */
     update(def: SymbolDefinition): void;
     reset(): void;
     get value(): BoxedExpression | undefined;
     set value(val: SemiBoxedExpression | number | undefined);
-    get domain(): BoxedDomain | undefined;
-    set domain(domain: BoxedDomain | DomainExpression | undefined);
-    get number(): boolean | undefined;
-    set number(val: boolean | undefined);
-    get integer(): boolean | undefined;
-    set integer(val: boolean | undefined);
-    get rational(): boolean | undefined;
-    set rational(val: boolean | undefined);
-    get algebraic(): boolean | undefined;
-    set algebraic(val: boolean | undefined);
-    get real(): boolean | undefined;
-    set real(val: boolean | undefined);
-    get extendedReal(): boolean | undefined;
-    set extendedReal(val: boolean | undefined);
-    get complex(): boolean | undefined;
-    set complex(val: boolean | undefined);
-    get extendedComplex(): boolean | undefined;
-    set extendedComplex(val: boolean | undefined);
-    get imaginary(): boolean | undefined;
-    set imaginary(val: boolean | undefined);
-    get positive(): boolean | undefined;
-    set positive(val: boolean | undefined);
-    get nonPositive(): boolean | undefined;
-    set nonPositive(val: boolean | undefined);
-    get negative(): boolean | undefined;
-    set negative(val: boolean | undefined);
-    get nonNegative(): boolean | undefined;
-    set nonNegative(val: boolean | undefined);
-    get zero(): boolean | undefined;
-    set zero(val: boolean | undefined);
-    get notZero(): boolean | undefined;
-    set notZero(val: boolean | undefined);
-    get one(): boolean | undefined;
-    set one(val: boolean | undefined);
-    get negativeOne(): boolean | undefined;
-    set negativeOne(val: boolean | undefined);
-    get infinity(): boolean | undefined;
-    set infinity(val: boolean | undefined);
-    get finite(): boolean | undefined;
-    set finite(val: boolean | undefined);
-    get NaN(): boolean | undefined;
-    set NaN(val: boolean | undefined);
+    get type(): Type;
+    set type(type: Type);
+    get sgn(): Sign | undefined;
+    set sgn(val: Sign | undefined);
     get even(): boolean | undefined;
     set even(val: boolean | undefined);
     get odd(): boolean | undefined;
     set odd(val: boolean | undefined);
-    get prime(): boolean | undefined;
-    set prime(val: boolean | undefined);
-    get composite(): boolean | undefined;
-    set composite(val: boolean | undefined);
     updateFlags(flags: Partial<NumericFlags>): void;
 }
-export declare function domainToFlags(dom: BoxedDomain | undefined | null): Partial<NumericFlags>;

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

@@ -1,8 +1,11 @@
-/* 0.25.1 */
-import { Decimal } from 'decimal.js';
-import { Expression } from '../../math-json/math-json-format';
+/* 0.26.2 */
+import type { Expression } from '../../math-json/types';
+import type { Type, TypeString } from '../../common/type/types';
+import type { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOptions, RuntimeScope, BoxedFunctionDefinition, BoxedBaseDefinition, BoxedSubstitution, Rule, CanonicalOptions, BoxedRule, Sign } from './public';
+import { NumericValue } from '../numeric-value/public';
 import { _BoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedFunctionDefinition, BoxedBaseDefinition, DomainExpression, BoxedSubstitution, Rule, SemiBoxedExpression, CanonicalOptions } from './public';
+import { BigNum } from '../numerics/bignum';
+import type { OneOf } from '../../common/one-of';
 /**
  * BoxedSymbol
  *
@@ -24,16 +27,23 @@ export declare class BoxedSymbol extends _BoxedExpression {
     protected _id: string;
     private _hash;
     private _def;
+    private _isStructural;
     constructor(ce: IComputeEngine, name: string, options?: {
         metadata?: Metadata;
         canonical?: CanonicalOptions;
-        def?: BoxedSymbolDefinition | BoxedFunctionDefinition;
+        structural?: boolean;
+        def?: OneOf<[BoxedSymbolDefinition, BoxedFunctionDefinition]>;
     });
     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
      */
@@ -41,49 +51,53 @@ export declare class BoxedSymbol extends _BoxedExpression {
     reset(): void;
     get isCanonical(): boolean;
     set isCanonical(val: boolean);
+    is(rhs: any): boolean;
     get canonical(): BoxedExpression;
+    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 complexity(): number;
-    get head(): string;
+    get operator(): string;
     get symbol(): string;
     get baseDefinition(): BoxedBaseDefinition | undefined;
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
     /**
      * Subsequence inferences will narrow the domain of the symbol.
-     * f(:integer), g(:real)
-     * g(x) => x:real
-     * f(x) => x:integer narrowed from integer to real
+     * f: integer -> real, g: real -> real
+     * g(x) => x: real
+     * f(x) => x: integer narrowed from integer to real
      */
-    infer(domain: BoxedDomain): boolean;
-    get value(): number | boolean | string | Object | undefined;
-    set value(value: boolean | string | Decimal | Complex | {
-        re: number;
-        im: number;
-    } | {
-        num: number;
-        denom: number;
-    } | number[] | BoxedExpression | number | undefined);
-    get domain(): BoxedDomain | undefined;
-    set domain(inDomain: DomainExpression | BoxedDomain);
-    get sgn(): -1 | 0 | 1 | undefined | null;
+    infer(t: Type): boolean;
+    get value(): number | boolean | string | object | undefined;
+    set value(value: boolean | string | Decimal | number[] | OneOf<[
+        {
+            re: number;
+            im: number;
+        },
+        {
+            num: number;
+            denom: number;
+        },
+        BoxedExpression
+    ]> | number | object | undefined);
+    get type(): Type;
+    set type(t: Type | TypeString);
+    get sgn(): Sign | undefined;
     has(x: string | string[]): boolean;
-    isSame(rhs: BoxedExpression): boolean;
-    match(pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
-    isEqual(rhs: BoxedExpression): boolean;
-    isLess(rhs: BoxedExpression): boolean | undefined;
-    isLessEqual(rhs: BoxedExpression): boolean | undefined;
-    isGreater(rhs: BoxedExpression): boolean | undefined;
-    isGreaterEqual(rhs: BoxedExpression): boolean | undefined;
+    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
     get isFunction(): boolean | undefined;
-    get isZero(): boolean | undefined;
-    get isNotZero(): boolean | undefined;
-    get isOne(): boolean | undefined;
-    get isNegativeOne(): boolean | undefined;
     get isOdd(): boolean | undefined;
     get isEven(): boolean | undefined;
-    get isPrime(): boolean | undefined;
-    get isComposite(): boolean | undefined;
     get isInfinity(): boolean | undefined;
     get isNaN(): boolean | undefined;
     get isPositive(): boolean | undefined;
@@ -93,17 +107,25 @@ export declare class BoxedSymbol extends _BoxedExpression {
     get isNumber(): boolean | undefined;
     get isInteger(): boolean | undefined;
     get isRational(): boolean | undefined;
-    get isAlgebraic(): boolean | undefined;
     get isReal(): boolean | undefined;
-    get isExtendedReal(): boolean | undefined;
-    get isComplex(): boolean | undefined;
-    get isImaginary(): boolean | undefined;
-    simplify(options?: SimplifyOptions): BoxedExpression;
+    get re(): number;
+    get im(): number;
+    get bignumRe(): BigNum | undefined;
+    get bignumIm(): BigNum | undefined;
+    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
     evaluate(options?: EvaluateOptions): BoxedExpression;
-    N(options?: NOptions): BoxedExpression;
-    replace(rules: BoxedRuleSet | Rule | Rule[], options?: ReplaceOptions): BoxedExpression | null;
+    N(): BoxedExpression;
+    replace(rules: Rule | (Rule | BoxedRule)[] | BoxedRuleSet, options?: Partial<ReplaceOptions>): BoxedExpression | null;
     subs(sub: Substitution, options?: {
         canonical?: CanonicalOptions;
     }): BoxedExpression;
+    get isCollection(): boolean;
+    contains(rhs: BoxedExpression): boolean;
+    get size(): number;
+    each(start?: number, count?: number): Iterator<BoxedExpression, undefined>;
+    at(index: number): BoxedExpression | undefined;
+    get(index: BoxedExpression | string): BoxedExpression | undefined;
+    indexOf(expr: BoxedExpression): number;
+    subsetOf(rhs: BoxedExpression, strict: boolean): boolean;
 }
 export declare function makeCanonicalSymbol(ce: IComputeEngine, name: string): BoxedExpression;

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

@@ -1,37 +1,40 @@
-/* 0.25.1 */
-import Decimal from 'decimal.js';
-import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, IComputeEngine, EvaluateOptions, NOptions, SimplifyOptions, Metadata, BoxedDomain, BoxedSubstitution, PatternMatchOptions, BoxedBaseDefinition, BoxedFunctionDefinition, SemiBoxedExpression } from '../public';
-import { DataTypeMap, TensorDataType } from '../symbolic/tensor-fields';
-import { AbstractTensor, TensorData } from '../symbolic/tensors';
+/* 0.26.2 */
+import type { BoxedExpression, IComputeEngine, EvaluateOptions, SimplifyOptions, Metadata, BoxedSubstitution, PatternMatchOptions, BoxedBaseDefinition, BoxedFunctionDefinition } from '../public';
+import { TensorDataType } from './tensor-fields';
+import { NumericValue } from '../numeric-value/public';
 import { _BoxedExpression } from './abstract-boxed-expression';
+import { AbstractTensor, TensorData } from '../tensor/tensors';
+import { Type } from '../../common/type/types';
 /**
- * A boxed tensor represents an expression that can be
- * represented by a tensor. This could be a vector, matrix
- * or multi-dimensional array.
+ * A boxed tensor represents an expression that can be represented by a tensor.
+ * This could be a vector, matrix or multi-dimensional array.
  *
- * The object can be created either from a tensor or from
- * an expression that can be represented as a tensor.
+ * The object can be created either from a tensor or from an expression that
+ * can be represented as a tensor.
  *
- * The counterpart (expression if input is tensor, or tensor
+ * The structural counterpart (expression if input is tensor, or tensor
  * if input is expression) is created lazily.
  *
  * @noInheritDoc
  *
  */
 export declare class BoxedTensor extends _BoxedExpression {
+    readonly options?: {
+        metadata?: Metadata;
+        canonical?: boolean;
+    };
     private _tensor;
-    private readonly _head?;
+    private readonly _operator?;
     private readonly _ops?;
     private _expression;
     constructor(ce: IComputeEngine, input: {
-        head?: string;
+        op?: string;
         ops: ReadonlyArray<BoxedExpression>;
     } | AbstractTensor<'expression'>, options?: {
         metadata?: Metadata;
         canonical?: boolean;
     });
-    get expression(): BoxedExpression;
+    get structural(): BoxedExpression;
     /** Create the tensor on demand */
     get tensor(): AbstractTensor<'expression'>;
     get baseDefinition(): BoxedBaseDefinition | undefined;
@@ -45,28 +48,42 @@ export declare class BoxedTensor extends _BoxedExpression {
     get isPure(): boolean;
     get isValid(): boolean;
     get complexity(): number;
-    get head(): string;
+    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 shape(): number[];
     get rank(): number;
-    get domain(): BoxedDomain | undefined;
+    get type(): Type;
     get json(): Expression;
-    /** Structural equality */
-    isSame(rhs: BoxedExpression): boolean;
     /** Mathematical equality */
-    isEqual(rhs: BoxedExpression): boolean;
-    match(pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    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;
+    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
     evaluate(options?: EvaluateOptions): BoxedExpression;
-    simplify(options?: SimplifyOptions): BoxedExpression;
-    N(options?: NOptions): BoxedExpression;
+    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
+    N(): BoxedExpression;
 }
 export declare function isBoxedTensor(val: unknown): val is BoxedTensor;
-export declare function expressionTensorInfo(head: string, rows: ReadonlyArray<BoxedExpression>): {
+export declare function expressionTensorInfo(operator: string, rows: ReadonlyArray<BoxedExpression>): {
     shape: number[];
-    dtype: keyof DataTypeMap;
-};
-export declare function expressionAsTensor<T extends TensorDataType>(head: string, rows: ReadonlyArray<BoxedExpression>): TensorData<T> | undefined;
+    dtype: TensorDataType | undefined;
+} | undefined;
+export declare function expressionAsTensor<T extends TensorDataType = 'expression'>(operator: string, rows: ReadonlyArray<BoxedExpression>): TensorData<T> | undefined;

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

@@ -0,0 +1,6 @@
+/* 0.26.2 */
+    value: T | null;
+    generation: number | undefined;
+};
+/** The cache v will get updated if necessary */
+export declare function cachedValue<T>(v: CachedValue<T>, generation: number | undefined, fn: () => T): T;

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

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare function canonicalForm(expr: BoxedExpression, forms: CanonicalOptions): BoxedExpression;

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

@@ -0,0 +1,13 @@
+/* 0.26.2 */
+/**
+ * Structural equality of boxed expressions.
+ */
+export declare function same(a: BoxedExpression, b: BoxedExpression): boolean;
+/**
+ * Mathematically 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, b: number | BoxedExpression): boolean | undefined;
+export declare function cmp(a: BoxedExpression, b: number | BoxedExpression): '<' | '=' | '>' | '>=' | '<=' | undefined;

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

@@ -0,0 +1,20 @@
+/* 0.26.2 */
+export declare function expandProducts(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression | null;
+export declare function choose(n: number, k: number): number;
+/** Attempt to transform the expression (h, ops) into a sum */
+export declare function expandFunction(ce: IComputeEngine, h: string, ops: ReadonlyArray<BoxedExpression>): BoxedExpression | 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.
+ * Expand the terms of the expression if it is a sum or negate.
+ * If the expression is a fraction, expand the numerator.
+ * 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;
+/**
+ * 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;

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

@@ -1,4 +1,4 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare class ExpressionMap<U> implements ExpressionMapInterface<U> {
     readonly _items: Map<BoxedExpression, U>;
     constructor(source?: ExpressionMapInterface<U> | readonly (readonly [BoxedExpression, U])[]);

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

@@ -1,11 +1,12 @@
-/* 0.25.1 */
-import Decimal from 'decimal.js';
-import { Rational } from '../numerics/rationals';
-import { BoxedExpression } from './public';
-export declare function applyCoefficient(value: number | Decimal | Complex | Rational | null, coef: Rational): number | Decimal | Complex | Rational | null;
+/* 0.26.2 */
+import { NumericValue } from '../numeric-value/public';
 /** Combine rational expressions into a single fraction */
 export declare function together(op: BoxedExpression): BoxedExpression;
 /**
- * Return a list of expressions that multiply together to form `expr`.
+ * 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 getPiTerm(expr: BoxedExpression): [k: NumericValue, t: NumericValue];