@cortex-js/compute-engine 0.26.4 → 0.28.0

package/dist/types/common/type/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
  * A primitive type is a simple type that represents a concrete value.
  *
  * - `any`: the top type
@@ -30,24 +30,26 @@
  *          `tuple<number, boolean>`, `tuple<x: number, y: boolean>`.
  *       - `map`: a set key-value pairs, e.g. `map<x: number, y: boolean>`.
  *
- * - `number`: any numeric value:
- *    - `finite_number`: <finite_complex> or <finite_imaginary> or
- *       <finite_real> or <finite_rational> or <finite_integer>
- *    - `non_finite_number`: `NaN`, `PositiveInfinity`, `NegativeInfinity` or
- *      `ComplexInfinity`
- *    - `complex` and `finite_complex`: a complex number, with non-zero real
- *       and imaginary parts.
- *    - `imaginary` and `finite_imaginary`: a complex number with a real part
- *       of 0 (pure imaginary).
- *    - `real` and `finite_real`: a complex number with an imaginary part of 0.
- *    - `rational` and `finite_rational`: a pure rational number
- *       (not an integer)
- *    - `integer` and `finite_integer`: a whole number
  *
  *
  */
 export type PrimitiveType = NumericType | 'collection' | 'list' | 'set' | 'map' | 'tuple' | 'value' | 'scalar' | 'function' | 'symbol' | 'boolean' | 'string' | 'expression' | 'unknown' | 'error' | 'nothing' | 'never' | 'any';
