@cortex-js/compute-engine 0.25.0 → 0.26.0

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

@@ -1,87 +1,27 @@
-/* 0.25.0 */
+/* 0.26.0 */
 import { Decimal } from 'decimal.js';
 import { IComputeEngine, SemiBoxedExpression, BoxedExpression, Metadata, CanonicalOptions } from './public';
-import { MathJsonNumber } from '../../math-json/math-json-format';
-import { Rational } from '../numerics/rationals';
+import { MathJsonIdentifier } from '../../math-json/types';
+import { NumericValue } from '../numeric-value/public';
 /**
- * ### THEORY OF OPERATIONS
- *
- * 1/ Boxing does not depend on the numeric mode. The numeric mode could be
- * changed later, but the previously boxed numbers could not be retroactively
- * upgraded.
- *
- * The `numericMode` is taken into account only during evaluation.
- *
- * Therefore, a boxed expression may contain a mix of number representations.
- *
- * 2/ The result of boxing is canonical by default.
- *
- * This is the most common need (i.e. as soon as you want to evaluate an
- * expression you need a canonical expression). Creating a boxed expression
- * which is canonical from the start avoid going through an intermediary step
- * with a non-canonical expression.
- *
- * 3/ When boxing (and canonicalizing), if the function is "scoped", a new
- *    scope is created before the canonicalization, so that any declaration
- *    are done within that scope. Example of scoped functions include `Block`
- *    and `Sum`.
- *
- * 4/ When implementing an `evaluate()`:
- * - if `bignumPreferred()` all operations should be done in bignum and complex,
- *    otherwise, they should all be done in machine numbers and complex.
- * - if not `complexAllowed()`, return `NaN` if a complex value is encountered
- * - if a `Sqrt` (of a rational) is encountered, preserve it
- * - if a `hold` constant is encountered, preserve it
- * - if a rational is encountered, preserve it
- * - if one of the arguments is not exact, return an approximation
- *
- * EXACT
- * - 2 + 5 -> 7
- * - 2 + 5/7 -> 19/7
- * - 2 + √2 -> 2 + √2
- * - 2 + √(5/7) -> 2 + √(5/7)
- * - 5/7 + 9/11 -> 118/77
- * - 5/7 + √2 -> 5/7 + √2
- * - 10/14 + √(18/9) -> 5/7 + √2
- * - √2 + √5 -> √2 + √5
- * - √2 + √2 -> 2√2
- * - sin(2) -> sin(2)
- * - sin(pi/3) -> √3/2
- *
- * APPROXIMATE
- * - 2 + 2.1 -> 4.1
- * - 2 + √2.1 -> 3.44914
- * - 5/7 + √2.1 -> 2.16342
- * - sin(2) + √2.1 -> 2.35844
- */
-/**
- * Return a boxed number representing `num`.
- *
- * Note: `boxNumber()` should only be called from `ce.number()` in order to
- * benefit from number expression caching.
- */
-export declare function boxNumber(ce: IComputeEngine, num: MathJsonNumber | number | string | Complex | Decimal | Rational | [Decimal, Decimal], options?: {
-    metadata?: Metadata;
-    canonical?: boolean;
-}): BoxedExpression | null;
-/**
- * Given a head and a set of arguments, return a boxed function expression.
+ * Given a name and a set of arguments, return a boxed function expression.
  *
  * If available, preserve LaTeX and wikidata metadata in the boxed expression.
  *
  * Note that `boxFunction()` should only be called from `ce.function()`
  */
