@cortex-js/compute-engine 0.27.0 → 0.29.0

package/dist/types/common/one-of.d.ts

@@ -1,7 +1,8 @@
-/* 0.27.0 */
+/* 0.29.0 */
     infer Head,
     ...infer Rem
 ] ? MergeTypes<Rem, Res & Head> : Res;
+/** @internal  */
 export type OneOf<TypesArray extends any[], Res = never, AllProperties = MergeTypes<TypesArray>> = TypesArray extends [infer Head, ...infer Rem] ? OneOf<Rem, Res | OnlyFirst<Head, AllProperties>, AllProperties> : Res;
 type OnlyFirst<F, S> = F & {
     [Key in keyof Omit<S, keyof F>]?: never;

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

@@ -1,5 +1,4 @@
-/* 0.27.0 */
-/** @category Error Handling */
+/* 0.29.0 */
 export type RuntimeSignalCode = 'timeout' | 'out-of-memory' | 'recursion-depth-exceeded' | 'iteration-limit-exceeded';
 /** @category Error Handling */
 export type SignalCode = RuntimeSignalCode | ('invalid-name' | 'expected-predicate' | 'expected-symbol' | 'operator-requires-one-operand' | 'postfix-operator-requires-one-operand' | 'prefix-operator-requires-one-operand' | 'unbalanced-symbols' | 'expected-argument' | 'unexpected-command' | 'cyclic-definition' | 'invalid-supersets' | 'expected-supersets' | 'unknown-domain' | 'duplicate-wikidata' | 'invalid-dictionary-entry' | 'syntax-error');

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

@@ -0,0 +1,14 @@
+/* 0.29.0 */
+/** @category Type */
+export declare class BoxedType {
+    static unknown: BoxedType;
+    type: Type;
+    constructor(type: Type | TypeString);
+    matches(other: Type | TypeString | BoxedType): boolean;
+    is(other: Type | TypeString): boolean;
+    get isUnknown(): boolean;
+    toString(): string;
+    toJSON(): string;
+    [Symbol.toPrimitive](hint: string): string | null;
+    valueOf(): string;
+}

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.29.0 */
 export declare function parseType(s: undefined): undefined;
 export declare function parseType(s: string | Type): Type;
 export declare function parseType(s: string | Type | undefined): Type | undefined;

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

@@ -1,4 +1,5 @@
-/* 0.27.0 */
+/* 0.29.0 */
+/** All the types representing numeric values */
 export declare const NUMERIC_TYPES: PrimitiveType[];
 export declare const COLLECTION_TYPES: PrimitiveType[];
 export declare const SCALAR_TYPES: PrimitiveType[];

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

@@ -1,2 +1,2 @@
-/* 0.27.0 */
+/* 0.29.0 */
 export declare function typeToString(type: Type, precedence?: number): string;

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.29.0 */
 /** Return true if lhs is a subtype of rhs */
 export declare function isPrimitiveSubtype(lhs: PrimitiveType, rhs: PrimitiveType): boolean;
 /** Return true if lhs is a subtype of rhs */

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.29.0 */
  * A primitive type is a simple type that represents a concrete value.
  *
  * - `any`: the top type
@@ -10,14 +10,14 @@
  *
  * - `expression`:
  *    - a symbolic expression, such as `["Add", "x", 1]`
- *    - <value>
+ *    - `<value>`
  *    - `symbol`: a symbol, such as `x`.
  *    - `function`: a function expression
  *      such as `["Function", ["Add", "x", 1], "x"]`.
  *
  * - `value`
  *    - `scalar`
- *      - <number>
+ *      - `<number>`
  *      - `boolean`: a boolean value: `True` or `False`.
  *      - `string`: a string of characters.
  *    - `collection`
@@ -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.
  *
@@ -128,122 +130,105 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
  * The type is represented either by a primitive type (e.g. number, complex, collection, etc.), or a compound type (e.g. tuple, function signature, etc.).
  *
  * Types are described using the following BNF grammar:
-
-```bnf
-<type> ::= <union_type>
-
-<union_type> ::= <intersection_type> (" | " <intersection_type>)*
-
-<intersection_type> ::= <primary_type> (" & " <primary_type>)*
-
-<primary_type> ::=  <primitive>
-                | <tuple_type>
-                | <function_type>
-                | <list_type>
-                | <wrapped_primary_type>
-
-<wrapped_primary_type> ::= "(" <primary_type> ")"
-
-
-<primitive> ::= "any" | "unknown" | <value-type> | <symbolic-type> | <numeric-type>
-
-<numeric-type> ::= "number" | "complex" | "imaginary" | "real" | "rational" | "integer"
-
-<value-type> ::= "value" | <numeric-type> | "collection" | "boolean" | "string"
-
-<symbolic-type> ::= "expression" | "function" | "symbol"
-
-<tuple_type> ::= "(" (<name> <type> "," <named_tuple_elements>*) ")"
-            | "(" (<type> "," <unnamed_tuple_elements>*) ")" |
-            | "tuple(" <tuple_elements> ")"
-
-<tuple_elements> ::= <unnamed_tuple_elements> | <named_tuple_elements>
-
-<unnamed_tuple_elements> ::= <type> ("," <type>)*
-
-<named_tuple_elements> ::= <name> <type> ("," <name> <type>)*
-
-<function_type> ::=  <arguments> " -> " <type>
-
-<arguments> ::= "()"
-            | <argument>
-            | "(" <argument-list> ")"
-            | <deferred_evaluation>
-
-<deferred_evaluation> ::= "???" <argument>
-                       | "???" "(" <argument-list> ")"
-
-<argument> ::= <type>
-            | <name> <type>
-
-<rest_argument> ::= "..." <type>
-            | <name> "..." <type>
-
-<optional_argument> ::= <argument> "?"
-
-<optional_arguments> ::= <optional_argument> ("," <optional_argument>)*
-
-<required_arguments> ::= <argument> ("," <argument>)*
-
-<argument-list> ::= <required_arguments> ("," <rest_argument>)?
-            | <required_arguments> <optional_arguments>?
-            | <optional_arguments>?
-            | <rest_argument>
-
-
-<list_type> ::= "[" <type> <dimensions>? "]"
-
-<dimensions> ::= "^" <fixed_size>
-            | "^(" <multi_dimensional_size> ")"
-
-<fixed_size> ::= <positive-integer_literal>
-
-<multi_dimensional_size> ::= <positive-integer_literal> "x" <positive-integer_literal> ("x" <positive-integer_literal>)*
-
-<map> ::= "{}"
-            |"{" <map_elements> "}"
-            | "map(" <map_elements> ")"
-
-<map_elements> ::= <name> <type> ("," <name> <type>)*
-
-<set> ::= "set<" <type> ">"
-
-<collection ::= "collection<" <type> ">"
-
-<name> ::= <identifier> ":"
-
-<identifier> ::= [a-zA-Z_][a-zA-Z0-9_]*
-
-<positive-integer_literal> ::= [1-9][0-9]*
-```
-
-
-Examples of types:
-   "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
-   "[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 | 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
-*/
+ *
+ * ```bnf
+ * <type> ::= <union_type> | "(" <type> ")"
+ *
+ * <union_type> ::= <intersection_type> (" | " <intersection_type>)*
+ *
+ * <intersection_type> ::= <primary_type> (" & " <primary_type>)*
+ *
+ * <primary_type> ::=  <primitive>
+ *                | <tuple_type>
+ *                | <signature>
+ *                | <list_type>
+ *
+ * <primitive> ::= "any" | "unknown" | <value-type> | <symbolic-type> | <numeric-type>
+ *
+ * <numeric-type> ::= "number" | "complex" | "imaginary" | "real" | "rational" | "integer"
+ *
+ * <value-type> ::= "value" | <numeric-type> | "collection" | "boolean" | "string"
+ *
+ * <symbolic-type> ::= "expression" | "function" | "symbol"
+ *
+ * <tuple_type> ::= "tuple<" (<name> <type> "," <named_tuple_elements>*) ">"
+ *            | "tuple<" (<type> "," <unnamed_tuple_elements>*) ">" |
+ *            | "tuple<" <tuple_elements> ">"
+ *
+ * <tuple_elements> ::= <unnamed_tuple_elements> | <named_tuple_elements>
+ *
+ * <unnamed_tuple_elements> ::= <type> ("," <type>)*
+ *
+ * <named_tuple_elements> ::= <name> <type> ("," <name> <type>)*
+ *
+ * <signature> ::=  <arguments> " -> " <type>
+ *
+ * <arguments> ::= "()"
+ *            | <argument>
+ *            | "(" <argument-list> ")"
+ *
+ * <argument> ::= <type>
+ *            | <name> <type>
+ *
+ * <rest_argument> ::= "..." <type>
+ *            | <name> "..." <type>
+ *
+ * <optional_argument> ::= <argument> "?"
+ *
+ * <optional_arguments> ::= <optional_argument> ("," <optional_argument>)*
+ *
+ * <required_arguments> ::= <argument> ("," <argument>)*
+ *
+ * <argument-list> ::= <required_arguments> ("," <rest_argument>)?
+ *            | <required_arguments> <optional_arguments>?
+ *            | <optional_arguments>?
+ *            | <rest_argument>
+ *
+ * <list_type> ::= "list<" <type> <dimensions>? ">"
+ *
+ * <dimensions> ::= "^" <fixed_size>
+ *            | "^(" <multi_dimensional_size> ")"
+ *
+ * <fixed_size> ::= <positive-integer_literal>
+ *
+ * <multi_dimensional_size> ::= <positive-integer_literal> "x" <positive-integer_literal> ("x" <positive-integer_literal>)*
+ *
+ * <map> ::= "map" | "map<" <map_elements> ">"
+ *
+ * <map_elements> ::= <name> <type> ("," <name> <type>)*
+ *
+ * <set> ::= "set<" <type> ">"
+ *
+ * <collection ::= "collection<" <type> ">"
+ *
+ * <name> ::= <identifier> ":"
+ *
+ * <identifier> ::= [a-zA-Z_][a-zA-Z0-9_]*
+ *
+ * <positive-integer_literal> ::= [1-9][0-9]*
+ *```
+ *
+ * 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
+ * - `"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 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 signature and a primitive type
+ */
 export type TypeString = string;
 export type TypeCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
 export type TypeResolver = (name: string) => Type | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.29.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.27.0 */
+/* 0.29.0 */
 export declare function hidePrivateProperties(obj: any): void;

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.29.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,10 +1,11 @@
-/* 0.27.0 */
+/* 0.29.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 type { SerializeLatexOptions } from '../latex-syntax/public';
+import type { Type, TypeString } from '../../common/type/types';
+import { BoxedType } from '../../common/type/boxed-type';
+import type { BoxedSubstitution, Metadata, RuntimeScope, Substitution, CanonicalOptions, BoxedRuleSet, Rule, BoxedBaseDefinition, BoxedSymbolDefinition, BoxedFunctionDefinition, EvaluateOptions, CompiledType, Sign, BoxedExpression, JsonSerializationOptions, PatternMatchOptions, SimplifyOptions, TensorData, ComputeEngine } from '../global-types';
+import type { NumericValue } from '../numeric-value/types';
+import type { SmallInteger } from '../numerics/types';
+import type { LatexString, SerializeLatexOptions } from '../latex-syntax/types';
 import { AsciiMathOptions } from './ascii-math';
 /**
  * _BoxedExpression
@@ -18,12 +19,12 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     abstract get isCanonical(): boolean;
     abstract set isCanonical(_val: boolean);
     abstract match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
-    readonly engine: IComputeEngine;
+    readonly engine: ComputeEngine;
     /** Verbatim LaTeX, obtained from a source, i.e. from parsing,
      *  not generated synthetically
      */
     verbatimLatex?: string;
-    constructor(ce: IComputeEngine, metadata?: Metadata);
+    constructor(ce: ComputeEngine, metadata?: Metadata);
     isSame(rhs: BoxedExpression): boolean;
     isEqual(rhs: number | BoxedExpression): boolean | undefined;
     isLess(_rhs: number | BoxedExpression): boolean | undefined;
@@ -60,7 +61,7 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     get latex(): LatexString;
     set latex(val: LatexString);
     get symbol(): string | null;
-    get tensor(): null | AbstractTensor<'expression'>;
+    get tensor(): null | TensorData<'expression'>;
     get string(): string | null;
     getSubexpressions(operator: MathJsonIdentifier): ReadonlyArray<BoxedExpression>;
     get subexpressions(): ReadonlyArray<BoxedExpression>;
@@ -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,15 +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(options?: {
         to?: 'javascript';
-        optimize?: ('simplify' | 'evaluate')[];
         functions?: Record<MathJsonIdentifier, string | ((...any: any[]) => any)>;
         vars?: Record<MathJsonIdentifier, string>;
-        imports?: Function[];
+        imports?: ((...any: any[]) => any)[];
         preamble?: string;
-    }): (args: Record<string, any>) => any | undefined;
+    }): (args: Record<string, any>) => CompiledType;
     get isCollection(): boolean;
     contains(_rhs: BoxedExpression): boolean;
     subsetOf(_target: BoxedExpression, _strict: boolean): boolean;
@@ -163,5 +164,3 @@ 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 { AbstractTensor } from '../tensor/tensors';

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

@@ -1,5 +1,5 @@
-/* 0.27.0 */
+/* 0.29.0 */
 import { Decimal } from 'decimal.js';
-import type { BoxedExpression } from '../public';
+import type { BoxedExpression } from '../global-types';
 export declare function apply(expr: BoxedExpression, fn: (x: number) => number | Complex, bigFn?: (x: Decimal) => Decimal | Complex | number, complexFn?: (x: Complex) => number | Complex): BoxedExpression | undefined;
 export declare function apply2(expr1: BoxedExpression, expr2: BoxedExpression, fn: (x1: number, x2: number) => number | Complex, bigFn?: (x1: Decimal, x2: Decimal) => Decimal | Complex | number, complexFn?: (x1: Complex, x2: number | Complex) => Complex | number): BoxedExpression | undefined;

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

@@ -1,5 +1,6 @@
-/* 0.27.0 */
-import { Type } from '../../common/type/types';
+/* 0.29.0 */
+import { BoxedType } from '../../common/type/boxed-type';
+import type { BoxedExpression, ComputeEngine } from '../global-types';
 /**
  *
  * The canonical form of `Add`:
@@ -9,7 +10,7 @@ import { Type } from '../../common/type/types';
  * - sort the terms
  *
  */
-export declare function canonicalAdd(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression;
-export declare function addType(args: ReadonlyArray<BoxedExpression>): Type;
+export declare function canonicalAdd(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression;
+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-mul-div.d.ts

@@ -0,0 +1,27 @@
+/* 0.29.0 */
+/**
+ * Canonical form of 'Divide' (and 'Rational')
+ * - remove denominator of 1
+ * - simplify the signs
+ * - factor out negate (make the numerator and denominator positive)
+ * - if numerator and denominator are integer literals, return a rational number
+ *   or Rational expression
+ * - evaluate number literals
+ */
+export declare function canonicalDivide(op1: BoxedExpression, op2: BoxedExpression): BoxedExpression;
+export declare function div(num: BoxedExpression, denom: number | BoxedExpression): BoxedExpression;
+/**
+ * The canonical form of `Multiply`:
+ * - removes `1` anb `-1`
+ * - simplifies the signs:
+ *    - i.e. `-y \times -x` -> `x \times y`
+ *    - `2 \times -x` -> `-2 \times x`
+ * - arguments are sorted
+ * - complex numbers promoted (['Multiply', 2, 'ImaginaryUnit'] -> 2i)
+ * - Numeric values are promoted (['Multiply', 2, 'Sqrt', 3] -> 2√3)
+ *
+ * The input ops may not be canonical, the result is canonical.
+ */
+export declare function canonicalMultiply(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression;
+export declare function mul(...xs: ReadonlyArray<BoxedExpression>): BoxedExpression;
+export declare function mulN(...xs: ReadonlyArray<BoxedExpression>): BoxedExpression;

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

@@ -1,5 +1,5 @@
-/* 0.27.0 */
-import type { Rational } from '../numerics/rationals';
+/* 0.29.0 */
+import type { Rational } from '../numerics/types';
 export declare function asRadical(expr: BoxedExpression): Rational | null;
 export declare function canonicalPower(a: BoxedExpression, b: BoxedExpression): BoxedExpression;
 export declare function canonicalRoot(a: BoxedExpression, b: BoxedExpression | number): BoxedExpression;

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.29.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,8 +1,8 @@
-/* 0.27.0 */
+/* 0.29.0 */
 import { Decimal } from 'decimal.js';
-import { IComputeEngine, SemiBoxedExpression, BoxedExpression, Metadata, CanonicalOptions } from './public';
+import type { SemiBoxedExpression, BoxedExpression, CanonicalOptions, ComputeEngine, Metadata } from '../global-types';
 import { MathJsonIdentifier } from '../../math-json/types';
-import { NumericValue } from '../numeric-value/public';
+import { NumericValue } from '../numeric-value/types';
 /**
  * Given a name and a set of arguments, return a boxed function expression.
  *
@@ -10,7 +10,7 @@ import { NumericValue } from '../numeric-value/public';
  *
  * Note that `boxFunction()` should only be called from `ce.function()`
  */
-export declare function boxFunction(ce: IComputeEngine, name: MathJsonIdentifier, ops: readonly SemiBoxedExpression[], options?: {
+export declare function boxFunction(ce: ComputeEngine, name: MathJsonIdentifier, ops: readonly SemiBoxedExpression[], options?: {
     metadata?: Metadata;
     canonical?: CanonicalOptions;
     structural?: boolean;
@@ -40,7 +40,7 @@ export declare function boxFunction(ce: IComputeEngine, name: MathJsonIdentifier
  * Note that this function should only be called from `ce.box()`
  *
  */
-export declare function box(ce: IComputeEngine, expr: null | undefined | NumericValue | SemiBoxedExpression, options?: {
+export declare function box(ce: ComputeEngine, expr: null | undefined | NumericValue | SemiBoxedExpression, options?: {
     canonical?: CanonicalOptions;
     structural?: boolean;
 }): BoxedExpression;