-export type NumericType = 'number' | 'finite_number' | 'complex' | 'finite_complex' | 'imaginary' | 'finite_imaginary' | 'real' | 'finite_real' | 'rational' | 'finite_rational' | 'integer' | 'finite_integer' | 'non_finite_number';
+/**
+ * - `number`: any numeric value = `complex` + `real` plus `NaN`
+ * - `complex`: a number with non-zero real and imaginary parts = `finite_complex` plus `ComplexInfinity`
+ * - `finite_complex`: a finite complex number = `imaginary` + `finite_real`
+ * - `imaginary`: a complex number with a real part of 0 (pure imaginary)
+ * - `finite_number`: a finite numeric value = `finite_complex`
+ * - `finite_real`: a finite real number = `finite_rational` + `finite_integer`
+ * - `finite_rational`: a pure rational number
+ * - `finite_integer`: a whole number
+ * - `real`: a complex number with an imaginary part of 0 = `finite_real` + `non_finite_number`
+ * - `non_finite_number`: `PositiveInfinity`, `NegativeInfinity`
+ * - `integer`: a whole number = `finite_integer` + `non_finite_number`
+ * - `rational`: a pure rational number (not an integer) = `finite_rational` + `non_finite_number`
+ *
+ */
+export type NumericType = 'number' | 'finite_number' | 'complex' | 'finite_complex' | 'imaginary' | 'real' | 'finite_real' | 'rational' | 'finite_rational' | 'integer' | 'finite_integer' | 'non_finite_number';
 export type NamedElement = {
     name?: string;
     type: Type;
@@ -71,7 +73,7 @@ export type ValueType = {
     kind: 'value';
     value: any;
 };
-/** Map is not a collection. It is a set of key/value pairs.
+/** Map is a non-indexable collection of key/value pairs.
  * An element of a map whose type is a subtype of `nothing` is optional.
  * For example, in `{x: number, y: boolean | nothing}` the element `y` is optional.
  */
@@ -90,8 +92,8 @@ export type CollectionType = {
 /**
  * The elements of a list are ordered.
  *
- * All elements of a list have the same type (but it can be a broad type,
- * up to `any`).
+ * All elements of a list have the same type, but it can be a broad type,
+ * up to `any`.
  *
  * The same element can be present in the list more than once.
  *
@@ -130,7 +132,7 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
  * Types are described using the following BNF grammar:
 
 ```bnf
-<type> ::= <union_type>
+<type> ::= <union_type> | "(" <type> ")"
 
 <union_type> ::= <intersection_type> (" | " <intersection_type>)*
 
@@ -138,12 +140,8 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
 
 <primary_type> ::=  <primitive>
                 | <tuple_type>
-                | <function_type>
+                | <signature>
                 | <list_type>
-                | <wrapped_primary_type>
-
-<wrapped_primary_type> ::= "(" <primary_type> ")"
-
 
 <primitive> ::= "any" | "unknown" | <value-type> | <symbolic-type> | <numeric-type>
 
@@ -153,9 +151,9 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
 
 <symbolic-type> ::= "expression" | "function" | "symbol"
 
-<tuple_type> ::= "(" (<name> <type> "," <named_tuple_elements>*) ")"
-            | "(" (<type> "," <unnamed_tuple_elements>*) ")" |
-            | "tuple(" <tuple_elements> ")"
+<tuple_type> ::= "tuple<" (<name> <type> "," <named_tuple_elements>*) ">"
+            | "tuple<" (<type> "," <unnamed_tuple_elements>*) ">" |
+            | "tuple<" <tuple_elements> ">"
 
 <tuple_elements> ::= <unnamed_tuple_elements> | <named_tuple_elements>
 
@@ -163,15 +161,11 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
 
 <named_tuple_elements> ::= <name> <type> ("," <name> <type>)*
 
-<function_type> ::=  <arguments> " -> " <type>
+<signature> ::=  <arguments> " -> " <type>
 
 <arguments> ::= "()"
             | <argument>
             | "(" <argument-list> ")"
-            | <deferred_evaluation>
-
-<deferred_evaluation> ::= "???" <argument>
-                       | "???" "(" <argument-list> ")"
 
 <argument> ::= <type>
             | <name> <type>
@@ -191,7 +185,7 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
             | <rest_argument>
 
 
-<list_type> ::= "[" <type> <dimensions>? "]"
+<list_type> ::= "list<" <type> <dimensions>? ">"
 
 <dimensions> ::= "^" <fixed_size>
             | "^(" <multi_dimensional_size> ")"
@@ -200,9 +194,7 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
 
 <multi_dimensional_size> ::= <positive-integer_literal> "x" <positive-integer_literal> ("x" <positive-integer_literal>)*
 
-<map> ::= "{}"
-            |"{" <map_elements> "}"
-            | "map(" <map_elements> ")"
+<map> ::= "map" | "map<" <map_elements> ">"
 
 <map_elements> ::= <name> <type> ("," <name> <type>)*
 
@@ -218,31 +210,29 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
 ```
 
 
-Examples of types:
+Examples of types strings:
    "number"    -- a simple type primitive
-
-
    "(number, boolean)" -- a tuple type
    "(x: number, y:boolean)" -- a named tuple/record type. Either all arguments are named, or none are
 
-   "[any]" -- an arbitrary collection type, with no length or element type restrictions
-   "[integer]" -- a collection type where all the elements are integers
-   "[(number, boolean)]" -- a collection of tuples
-   "[(value:number, seen:boolean)]" -- a collection of named tuples
+   "collection<any>" -- an arbitrary collection type, with no length or element type restrictions
+   "collection<integer>" -- a collection type where all the elements are integers
+   "collection<(number, boolean)>" -- a collection of tuples
+   "collection<(value:number, seen:boolean)>" -- a collection of named tuples
    "[boolean]^32" -- a collection type with a fixed size of 32 elements
    "[integer]^(2x3)" -- an integer matrix of 2 columns and 3 rows
    "[integer]^(2x3x4)" -- a tensor of dimensions 2x3x4
 
-   "number -> number" -- a function type with a single argument
-   "(x: number, number) -> number" -- a function type with a named argument
-   "(number, y:number?) -> number" -- a function type with an optional named argument (can have several optional arguments, at the end)
-   "(number, ...number) -> number" -- a function type with a rest argument (can have only one, and no optional arguments if there is a rest argument).
-   "() -> number" -- a function type with an empty argument list
+   "number -> number" -- a signature with a single argument
+   "(x: number, number) -> number" -- a signature with a named argument
+   "(number, y:number?) -> number" -- a signature with an optional named argument (can have several optional arguments, at the end)
+   "(number, ...number) -> number" -- a signature with a rest argument (can have only one, and no optional arguments if there is a rest argument).
+   "() -> number" -- a signature with an empty argument list
 
    "number | boolean" -- a union type
    "(x: number) & (y: number)" -- an intersection type
    "number | ((x: number) & (y: number))" -- a union type with an intersection type
-   "(number -> number) | number" -- a union type with a function type
+   "(number -> number) | number" -- a union type with a signature and a primitive type
 */
 export type TypeString = string;
 export type TypeCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';

package/dist/types/common/type/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 /** Convert two or more types into a more specific type that is a subtype of
  *  all the input types. The resulting type is usually more constrained and
  *  only encompasses values that belong to both input types.
@@ -27,13 +27,9 @@ export declare function narrow(...types: Readonly<Type>[]): Type;
  * widen('number', 'expression') => 'expression'
  * widen('number', 'string') => 'any'
  */
-export declare function widen(...types: Readonly<Type>[]): Type;
+export declare function widen(...types: Readonly<Type>[]): Readonly<Type>;
 export declare function isSignatureType(type: Readonly<Type> | TypeString): type is FunctionSignature;
 export declare function functionSignature(type: Readonly<Type>): Type | undefined;
-export declare function functionResult(type: Readonly<Type>): Type | undefined;
+export declare function functionResult(type: Readonly<Type> | undefined): Type | undefined;
 export declare function collectionElementType(type: Readonly<Type>): Type | undefined;
 export declare function isValidType(t: any): t is Readonly<Type>;
-/**
- * Add a `toString()` method to the type object
- */
-export declare function makeType(type: Type): Readonly<Type>;

package/dist/types/common/utils.d.ts

@@ -1,2 +1,2 @@
-/* 0.26.4 */
+/* 0.28.0 */
 export declare function hidePrivateProperties(obj: any): void;

package/dist/types/compute-engine/assume.d.ts

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 /**
  * Add an assumption, in the form of a predicate, for example:
  *

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

@@ -1,9 +1,10 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import { Expression, MathJsonIdentifier } from '../../math-json/types';
 import type { BoxedBaseDefinition, BoxedExpression, BoxedFunctionDefinition, BoxedRuleSet, BoxedSubstitution, BoxedSymbolDefinition, CanonicalOptions, EvaluateOptions, IComputeEngine, JsonSerializationOptions, Metadata, PatternMatchOptions, Rule, RuntimeScope, Sign, SimplifyOptions, Substitution } from './public';
 import type { LatexString } from '../public';
 import type { NumericValue } from '../numeric-value/public';
 import type { SmallInteger } from '../numerics/numeric';
+import { CompiledType } from '../compile';
 import type { SerializeLatexOptions } from '../latex-syntax/public';
 import { AsciiMathOptions } from './ascii-math';
 /**
@@ -116,7 +117,7 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
         canonical: CanonicalOptions;
         recursive?: boolean;
     }): BoxedExpression;
-    solve(_vars: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
+    solve(_vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
     replace(_rules: BoxedRuleSet | Rule | Rule[]): null | BoxedExpression;
     has(_v: string | string[]): boolean;
     get isPositive(): boolean | undefined;
@@ -130,13 +131,13 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     get baseDefinition(): BoxedBaseDefinition | undefined;
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
-    infer(t: Type): boolean;
+    infer(_t: Type): boolean;
     bind(): void;
     reset(): void;
     get value(): number | boolean | string | object | undefined;
     set value(_value: BoxedExpression | number | boolean | string | number[] | undefined);
-    get type(): Type;
-    set type(_type: Type);
+    get type(): BoxedType;
+    set type(_type: Type | TypeString | BoxedType);
     get isNumber(): boolean | undefined;
     get isInteger(): boolean | undefined;
     get isRational(): boolean | undefined;
@@ -144,10 +145,15 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     simplify(_options?: Partial<SimplifyOptions>): BoxedExpression;
     expand(): BoxedExpression;
     evaluate(_options?: Partial<EvaluateOptions>): BoxedExpression;
+    evaluateAsync(_options?: Partial<EvaluateOptions>): Promise<BoxedExpression>;
     N(): BoxedExpression;
-    compile(to?: string, options?: {
-        optimize: ('simplify' | 'evaluate')[];
-    }): ((args: Record<string, any>) => any | undefined) | undefined;
+    compile(options?: {
+        to?: 'javascript';
+        functions?: Record<MathJsonIdentifier, string | ((...any: any[]) => any)>;
+        vars?: Record<MathJsonIdentifier, string>;
+        imports?: Function[];
+        preamble?: string;
+    }): (args: Record<string, any>) => CompiledType;
     get isCollection(): boolean;
     contains(_rhs: BoxedExpression): boolean;
     subsetOf(_target: BoxedExpression, _strict: boolean): boolean;
@@ -158,5 +164,6 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     indexOf(_expr: BoxedExpression): number;
 }
 export declare function getSubexpressions(expr: BoxedExpression, name: MathJsonIdentifier): ReadonlyArray<BoxedExpression>;
-import { Type } from '../../common/type/types';
+import type { Type, TypeString } from '../../common/type/types';
 import { AbstractTensor } from '../tensor/tensors';
+import { BoxedType } from '../../common/type/boxed-type';

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import { Decimal } from 'decimal.js';
 import type { BoxedExpression } from '../public';
 export declare function apply(expr: BoxedExpression, fn: (x: number) => number | Complex, bigFn?: (x: Decimal) => Decimal | Complex | number, complexFn?: (x: Complex) => number | Complex): BoxedExpression | undefined;

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

@@ -1,5 +1,6 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import { Type } from '../../common/type/types';
+import { BoxedType } from '../../common/type/boxed-type';
 /**
  *
  * The canonical form of `Add`:
@@ -10,6 +11,6 @@ import { Type } from '../../common/type/types';
  *
  */
 export declare function canonicalAdd(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression;
-export declare function addType(args: ReadonlyArray<BoxedExpression>): Type;
+export declare function addType(args: ReadonlyArray<BoxedExpression>): Type | BoxedType;
 export declare function add(...xs: ReadonlyArray<BoxedExpression>): BoxedExpression;
 export declare function addN(...xs: ReadonlyArray<BoxedExpression>): BoxedExpression;

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 /**
  * Canonical form of 'Divide' (and 'Rational')
  * - remove denominator of 1

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 /**
  * The canonical form of `Multiply`:
  * - removes `1` anb `-1`

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import type { Rational } from '../numerics/rationals';
 export declare function asRadical(expr: BoxedExpression): Rational | null;
 export declare function canonicalPower(a: BoxedExpression, b: BoxedExpression): BoxedExpression;

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 export type AsciiMathSerializer = (expr: BoxedExpression, precedence?: number) => string;
 export type AsciiMathOptions = {
     symbols: Record<string, string>;

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import { Decimal } from 'decimal.js';
 import { IComputeEngine, SemiBoxedExpression, BoxedExpression, Metadata, CanonicalOptions } from './public';
 import { MathJsonIdentifier } from '../../math-json/types';

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

@@ -1,7 +1,8 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import type { BoxedExpression, CollectionHandlers, CompiledExpression, EvaluateOptions, Sign } from './public';
-import { Type } from '../../common/type/types';
+import { Type, TypeString } from '../../common/type/types';
 import { OneOf } from '../../common/one-of';
+import { BoxedType } from '../../common/type/boxed-type';
 export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition {
     engine: IComputeEngine;
     scope: RuntimeScope;
@@ -16,12 +17,12 @@ export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition
     involution: boolean;
     pure: boolean;
     complexity: number;
-    hold: boolean;
-    signature: Type;
+    lazy: boolean;
+    signature: BoxedType;
     inferredSignature: boolean;
     type?: (ops: ReadonlyArray<BoxedExpression>, options: {
         engine: IComputeEngine;
-    }) => Type | undefined;
+    }) => BoxedType | Type | TypeString | undefined;
     sgn?: (ops: ReadonlyArray<BoxedExpression>, options: {
         engine: IComputeEngine;
     }) => Sign | undefined;
@@ -33,15 +34,21 @@ export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition
     canonical?: (ops: ReadonlyArray<BoxedExpression>, options: {
         engine: IComputeEngine;
     }) => BoxedExpression | null;
-    evaluate?: (ops: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
+    evaluate?: (ops: ReadonlyArray<BoxedExpression>, options: Partial<EvaluateOptions> & {
         engine: IComputeEngine;
     }) => BoxedExpression | undefined;
+    evaluateAsync?: (ops: ReadonlyArray<BoxedExpression>, options?: Partial<EvaluateOptions> & {
+        engine?: IComputeEngine;
+    }) => Promise<BoxedExpression | undefined>;
     evalDimension?: (ops: ReadonlyArray<BoxedExpression>, options: {
         engine: IComputeEngine;
     }) => BoxedExpression;
     compile?: (expr: BoxedExpression) => CompiledExpression;
     collection?: Partial<CollectionHandlers>;
     constructor(ce: IComputeEngine, name: string, def: FunctionDefinition);
+    infer(sig: Type): void;
+    update(def: FunctionDefinition): void;
     reset(): void;
 }
 export declare function makeFunctionDefinition(engine: IComputeEngine, name: string, def: OneOf<[FunctionDefinition | BoxedFunctionDefinition]>): BoxedFunctionDefinition;
+export declare function isBoxedFunctionDefinition(x: any): x is BoxedFunctionDefinition;

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

@@ -1,15 +1,16 @@
-/* 0.26.4 */
+/* 0.28.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 { Type } from '../../common/type/types';
+import { BoxedType } from '../../common/type/boxed-type';
 /**
- * A boxed function represent an expression that can be
- * represented by a function call.
+ * A boxed function represent an expression that can be represented by a
+ * function call.
  *
- * It is composed of an operator (the name of the function) and
- * a list of arguments.
+ * 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 operator.
  * The definition contains the signature of the function, and the
@@ -98,11 +99,12 @@ export declare class BoxedFunction extends _BoxedExpression {
     get isReal(): boolean | undefined;
     get isFunctionExpression(): boolean;
     /** The type of the value of the function */
-    get type(): Type;
+    get type(): BoxedType;
     simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
-    evaluate(options?: EvaluateOptions): BoxedExpression;
+    evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
+    evaluateAsync(options?: Partial<EvaluateOptions>): Promise<BoxedExpression>;
     N(): BoxedExpression;
-    solve(vars: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
+    solve(vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
     get isCollection(): boolean;
     contains(rhs: BoxedExpression): boolean;
     get size(): number;
@@ -111,4 +113,6 @@ export declare class BoxedFunction extends _BoxedExpression {
     get(index: BoxedExpression | string): BoxedExpression | undefined;
     indexOf(expr: BoxedExpression): number;
     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,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import { Decimal } from 'decimal.js';
 import type { BoxedExpression, IComputeEngine, Metadata, PatternMatchOptions, BoxedSubstitution, EvaluateOptions, BoxedRuleSet, ReplaceOptions, Rule, Substitution, CanonicalOptions, SimplifyOptions, Sign } from '../public';
 import type { Expression, MathJsonNumber } from '../../math-json';
@@ -6,7 +6,7 @@ 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 { Type } from '../../common/type/types';
+import { BoxedType } from '../../common/type/boxed-type';
 /**
  * BoxedNumber
  *
@@ -54,7 +54,7 @@ export declare class BoxedNumber extends _BoxedExpression {
     root(exp: number | BoxedExpression): BoxedExpression;
     sqrt(): BoxedExpression;
     ln(semiBase?: number | BoxedExpression): BoxedExpression;
-    get type(): Type;
+    get type(): BoxedType;
     get sgn(): Sign | undefined;
     get numerator(): BoxedExpression;
     get denominator(): BoxedExpression;
@@ -87,7 +87,7 @@ export declare class BoxedNumber extends _BoxedExpression {
     get structural(): BoxedExpression;
     toNumericValue(): [NumericValue, BoxedExpression];
     simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
-    evaluate(options?: EvaluateOptions): BoxedExpression;
+    evaluate(options?: Partial<EvaluateOptions>): 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.26.4 */
+/* 0.28.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,6 +1,6 @@
-/* 0.26.4 */
+/* 0.28.0 */
 import { _BoxedExpression } from './abstract-boxed-expression';
-import { Type } from '../../common/type/types';
+import { BoxedType } from '../../common/type/boxed-type';
 /**
  * BoxedString
  *
@@ -15,7 +15,7 @@ export declare class BoxedString extends _BoxedExpression {
     get isPure(): boolean;
     get isCanonical(): boolean;
     set isCanonical(_va: boolean);
-    get type(): Type;
+    get type(): BoxedType;
     get complexity(): number;
     get string(): string;
     match(pattern: BoxedExpression, _options?: PatternMatchOptions): BoxedSubstitution | null;

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

@@ -1,5 +1,6 @@
-/* 0.26.4 */
-import { Type } from '../../common/type/types';
+/* 0.28.0 */
+import { Type, TypeString } from '../../common/type/types';
+import { BoxedType } from '../../common/type/boxed-type';
 /**
  * ### THEORY OF OPERATIONS
  *
@@ -51,8 +52,8 @@ export declare class _BoxedSymbolDefinition implements BoxedSymbolDefinition {
     reset(): void;
     get value(): BoxedExpression | undefined;
     set value(val: SemiBoxedExpression | number | undefined);
-    get type(): Type;
-    set type(type: Type);
+    get type(): BoxedType;
+    set type(type: Type | TypeString | BoxedType);
     get sgn(): Sign | undefined;
     set sgn(val: Sign | undefined);
     get even(): boolean | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 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';
@@ -6,6 +6,7 @@ import { NumericValue } from '../numeric-value/public';
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { BigNum } from '../numerics/bignum';
 import type { OneOf } from '../../common/one-of';
+import { BoxedType } from '../../common/type/boxed-type';
 /**
  * BoxedSymbol
  *
@@ -64,7 +65,7 @@ export declare class BoxedSymbol extends _BoxedExpression {
     root(n: number | BoxedExpression): BoxedExpression;
     sqrt(): BoxedExpression;
     ln(semiBase?: number | BoxedExpression): BoxedExpression;
-    solve(vars: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
+    solve(vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
     get complexity(): number;
     get operator(): string;
     get symbol(): string;
@@ -72,7 +73,7 @@ export declare class BoxedSymbol extends _BoxedExpression {
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
     /**
-     * Subsequence inferences will narrow the domain of the symbol.
+     * 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
@@ -90,8 +91,8 @@ export declare class BoxedSymbol extends _BoxedExpression {
         },
         BoxedExpression
     ]> | number | object | undefined);
-    get type(): Type;
-    set type(t: Type | TypeString);
+    get type(): BoxedType;
+    set type(t: Type | TypeString | BoxedType);
     get sgn(): Sign | undefined;
     has(x: string | string[]): boolean;
     match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
@@ -113,7 +114,7 @@ export declare class BoxedSymbol extends _BoxedExpression {
     get bignumRe(): BigNum | undefined;
     get bignumIm(): BigNum | undefined;
     simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
-    evaluate(options?: EvaluateOptions): BoxedExpression;
+    evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
     N(): BoxedExpression;
     replace(rules: Rule | (Rule | BoxedRule)[] | BoxedRuleSet, options?: Partial<ReplaceOptions>): BoxedExpression | null;
     subs(sub: Substitution, options?: {

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

@@ -1,10 +1,10 @@
-/* 0.26.4 */
+/* 0.28.0 */
 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';
+import { BoxedType } from '../../common/type/boxed-type';
 /**
  * A boxed tensor represents an expression that can be represented by a tensor.
  * This could be a vector, matrix or multi-dimensional array.
@@ -66,7 +66,7 @@ export declare class BoxedTensor extends _BoxedExpression {
     sqrt(): BoxedExpression;
     get shape(): number[];
     get rank(): number;
-    get type(): Type;
+    get type(): BoxedType;
     get json(): Expression;
     /** Mathematical equality */
     isEqual(rhs: number | BoxedExpression): boolean | undefined;
@@ -77,7 +77,7 @@ export declare class BoxedTensor extends _BoxedExpression {
     at(_index: number): BoxedExpression | undefined;
     indexOf(_expr: BoxedExpression): number;
     match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
-    evaluate(options?: EvaluateOptions): BoxedExpression;
+    evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
     simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
     N(): BoxedExpression;
 }

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

@@ -1,6 +1,7 @@
-/* 0.26.4 */
+/* 0.28.0 */
     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;
+export declare function cachedValueAsync<T>(v: CachedValue<T>, generation: number | undefined, fn: () => Promise<T>): Promise<T>;

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.26.4 */
+/* 0.28.0 */
 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 */