-export declare function boxFunction(ce: IComputeEngine, head: string, ops: readonly SemiBoxedExpression[], options?: {
+export declare function boxFunction(ce: IComputeEngine, name: MathJsonIdentifier, ops: readonly SemiBoxedExpression[], options?: {
     metadata?: Metadata;
     canonical?: CanonicalOptions;
+    structural?: boolean;
 }): BoxedExpression;
 /**
  * Notes about the boxed form:
  *
- * [1] Expression with a head of `Number`, `String`, `Symbol` and `Dictionary`
+ * [1] Expression with an operator of `Number`, `String`, `Symbol` and `Dictionary`
  *      are converted to the corresponding atomic expression.
  *
- * [2] Expressions with a head of `Complex` are converted to a (complex) number
+ * [2] Expressions with an operator of `Complex` are converted to a (complex) number
  *     or a `Add`/`Multiply` expression.
  *
  *     The precedence of `Complex` (for serialization) is sometimes the
@@ -89,8 +29,8 @@ export declare function boxFunction(ce: IComputeEngine, head: string, ops: reado
  *    `Multiply` (when im or re === 0). Using a number or an explicit
  *    `Add`/`Multiply` expression avoids this ambiguity.
  *
- * [3] An expression with a `Rational` head is converted to a rational number.
- *    if possible, to a `Divide` otherwise.
+ * [3] An expression with a `Rational` operator is converted to a rational
+ *    number if possible, to a `Divide` otherwise.
  *
  * [4] A `Negate` function applied to a number literal is converted to a number.
  *
@@ -100,6 +40,8 @@ export declare function boxFunction(ce: IComputeEngine, head: string, ops: reado
  * Note that this function should only be called from `ce.box()`
  *
  */
-export declare function box(ce: IComputeEngine, expr: null | undefined | Decimal | Complex | Rational | SemiBoxedExpression, options?: {
+export declare function box(ce: IComputeEngine, expr: null | undefined | NumericValue | SemiBoxedExpression, options?: {
     canonical?: CanonicalOptions;
+    structural?: boolean;
 }): BoxedExpression;
+export declare function toBigint(x: Complex | Decimal | SemiBoxedExpression): bigint | null;

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

@@ -1,5 +1,7 @@
-/* 0.25.0 */
-import { BoxedExpression } from './public';
+/* 0.26.0 */
+import type { BoxedExpression, CollectionHandlers, CompiledExpression, EvaluateOptions, Sign } from './public';
+import { Type } from '../../common/type/types';
+import { OneOf } from '../../common/one-of';
 export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition {
     engine: IComputeEngine;
     scope: RuntimeScope;
@@ -9,21 +11,37 @@ export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition
     threadable: boolean;
     associative: boolean;
     commutative: boolean;
+    commutativeOrder: ((a: BoxedExpression, b: BoxedExpression) => number) | undefined;
     idempotent: boolean;
     involution: boolean;
     pure: boolean;
-    inert: boolean;
-    numeric: boolean;
     complexity: number;
-    hold: Hold;
-    dynamic: boolean;
-    signature: BoxedFunctionSignature;
-    iterator?: (expr: BoxedExpression, start?: number, count?: number) => Iterator<BoxedExpression>;
-    at?: (expr: BoxedExpression, index: number | string) => undefined | BoxedExpression;
-    size?: (expr: BoxedExpression) => number;
-    keys?: (expr: BoxedExpression) => undefined | Iterator<string>;
-    indexOf?: (expr: BoxedExpression, target: BoxedExpression, from?: number) => number | string | undefined;
+    hold: boolean;
+    signature: Type;
+    inferredSignature: boolean;
+    type?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => Type | undefined;
+    sgn?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => Sign | undefined;
+    eq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
+    neq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
+    even?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => boolean | undefined;
+    canonical?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => BoxedExpression | null;
+    evaluate?: (ops: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
+        engine: IComputeEngine;
+    }) => BoxedExpression | undefined;
+    evalDimension?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => BoxedExpression;
+    compile?: (expr: BoxedExpression) => CompiledExpression;
+    collection?: Partial<CollectionHandlers>;
     constructor(ce: IComputeEngine, name: string, def: FunctionDefinition);
     reset(): void;
 }
-export declare function makeFunctionDefinition(engine: IComputeEngine, name: string, def: FunctionDefinition | BoxedFunctionDefinition): BoxedFunctionDefinition;
+export declare function makeFunctionDefinition(engine: IComputeEngine, name: string, def: OneOf<[FunctionDefinition | BoxedFunctionDefinition]>): BoxedFunctionDefinition;

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

@@ -1,47 +1,55 @@
-/* 0.25.0 */
-import { Decimal } from 'decimal.js';
+/* 0.26.0 */
+import type { BoxedFunctionDefinition, IComputeEngine, BoxedRuleSet, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOptions, RuntimeScope, BoxedSubstitution, EvaluateOptions, BoxedBaseDefinition, Rule, CanonicalOptions } from '../public';
+import type { BoxedExpression, Sign } from './public';
+import { NumericValue } from '../numeric-value/public';
 import { _BoxedExpression } from './abstract-boxed-expression';
-import { Expression } from '../../math-json/math-json-format';
-import { BoxedFunctionDefinition, IComputeEngine, NOptions, BoxedRuleSet, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedSubstitution, EvaluateOptions, BoxedBaseDefinition, Hold, Rule, CanonicalOptions } from '../public';
-import { BoxedExpression, SemiBoxedExpression } from './public';
+import { Type } from '../../common/type/types';
 /**
  * A boxed function represent an expression that can be
  * represented by a function call.
  *
- * It is composed of a head (the name of the function) and
+ * It is composed of an operator (the name of the function) and
  * a list of arguments.
  *
- * It has a definition associated with it, based
- * on the head. The definition contains the signature of the function,
- * and the implementation of the function.
+ * 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.
  *
  * @noInheritDoc
  *
  */
 export declare class BoxedFunction extends _BoxedExpression {
-    private readonly _head;
+    private readonly _name;
     private readonly _ops;
     private _canonical;
     private _scope;
-    private _def;
+    _def: BoxedFunctionDefinition | undefined;
     private _isPure;
-    private _result;
+    private _isStructural;
     private _hash;
-    constructor(ce: IComputeEngine, head: string | BoxedExpression, ops: ReadonlyArray<BoxedExpression>, options?: {
+    private _value;
+    private _valueN;
+    private _sgn;
+    private _type;
+    constructor(ce: IComputeEngine, name: string, ops: ReadonlyArray<BoxedExpression>, options?: {
         metadata?: Metadata;
         canonical?: boolean;
+        structural?: boolean;
     });
     get hash(): number;
-    infer(domain: BoxedDomain): boolean;
+    infer(t: Type): boolean;
     bind(): void;
     reset(): void;
-    get isExact(): boolean;
     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 json(): Expression;
     get scope(): RuntimeScope | null;
-    get head(): string | BoxedExpression;
+    get operator(): string;
     get ops(): ReadonlyArray<BoxedExpression>;
     get nops(): number;
     get op1(): BoxedExpression;
@@ -49,45 +57,58 @@ export declare class BoxedFunction extends _BoxedExpression {
     get op3(): BoxedExpression;
     get isValid(): boolean;
     get canonical(): BoxedExpression;
+    get structural(): BoxedExpression;
+    get isStructural(): boolean;
+    toNumericValue(): [NumericValue, BoxedExpression];
     subs(sub: Substitution, options?: {
         canonical?: CanonicalOptions;
     }): BoxedExpression;
-    replace(rules: BoxedRuleSet | Rule | Rule[], options?: ReplaceOptions): BoxedExpression | null;
-    has(x: string | string[]): boolean;
-    /** `isSame` is structural/symbolic equality */
-    isSame(rhs: BoxedExpression): boolean;
-    match(pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    replace(rules: BoxedRuleSet | Rule | Rule[], options?: Partial<ReplaceOptions>): BoxedExpression | null;
+    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    has(v: string | string[]): boolean;
+    get sgn(): Sign | undefined;
+    get isNaN(): boolean | undefined;
+    get isInfinity(): boolean | undefined;
+    get isFinite(): boolean | undefined;
+    get isOne(): boolean | undefined;
+    get isNegativeOne(): boolean | undefined;
+    get isPositive(): boolean | undefined;
+    get isNonNegative(): boolean | undefined;
+    get isNegative(): boolean | undefined;
+    get isNonPositive(): boolean | undefined;
+    get numerator(): BoxedExpression;
+    get denominator(): BoxedExpression;
+    get numeratorDenominator(): [BoxedExpression, 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(exp: number | BoxedExpression): BoxedExpression;
+    sqrt(): BoxedExpression;
+    ln(semiBase?: number | BoxedExpression): BoxedExpression;
     get complexity(): number | undefined;
     get baseDefinition(): BoxedBaseDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
-    /** `isEqual` is mathematical equality */
-    isEqual(rhs: BoxedExpression): boolean;
     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;
-    get domain(): BoxedDomain | undefined;
-    simplify(options?: SimplifyOptions): BoxedExpression;
+    get isFunctionExpression(): boolean;
+    /** The type of the value of the function */
+    get type(): Type;
+    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
     evaluate(options?: EvaluateOptions): BoxedExpression;
-    N(options?: NOptions): 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>;
+    at(index: number): BoxedExpression | undefined;
+    get(index: BoxedExpression | string): BoxedExpression | undefined;
+    indexOf(expr: BoxedExpression): number;
+    subsetOf(rhs: BoxedExpression, strict: boolean): boolean;
 }
-export declare function makeCanonicalFunction(ce: IComputeEngine, head: string | BoxedExpression, ops: ReadonlyArray<SemiBoxedExpression>, metadata?: Metadata): BoxedExpression;
-/** Apply the function `f` to elements of `xs`, except to the elements
- * described by `skip`:
- * - `all`: don't apply f to any elements
- * - `none`: apply `f` to all elements
- * - `first`: apply `f` to all elements except the first
- * - `rest`: apply `f` to the first element, skip the  others
- * - 'last': apply `f` to all elements except the last
- * - 'most': apply `f` to the last elements, skip the others
- *
- * Account for `Hold`, `ReleaseHold`, `Sequence`, `Symbol` and `Nothing`.
- *
- * If `f` returns `null`, the element is not added to the result
- */
-export declare function holdMap(xs: ReadonlyArray<BoxedExpression>, skip: Hold, associativeHead: string, f: (x: BoxedExpression) => BoxedExpression | null): ReadonlyArray<BoxedExpression>;

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

@@ -1,19 +1,20 @@
-/* 0.25.0 */
+/* 0.26.0 */
 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,42 @@ 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 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 +71,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.0 */
-import { BoxedExpression } from './public';
+/* 0.26.0 */
+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.0 */
-import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, PatternMatchOptions, BoxedSubstitution, SemiBoxedExpression } from './public';
-import Complex from 'complex.js';
-import Decimal from 'decimal.js';
+/* 0.26.0 */
+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.0 */
+/* 0.26.0 */
+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>;