@cortex-js/compute-engine 0.10.0 → 0.12.0

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

@@ -1,4 +1,4 @@
-/* 0.10.0 */
+/* 0.12.0 */
  * The most important classes are {@link ComputeEngine} and
  * {@link BoxedExpression}.
  *
@@ -9,15 +9,14 @@
  */
 import type { Decimal } from 'decimal.js';
 import type { Complex } from 'complex.js';
-import type { SignalMessage, WarningSignal, WarningSignalHandler } from '../common/signals';
 import type { Expression, MathJsonDictionary, MathJsonFunction, MathJsonNumber, MathJsonString, MathJsonSymbol } from '../math-json/math-json-format';
 import type { NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
 export * from './latex-syntax/public';
-export declare type Rational = [number, number] | [Decimal, Decimal];
+export type Rational = [number, number] | [bigint, bigint];
 /**
  * Metadata that can be associated with a `BoxedExpression`
  */
-export declare type Metadata = {
+export type Metadata = {
     latex?: string | undefined;
     wikidata?: string | undefined;
 };
@@ -35,9 +34,9 @@ export declare type Metadata = {
 
 </div>
  */
-export declare type NumericMode = 'auto' | 'machine' | 'bignum' | 'complex';
+export type NumericMode = 'auto' | 'machine' | 'bignum' | 'complex';
 /** Options for `BoxedExpression.simplify()` */
-export declare type SimplifyOptions = EvaluateOptions & {
+export type SimplifyOptions = EvaluateOptions & {
     recursive?: boolean;
     rules?: BoxedRuleSet;
 };
@@ -45,12 +44,12 @@ export declare type SimplifyOptions = EvaluateOptions & {
  *
  * @internal
  */
-export declare type EvaluateOptions = {};
+export type EvaluateOptions = {};
 /** Options for `BoxedExpression.N()`
  * @internal
  */
-export declare type NOptions = {};
-export declare type ReplaceOptions = {
+export type NOptions = {};
+export type ReplaceOptions = {
     /** If `true`, apply replacement rules to all sub-expressions.
      * If `false`, only consider the top-level expression.
      *
@@ -82,16 +81,14 @@ export declare type ReplaceOptions = {
  * A substitution can also be considered a more constrained version of a
  * rule whose `lhs` is always a symbol.
  */
-export declare type Substitution = {
-    [symbol: string]: SemiBoxedExpression;
-};
-export declare type BoxedSubstitution = {
-    [symbol: string]: BoxedExpression;
+export type Substitution<T = SemiBoxedExpression> = {
+    [symbol: string]: T;
 };
+export type BoxedSubstitution = Substitution<BoxedExpression>;
 /** A LaTeX string starts and end with `$`, for example
  * `"$\frac{\pi}{2}$"`.
  */
-export declare type LatexString = string;
+export type LatexString = string;
 /**
  *  A rule describes how to modify an expressions that matches a `lhs` pattern
  * into a new expressions matching `rhs`.
@@ -112,7 +109,7 @@ export declare type LatexString = string;
  *  - `__1` (`__a`, etc..) match a sequence of one or more expressions
  *  - `___1` (`___a`, etc...) match a sequence of zero or more expressions
  */
-export declare type Rule = [
+export type Rule = [
     lhs: LatexString | SemiBoxedExpression | Pattern,
     rhs: LatexString | SemiBoxedExpression,
     options?: {
@@ -120,18 +117,18 @@ export declare type Rule = [
         priority?: number;
     }
 ];
-export declare type BoxedRule = [
+export type BoxedRule = [
     lhs: Pattern,
     rhs: BoxedExpression,
     priority: number,
     condition: undefined | ((wildcards: BoxedSubstitution) => boolean)
 ];
-export declare type BoxedRuleSet = Set<BoxedRule>;
-export declare type DomainCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
+export type BoxedRuleSet = Set<BoxedRule>;
+export type DomainCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
 /** A domain constructor is the head of a domain expression. */
-export declare type DomainConstructor = 'Error' | 'Matrix' | 'SquareMatrix' | 'Vector' | 'Function' | 'List' | 'Dictionary' | 'Tuple' | 'Range' | 'Interval' | 'Intersection' | 'Union' | 'Maybe' | 'Sequence' | 'Head' | 'Symbol' | 'Value' | 'Covariant' | 'Contravariant' | 'Bivariant' | 'Invariant';
-export declare type DomainLiteral = string;
-export declare type DomainExpression<T = SemiBoxedExpression> = DomainLiteral | [DomainConstructor, ...(string | T | DomainExpression<T>)[]] | ['Error', T] | ['Error', T, T] | ['Union', ...DomainExpression<T>[]] | ['Intersection', ...DomainExpression<T>[]] | ['Matrix', DomainExpression<T>, T, T] | ['SquareMatrix', DomainExpression<T>, T] | ['Vector', DomainExpression<T>, T] | ['List', DomainExpression<T>] | ['Dictionary', DomainExpression<T>] | ['Tuple', ...DomainExpression<T>[]] | ['Maybe', DomainExpression<T>] | ['Sequence', DomainExpression<T>] | ['Range'] | ['Range', T] | ['Range', T, T] | ['Range', T, T, T] | ['Interval', T, T] | ['Interval', ['Open', T], T] | ['Interval', T, ['Open', T]] | ['Interval', ['Open', T], ['Open', T]] | ['Value', T] | ['Head', string] | ['Symbol', string] | ['Covariant', DomainExpression<T>] | ['Contravariant', DomainExpression<T>] | ['Bivariant', DomainExpression<T>] | ['Invariant', DomainExpression<T>] | ['Function', ...DomainExpression<T>[]];
+export type DomainConstructor = 'Error' | 'Matrix' | 'SquareMatrix' | 'Vector' | 'Function' | 'List' | 'Dictionary' | 'Tuple' | 'Range' | 'Interval' | 'Intersection' | 'Union' | 'Maybe' | 'Sequence' | 'Head' | 'Symbol' | 'Value' | 'Covariant' | 'Contravariant' | 'Bivariant' | 'Invariant';
+export type DomainLiteral = string;
+export type DomainExpression<T = SemiBoxedExpression> = DomainLiteral | [DomainConstructor, ...(string | T | DomainExpression<T>)[]] | ['Error', T] | ['Error', T, T] | ['Union', ...DomainExpression<T>[]] | ['Intersection', ...DomainExpression<T>[]] | ['Matrix', DomainExpression<T>, T, T] | ['SquareMatrix', DomainExpression<T>, T] | ['Vector', DomainExpression<T>, T] | ['List', DomainExpression<T>] | ['Dictionary', DomainExpression<T>] | ['Tuple', ...DomainExpression<T>[]] | ['Maybe', DomainExpression<T>] | ['Sequence', DomainExpression<T>] | ['Range'] | ['Range', T] | ['Range', T, T] | ['Range', T, T, T] | ['Interval', T, T] | ['Interval', ['Open', T], T] | ['Interval', T, ['Open', T]] | ['Interval', ['Open', T], ['Open', T]] | ['Value', T] | ['Head', string] | ['Symbol', string] | ['Covariant', DomainExpression<T>] | ['Contravariant', DomainExpression<T>] | ['Bivariant', DomainExpression<T>] | ['Invariant', DomainExpression<T>] | ['Function', ...DomainExpression<T>[]];
 export interface BoxedDomain extends BoxedExpression {
     is(s: BoxedDomain): boolean;
     /** True if a valid domain, and compatible with `dom` */
@@ -176,7 +173,7 @@ export interface BoxedDomain extends BoxedExpression {
 /**
  * Options to control the serialization to MathJSON when using `BoxedExpression.json`.
  */
-export declare type JsonSerializationOptions = {
+export type JsonSerializationOptions = {
     /** A list of space separated function names that should be excluded from
      * the JSON output.
      *
@@ -352,7 +349,12 @@ export interface BoxedExpression {
      * **Note** applicable to canonical and non-canonical expressions.
      *
      */
-    readonly symbols: BoxedExpression[];
+    readonly symbols: string[];
+    /**
+     * All the free variables in the expression, recursively,
+     * that is all the symbols with no value
+     */
+    readonly freeVars: string[];
     /** All the `["Error"]` subexpressions
      *
      * **Note** applicable to canonical and non-canonical expressions.
@@ -987,8 +989,8 @@ export interface BoxedExpression {
  * This is convenient when creating new expressions from portions
  * of an existing `BoxedExpression` while avoiding unboxing and reboxing.
  */
-export declare type SemiBoxedExpression = number | string | Decimal | Complex | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | SemiBoxedExpression[] | BoxedExpression;
-export declare type PatternMatchOptions = {
+export type SemiBoxedExpression = number | string | Decimal | Complex | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | SemiBoxedExpression[] | BoxedExpression;
+export type PatternMatchOptions = {
     substitution?: BoxedSubstitution;
     recursive?: boolean;
     numericTolerance?: number;
@@ -1009,27 +1011,31 @@ export interface ExpressionMapInterface<U> {
     [Symbol.iterator](): IterableIterator<[BoxedExpression, U]>;
 }
 /**
- * A symbol table contains definitions for symbols, functions and rules.
+ * An ID table contains definitions for symbols and functions.
+ *
+ * The index of the table is an identifier, the  name of the symbol or
+ * function for this definition
+ *
+ * The name of a symbol or function is an arbitrary string of Unicode
+ * characters, however the following conventions are recommended:
+ *
+ * - Use only letters, digits and `-`: `/[a-zA-Z0-9-]+/`
+ * - The first character should be a letter: `/^[a-zA-Z]/`
+ * - Functions and symbols exported from a library should start with an uppercase letter `/^[A-Z]/`
  *
  */
-export declare type SymbolTable = {
-    symbols?: SymbolDefinition[];
-    functions?: FunctionDefinition[];
-    simplifyRules?: BoxedRuleSet;
+export type IdTable = {
+    [id: string]: SymbolDefinition | FunctionDefinition;
 };
 /**
- * The entries of a `RuntimeSymbolTable` have been validated and
+ * The entries of a `RuntimeIdentifierTable` have been validated and
  * optimized for faster evaluation.
  *
  * When a new scope is created with `pushScope()` or when creating a new
- * engine instance, new instances of `RuntimeDictionary` are created as needed.
+ * engine instance, new instances of `RuntimeIdentifierTable` are created
+ * as needed.
  */
-export declare type RuntimeSymbolTable = {
-    symbols: Map<string, BoxedSymbolDefinition>;
-    symbolWikidata: Map<string, BoxedSymbolDefinition>;
-    functions: Map<string, BoxedFunctionDefinition>;
-    functionWikidata: Map<string, BoxedFunctionDefinition>;
-};
+export type RuntimeIdentifierTable = Map<string, BoxedSymbolDefinition | BoxedFunctionDefinition>;
 /**
  * A scope is a set of names in a dictionary that are bound (defined) in
  * a MathJSON expression.
@@ -1045,38 +1051,35 @@ export declare type RuntimeSymbolTable = {
  * where they are in an expression, they are not determined at runtime.
  *
  */
-export declare type Scope = {
-    /** This handler is invoked when exiting this scope if there are any
-     * warnings pending. */
-    warn?: WarningSignalHandler;
+export type Scope = {
     /** Signal `timeout` when the execution time for this scope is exceeded.
      * Time in seconds, default 2s.
      *
      * @experimental
      */
-    timeLimit?: number;
+    timeLimit: number;
     /** Signal `out-of-memory` when the memory usage for this scope is exceeded.
      * Memory in Megabytes, default: 1Mb.
      *
      * @experimental
      */
-    memoryLimit?: number;
+    memoryLimit: number;
     /** Signal `recursion-depth-exceeded` when the recursion depth for this
      * scope is exceeded.
      *
      * @experimental
      */
-    recursionLimit?: number;
+    recursionLimit: number;
     /** Signal `iteration-limit-exceeded` when the iteration limit for this
      * scope is exceeded. Default: no limits.
      *
      * @experimental
      */
-    iterationLimit?: number;
+    iterationLimit: number;
 };
-export declare type RuntimeScope = Scope & {
+export type RuntimeScope = Scope & {
     parentScope?: RuntimeScope;
-    symbolTable?: RuntimeSymbolTable;
+    idTable?: RuntimeIdentifierTable;
     assumptions: undefined | ExpressionMapInterface<boolean>;
     /** The location of the call site that created this scope */
     origin?: {
@@ -1086,21 +1089,8 @@ export declare type RuntimeScope = Scope & {
     };
     /** Free memory should not go below this level for execution to proceed */
     lowWaterMark?: number;
-    /** Set when one or more warnings have been signaled in this scope */
-    warnings?: WarningSignal[];
 };
-export declare type BaseDefinition = {
-    /** The name of the symbol or function for this definition
-     *
-     * The name of a symbol or function is an arbitrary string of Unicode
-     * characters, however the following conventions are recommended:
-     *
-     * - Use only letters, digits and `-`: `/[a-zA-Z0-9-]+/`
-     * - The first character should be a letter: `/^[a-zA-Z]/`
-     * - Functions and symbols exported from a library should start with an uppercase letter `/^[A-Z]/`
-     *
-     */
-    name: string;
+export type BaseDefinition = {
     /** A short (about 1 line) description. May contain Markdown. */
     description?: string | string[];
     /** A URL pointing to more information about this symbol or head. */
@@ -1133,7 +1123,7 @@ export interface BoxedBaseDefinition {
  * A function definition can have some flags to indicate specific
  * properties of the function.
  */
-export declare type FunctionDefinitionFlags = {
+export type FunctionDefinitionFlags = {
     /**  If `true`, the function is applied element by element to lists, matrices
      * (`["List"]` or `["Tuple"]` expressions) and equations (relational
      * operators).
@@ -1220,7 +1210,7 @@ export declare type FunctionDefinitionFlags = {
 /**
  *
  */
-export declare type FunctionSignature = {
+export type FunctionSignature = {
     /** The domain of this signature, a domain compatible with the `Function`
      * domain) */
     domain?: BoxedDomain | DomainExpression;
@@ -1250,7 +1240,10 @@ export declare type FunctionSignature = {
      * arguments should be sorted in canonical order.
      *
      * The handler can make transformations based on the value of the arguments
-     * that are exact (i.e. `arg.isExact`).
+     * that are exact and literal
+     * (i.e. `arg.numericValue !== null && arg.isExact`).
+     *
+     * Values of symbols should not be substituted.
      *
      * The handler should not consider the value or any assumptions about any
      * of the arguments that are symbols or functions (i.e. `arg.isZero`,
@@ -1364,7 +1357,7 @@ export declare type FunctionSignature = {
     /** Return a compiled (optimized) expression. */
     compile?: (expr: BoxedExpression) => CompiledExpression;
 };
-export declare type BoxedFunctionSignature = {
+export type BoxedFunctionSignature = {
     domain: BoxedDomain;
     codomain?: BoxedDomain | ((ce: IComputeEngine, args: BoxedExpression[]) => BoxedDomain | null);
     canonical?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | null;
@@ -1379,7 +1372,7 @@ export declare type BoxedFunctionSignature = {
  * Definition record for a function.
  *
  */
-export declare type FunctionDefinition = BaseDefinition & Partial<FunctionDefinitionFlags> & {
+export type FunctionDefinition = BaseDefinition & Partial<FunctionDefinitionFlags> & {
     /**
      * A number used to order arguments.
      *
@@ -1414,7 +1407,7 @@ export declare type FunctionDefinition = BaseDefinition & Partial<FunctionDefini
     hold?: 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
     signature?: FunctionSignature;
 };
-export declare type BoxedFunctionDefinition = BoxedBaseDefinition & FunctionDefinitionFlags & {
+export type BoxedFunctionDefinition = BoxedBaseDefinition & FunctionDefinitionFlags & {
     complexity: number;
     hold: 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
     signature: BoxedFunctionSignature;
@@ -1428,7 +1421,7 @@ export declare type BoxedFunctionDefinition = BoxedBaseDefinition & FunctionDefi
  * For example, it might be useful to override `algebraic = false`
  * for a transcendental number.
  */
-export declare type SymbolFlags = {
+export type SymbolFlags = {
     number: boolean | undefined;
     integer: boolean | undefined;
     rational: boolean | undefined;
@@ -1454,42 +1447,61 @@ export declare type SymbolFlags = {
     prime: boolean | undefined;
     composite: boolean | undefined;
 };
-export declare type SymbolDefinitionFlags = {
+export type SymbolAttributes = {
     /**
-     * If true the value of the symbol is constant.
+     * If `true` the value of the symbol is constant. The value or domain of
+     * symbols with this attribute set to `true` cannot be changed.
      *
-     * If false, the symbol is a variable.
+     * If `false`, the symbol is a variable.
+     *
+     * **Default**: `false`
      */
     constant: boolean;
     /**
-     * If `false`, the value of the symbol is substituted during canonicalization
-     * or simplification.
-     *
-     * If true, the value is only replaced during a `ce.N()` or `ce.evaluate()`.
-     *
-     * **Default:** `true`
-     */
-    hold: boolean;
+     * If the symbol has a value, it is held as indicated in the table below.
+     * A green checkmark indicate that the symbol is substituted.
+  
+  <div class=symbols-table>
+  
+  | Operation | `"never"` | `"simplify"` | `"evaluate"` | `"N"` |
+  | :--- | :----- |
+  | `canonical()`|  (X) | | | |
+  | `simplify()` |   (X) | (X) | | |
+  | `evaluate()` |   (X) | (X) | (X) | |
+  | `"N()"` |  (X) | (X)  |  (X) | (X)  |
+  
+  </div>
+  
+    * Some examples:
+    * - `i` has `holdUntil: 'never'`
+    * - `GoldenRatio` has `holdUntil: 'simplify'` (symbolic constant)
+    * - `x` has `holdUntil: 'evaluate'` (variables)
+    * - `Pi` has `holdUntil: 'N'` (special numeric constant)
+    *
+    * **Default:** `simplify`
+    */
+    holdUntil: 'never' | 'simplify' | 'evaluate' | 'N';
 };
 /**
  * A bound symbol (i.e. one with an associated definition) has either a domain
  * (e.g. ∀ x ∈ ℝ), a value (x = 5) or both (π: value = 3.14... domain = TranscendentalNumber)
  */
-export declare type SymbolDefinition = BaseDefinition & Partial<SymbolFlags> & Partial<SymbolDefinitionFlags> & {
+export type SymbolDefinition = BaseDefinition & Partial<SymbolAttributes> & {
+    domain?: string | BoxedDomain;
     /** `value` can be a function since for some constants, such as
      * `Pi`, the actual value depends on the `precision` setting of the
      * `ComputeEngine` */
     value?: LatexString | SemiBoxedExpression | ((ce: IComputeEngine) => SemiBoxedExpression | null);
-    domain?: string | BoxedDomain;
+    flags?: Partial<SymbolFlags>;
 };
-export interface BoxedSymbolDefinition extends BoxedBaseDefinition, Partial<SymbolFlags>, SymbolDefinitionFlags {
+export interface BoxedSymbolDefinition extends BoxedBaseDefinition, SymbolAttributes, Partial<SymbolFlags> {
     get value(): BoxedExpression | undefined;
     set value(val: SemiBoxedExpression | number | undefined);
     domain: BoxedDomain | undefined;
     at?: (index: string | number) => undefined | BoxedExpression;
 }
-export declare type AssumeResult = 'internal-error' | 'not-a-predicate' | 'contradiction' | 'tautology' | 'ok';
-export declare type CompiledExpression = {
+export type AssumeResult = 'internal-error' | 'not-a-predicate' | 'contradiction' | 'tautology' | 'ok';
+export type CompiledExpression = {
     evaluate?: (scope: {
         [symbol: string]: BoxedExpression;
     }) => number | BoxedExpression;
@@ -1554,7 +1566,7 @@ export interface IComputeEngine {
     chop(n: Complex): Complex | 0;
     chop(n: number | Decimal | Complex): number | Decimal | Complex;
     /** @internal */
-    bignum: (a: Decimal.Value) => Decimal;
+    bignum: (a: Decimal.Value | bigint) => Decimal;
     /** @internal */
     complex: (a: number | Complex, b?: number) => Complex;
     set precision(p: number | 'machine');
@@ -1573,13 +1585,13 @@ export interface IComputeEngine {
      *
      * If a definition existed previously, it is replaced.
      */
-    defineSymbol(def: SymbolDefinition): BoxedSymbolDefinition;
+    defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
     /**
      * Associate a new definition to a function in the current context.
      *
      * If a definition existed previously, it is replaced.
      */
-    defineFunction(def: FunctionDefinition): BoxedFunctionDefinition;
+    defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
     lookupSymbol(name: string, wikidata?: string, scope?: RuntimeScope): undefined | BoxedSymbolDefinition;
     /** Return `undefined` if no definition exist for this `head` */
     lookupFunction(head: string | BoxedExpression, scope?: RuntimeScope | null): undefined | BoxedFunctionDefinition;
@@ -1589,8 +1601,9 @@ export interface IComputeEngine {
     box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression, options?: {
         canonical?: boolean;
     }): BoxedExpression;
+    canonical(xs: SemiBoxedExpression[]): BoxedExpression[];
     /** Return a boxed number */
-    number(value: number | string | MathJsonNumber | Decimal | Complex | [num: number, denom: number] | [num: Decimal, denom: Decimal], options?: {
+    number(value: number | bigint | string | MathJsonNumber | Decimal | Complex | Rational, options?: {
         metadata?: Metadata;
         canonical?: boolean;
     }): BoxedExpression;
@@ -1652,23 +1665,23 @@ export interface IComputeEngine {
      *
      * The result is canonical.
      */
-    power(base: BoxedExpression, exponent: number | Rational | BoxedExpression, metadata?: Metadata): BoxedExpression;
+    pow(base: BoxedExpression, exponent: number | Rational | BoxedExpression, metadata?: Metadata): BoxedExpression;
     sqrt(base: BoxedExpression, metadata?: Metadata): any;
     /** Shortcut for `this.fn("Divide", [1, expr])`
      *
      * The result is canonical.
      */
-    inverse(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    inv(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
     /** Shortcut for `this.fn("Negate", [expr])`
      *
      * The result is canonical.
      */
-    negate(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    neg(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
     /** Shortcut for `this.fn("Divide", [num, denom])`
      *
      * The result is canonical.
      */
-    divide(num: BoxedExpression, denom: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    div(num: BoxedExpression, denom: BoxedExpression, metadata?: Metadata): BoxedExpression;
     /** Shortcut for `this.fn("Pair"...)`
      *
      * The result is canonical.
@@ -1715,20 +1728,12 @@ export interface IComputeEngine {
     /** {@inheritDoc  JsonSerializationOptions} */
     get jsonSerializationOptions(): Readonly<JsonSerializationOptions>;
     set jsonSerializationOptions(val: Partial<JsonSerializationOptions>);
-    pushScope(options?: {
-        symbolTable?: Readonly<SymbolTable> | Readonly<SymbolTable>[];
-        assumptions?: (LatexString | Expression | BoxedExpression)[];
-        scope?: Partial<Scope>;
-    }): void;
+    pushScope(identifiers?: Readonly<IdTable> | Readonly<IdTable>[], scope?: Partial<Scope>): void;
     popScope(): void;
     /** Assign a value to an identifier in the current scope. Use `null` to reset the identifier to no value */
-    set(identifiers: {
-        [identifier: string]: SemiBoxedExpression | null;
-    }): void;
-    /** Declare identifiers (specify their domain without necessarily assigning them a value in the current scope*/
-    let(identifiers: {
-        [identifier: string]: SymbolDefinition | FunctionDefinition;
-    }): void;
+    set(identifiers: Substitution<SemiBoxedExpression | null | undefined>): void;
+    /** Declare identifiers (specify their domain without necessarily assigning them a value in the current scope) */
+    let(identifiers: IdTable): void;
     /**
      * Add an assumption.
      *
@@ -1751,16 +1756,6 @@ export interface IComputeEngine {
     forget(symbol?: string | string[]): void;
     get assumptions(): ExpressionMapInterface<boolean>;
     ask(pattern: LatexString | SemiBoxedExpression): BoxedSubstitution[];
-    /**
-     * When `condition` is false, signal.
-     *
-     * - `condition` - If `true`, do nothing. If `false`, signal.
-     *
-     * @experimental
-     */
-    assert(condition: boolean, expr: BoxedExpression, msg: string, code?: SignalMessage): any;
-    signal(expr: BoxedExpression, msg: string, code?: SignalMessage): void;
-    signal(sig: WarningSignal): void;
     /** @internal */
     shouldContinueExecution(): boolean;
     /** @internal */

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

@@ -1,4 +1,4 @@
-/* 0.10.0 */
+/* 0.12.0 */
 /**
  * Go through all the rules in the rule set, and for all the rules that match
  * return the rhs of the rule applied to `expr`.

package/dist/types/compute-engine/simplify-rules.d.ts

@@ -1,4 +1,4 @@
-/* 0.10.0 */
+/* 0.12.0 */
 /**
  * A set of simplification rules.
  *

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

@@ -1,4 +1,4 @@
-/* 0.10.0 */
+/* 0.12.0 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * Expression is a function of a single variable (`x`) or an Equality

package/dist/types/compute-engine/symbolic/expand.d.ts

@@ -1,4 +1,4 @@
-/* 0.10.0 */
+/* 0.12.0 */
 /**
  * Return the expansion of ['Multiply', lhs, rhs]
  * - lhs = 'a + b', rhs = '2'

package/dist/types/compute-engine/symbolic/flatten.d.ts

@@ -1,8 +1,9 @@
-/* 0.10.0 */
+/* 0.12.0 */
 /**
  * Flatten the arguments.
  * If `expr` was canonical, the result it canonical.
  */
 export declare function flatten(expr: BoxedExpression, head: string): BoxedExpression;
-export declare function flattenOps(ops: BoxedExpression[], head: string): BoxedExpression[] | null;
+export declare function flattenOps(ops: BoxedExpression[], head: string): BoxedExpression[];
 export declare function flattenSequence(xs: BoxedExpression[]): BoxedExpression[];
+export declare function canonical(xs: BoxedExpression[]): BoxedExpression[];

package/dist/types/compute-engine/symbolic/negate.d.ts

@@ -1,12 +1,10 @@
-/* 0.10.0 */
+/* 0.12.0 */
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an
- * addition or another `Negate`.
+ * addition or multiplication or another `Negate`.
  *
- * This is appropriate to call during a `canonical` chain.
- *
- * For more thorough distribution (including multiplication), see `distributeNegate`,
- * applicable  during a `simplify` or `evaluate` chain.
+ * It is important to do all these to handle cases like
+ * `-3x` -> ["Negate, ["Multiply", 3, "x"]] -> ["Multiply, -3, x]
  */
 export declare function canonicalNegate(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
 export declare function processNegate(_ce: IComputeEngine, x: BoxedExpression, _mode?: 'simplify' | 'evaluate' | 'N'): BoxedExpression;

package/dist/types/compute-engine/symbolic/polynomials.d.ts

@@ -1,4 +1,4 @@
-/* 0.10.0 */
+/* 0.12.0 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *
@@ -12,8 +12,8 @@
  * If a coefficient does not apply (there are no corresponding term), it is `null`.
  *
  */
-export declare type UnivariateCoefficients = (null | BoxedExpression)[];
-export declare type MultivariateCoefficients = (null | (null | BoxedExpression)[])[];
+export type UnivariateCoefficients = (null | BoxedExpression)[];
+export type MultivariateCoefficients = (null | (null | BoxedExpression)[])[];
 /**
  * Return a list of coefficient of powers of `vars` in `poly`,
  * starting with power 0.

package/dist/types/compute-engine/symbolic/product.d.ts

@@ -1,4 +1,4 @@
-/* 0.10.0 */
+/* 0.12.0 */
 /**
  * Group terms in a product by common term.
  *

package/dist/types/compute-engine/symbolic/sum.d.ts

@@ -1,14 +1,15 @@
-/* 0.10.0 */
+/* 0.12.0 */
 export declare class Sum {
     private engine;
+    private _isCanonical;
     private _rational;
     private _imaginary;
     private _number;
     private _bignum;
     private _posInfinityCount;
     private _negInfinityCount;
+    private _naNCount;
     private _terms;
-    private _isCanonical;
     constructor(ce: IComputeEngine, xs?: BoxedExpression[], options?: {
         canonical?: boolean;
     });

package/dist/types/compute-engine/symbolic/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.10.0 */
+/* 0.12.0 */
 import Decimal from 'decimal.js';
 import { BoxedExpression, Rational } from '../public';
 /**

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

@@ -1,4 +1,3 @@
-/* 0.10.0 */
+/* 0.12.0 */
 export { ComputeEngine } from './compute-engine/compute-engine';
-export declare const version = "0.10.0";
-export { getVars } from './compute-engine/boxed-expression/utils';
+export declare const version = "0.12.0";

package/dist/types/math-json/math-json-format.d.ts

@@ -1,4 +1,4 @@
-/* 0.10.0 */
+/* 0.12.0 */
     /** A human readable string to annotate this expression, since JSON does not
      * allow comments in its encoding */
     comment?: string;
@@ -78,19 +78,19 @@
  * - `1.(3)`
  * - `123456789123456789.123(4567)e999`
  */
-export declare type MathJsonNumber = {
+export type MathJsonNumber = {
     num: 'NaN' | '-Infinity' | '+Infinity' | string;
 } & Attributes;
-export declare type MathJsonSymbol = {
+export type MathJsonSymbol = {
     sym: string;
 } & Attributes;
-export declare type MathJsonString = {
+export type MathJsonString = {
     str: string;
 } & Attributes;
-export declare type MathJsonFunction = {
+export type MathJsonFunction = {
     fn: [Expression, ...Expression[]];
 } & Attributes;
-export declare type MathJsonDictionary = {
+export type MathJsonDictionary = {
     dict: {
         [key: string]: Expression;
     };
@@ -102,4 +102,4 @@ export declare type MathJsonDictionary = {
  * The dictionary and function nodes can contain expressions themselves.
  *
  */
-export declare type Expression = number | string | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | [Expression, ...Expression[]];
+export type Expression = number | string | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | [Expression, ...Expression[]];