@cortex-js/compute-engine 0.15.0 → 0.17.0

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

@@ -1,30 +1,27 @@
-/* 0.15.0 */
+/* 0.17.0 */
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, BoxedFunctionDefinition, IComputeEngine, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedSubstitution, EvaluateOptions } from '../public';
+import { BoxedExpression, BoxedFunctionDefinition, IComputeEngine, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedSubstitution, EvaluateOptions, BoxedBaseDefinition, Hold } from '../public';
 /**
  * BoxedFunction
  */
-export declare class BoxedFunction extends AbstractBoxedExpression {
-    private _scope;
+export declare class BoxedFunction extends _BoxedExpression {
     private readonly _head;
     private readonly _ops;
     private _canonical;
+    private _scope;
     private _def;
     private _isPure;
-    /** The domain of the value of the function applied to its arguments */
     private _codomain;
-    /** The cached values of applying the tail to the head.
-     * If the function is not pure, it is never cached.
-     */
     private _value;
     private _numericValue;
     private _hash;
     constructor(ce: IComputeEngine, head: string | BoxedExpression, ops: BoxedExpression[], options?: {
         metadata?: Metadata;
         canonical?: boolean;
-        def?: BoxedFunctionDefinition;
     });
     get hash(): number;
+    bind(): void;
+    reset(): void;
     get isCanonical(): boolean;
     set isCanonical(val: boolean);
     get isPure(): boolean;
@@ -48,13 +45,9 @@ export declare class BoxedFunction extends AbstractBoxedExpression {
     /** `isSame` is structural/symbolic equality */
     isSame(rhs: BoxedExpression): boolean;
     match(rhs: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
-    unbind(): void;
-    get wikidata(): string | undefined;
-    get description(): string[] | undefined;
-    get url(): string | undefined;
     get complexity(): number | undefined;
+    get baseDefinition(): BoxedBaseDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
-    bind(_scope: RuntimeScope | null): void;
     get value(): BoxedExpression | undefined;
     /** `isEqual` is mathematical equality */
     isEqual(rhs: BoxedExpression): boolean;
@@ -79,18 +72,13 @@ export declare class BoxedFunction extends AbstractBoxedExpression {
     get isComplex(): boolean | undefined;
     get isImaginary(): boolean | undefined;
     get sgn(): -1 | 0 | 1 | undefined | null;
-    get domain(): BoxedDomain;
+    get domain(): BoxedDomain | undefined;
     simplify(options?: SimplifyOptions): BoxedExpression;
     evaluate(options?: EvaluateOptions): BoxedExpression;
     N(options?: NOptions): BoxedExpression;
     solve(vars: string[]): null | BoxedExpression[];
 }
 export declare function makeCanonicalFunction(ce: IComputeEngine, head: string | BoxedExpression, ops: SemiBoxedExpression[], metadata?: Metadata): BoxedExpression;
-/** Apply arguments to an expression. If the expression is a lambda expression
- * its wildcard arguments are substituted before being evaluated. Otherwise
- * the expression is just evaluated.
- */
-export declare function apply(fn: BoxedExpression, args: BoxedExpression[]): BoxedExpression;
 /** Apply the function `f` to elements of `xs`, except to the elements
  * described by `skip`:
  * - `all`: don't apply f to any elements
@@ -104,4 +92,4 @@ export declare function apply(fn: BoxedExpression, args: BoxedExpression[]): Box
  *
  * If `f` returns `null`, the element is not added to the result
  */
-export declare function holdMap(xs: BoxedExpression[], skip: 'all' | 'none' | 'first' | 'rest' | 'last' | 'most', associativeHead: string, f: (x: BoxedExpression) => BoxedExpression | null): BoxedExpression[];
+export declare function holdMap(xs: BoxedExpression[], skip: Hold, associativeHead: string, f: (x: BoxedExpression) => BoxedExpression | null): BoxedExpression[];

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

@@ -1,12 +1,12 @@
-/* 0.15.0 */
-import { Complex } from 'complex.js';
+/* 0.17.0 */
+import { Decimal } from 'decimal.js';
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, NOptions, PatternMatchOptions, Rational, SimplifyOptions, BoxedSubstitution } from '../public';
-import { AbstractBoxedExpression } from './abstract-boxed-expression';
+import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, NOptions, PatternMatchOptions, Rational, SimplifyOptions, BoxedSubstitution, EvaluateOptions } from '../public';
+import { _BoxedExpression } from './abstract-boxed-expression';
 /**
  * BoxedNumber
  */
-export declare class BoxedNumber extends AbstractBoxedExpression {
+export declare class BoxedNumber extends _BoxedExpression {
     protected readonly _value: number | Decimal | Complex | Rational;
     private _domain;
     private _hash;
@@ -81,5 +81,6 @@ export declare class BoxedNumber extends AbstractBoxedExpression {
     get isExtendedComplex(): boolean | undefined;
     get canonical(): BoxedExpression;
     simplify(_options?: SimplifyOptions): BoxedExpression;
+    evaluate(options?: EvaluateOptions): BoxedExpression;
     N(_options?: NOptions): BoxedExpression;
 }

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

@@ -1,11 +1,11 @@
-/* 0.15.0 */
-import { AbstractBoxedExpression } from './abstract-boxed-expression';
+/* 0.17.0 */
+import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedExpression, BoxedSubstitution, BoxedDomain, IComputeEngine, LatexString, Metadata, Pattern, PatternMatchOptions, SemiBoxedExpression, Substitution } from '../public';
-export declare class BoxedPattern extends AbstractBoxedExpression implements Pattern {
+export declare class BoxedPattern extends _BoxedExpression implements Pattern {
     _pattern: BoxedExpression;
     constructor(ce: IComputeEngine, pattern: LatexString | SemiBoxedExpression, metadata?: Metadata);
     get hash(): number;
-    unbind(): void;
+    reset(): void;
     get json(): Expression;
     get head(): string | BoxedExpression;
     get domain(): BoxedDomain;

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

@@ -1,10 +1,10 @@
-/* 0.15.0 */
-import { AbstractBoxedExpression } from './abstract-boxed-expression';
+/* 0.17.0 */
+import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, PatternMatchOptions, BoxedSubstitution } from '../public';
 /**
  * BoxedString
  */
-export declare class BoxedString extends AbstractBoxedExpression {
+export declare class BoxedString extends _BoxedExpression {
     private readonly _string;
     constructor(ce: IComputeEngine, expr: string, metadata?: Metadata);
     get hash(): number;

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

@@ -1,6 +1,6 @@
-/* 0.15.0 */
+/* 0.17.0 */
 /**
- * THEORY OF OPERATIONS
+ * ## THEORY OF OPERATIONS
  *
  * - The value or domain of a constant cannot be changed.
  * - If set explicitly, the value is the source of truth: it overrides any
@@ -18,24 +18,25 @@
  * Otherwise, the stored flags are (the stored flags are also set when the domain is changed)
  *
  */
-export declare class BoxedSymbolDefinitionImpl implements BoxedSymbolDefinition {
+export declare class _BoxedSymbolDefinition implements BoxedSymbolDefinition {
     readonly name: string;
-    readonly wikidata?: string;
-    readonly description?: string | string[];
-    readonly url?: string;
+    wikidata?: string;
+    description?: string | string[];
+    url?: string;
     private _engine;
     readonly scope: RuntimeScope | undefined;
     private _defValue?;
     private _value;
     private _domain;
+    inferredDomain: boolean;
     private _flags;
-    readonly constant: boolean;
-    readonly holdUntil: 'never' | 'simplify' | 'evaluate' | 'N';
-    private _at;
-    at?: (index: string | number) => undefined | BoxedExpression;
+    constant: boolean;
+    holdUntil: 'never' | 'simplify' | 'evaluate' | 'N';
     prototype?: BoxedFunctionDefinition;
     self?: unknown;
     constructor(ce: IComputeEngine, name: string, def: SymbolDefinition);
+    /** 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);
@@ -89,6 +90,6 @@ export declare class BoxedSymbolDefinitionImpl implements BoxedSymbolDefinition
     set prime(val: boolean | undefined);
     get composite(): boolean | undefined;
     set composite(val: boolean | undefined);
-    updateFlags(flags: Partial<SymbolFlags>): void;
+    updateFlags(flags: Partial<NumericFlags>): void;
 }
-export declare function domainToFlags(dom: BoxedDomain | undefined | null): Partial<SymbolFlags>;
+export declare function domainToFlags(dom: BoxedDomain | undefined | null): Partial<NumericFlags>;

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

@@ -1,5 +1,7 @@
-/* 0.15.0 */
-import { AbstractBoxedExpression } from './abstract-boxed-expression';
+/* 0.17.0 */
+import { Decimal } from 'decimal.js';
+import { Expression } from '../../math-json/math-json-format';
+import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedFunctionDefinition, BoxedBaseDefinition, DomainExpression, BoxedSubstitution } from '../public';
 /**
  * BoxedSymbol
@@ -14,9 +16,9 @@ import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, E
  * not a function expression, i.e. `Sin`, not `["Sin", "Pi"]`. This is used
  * for example in `["InverseFunction", "Sin"]`
  */
-export declare class BoxedSymbol extends AbstractBoxedExpression {
+export declare class BoxedSymbol extends _BoxedExpression {
     private _scope;
-    protected _name: string;
+    protected _id: string;
     private _hash;
     private _def;
     constructor(ce: IComputeEngine, name: string, options?: {
@@ -25,19 +27,18 @@ export declare class BoxedSymbol extends AbstractBoxedExpression {
         def?: BoxedSymbolDefinition | BoxedFunctionDefinition;
     });
     get hash(): number;
-    unbind(): void;
     get isPure(): boolean;
     get json(): Expression;
     get scope(): RuntimeScope | null;
-    /** A free variable either has no definition, or it has a definition, but no value */
-    get isFree(): boolean;
     get isConstant(): boolean;
+    /**
+     * Associate a definition with this symbol
+     */
+    bind(): void;
+    reset(): void;
     get isCanonical(): boolean;
     set isCanonical(val: boolean);
     get canonical(): BoxedExpression;
-    get wikidata(): string | undefined;
-    get description(): string[] | undefined;
-    get url(): string | undefined;
     get complexity(): number;
     get head(): string;
     get symbol(): string;
@@ -45,12 +46,17 @@ export declare class BoxedSymbol extends AbstractBoxedExpression {
     get baseDefinition(): BoxedBaseDefinition | undefined;
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
-    bind(scope: RuntimeScope | null): void;
+    /**
+     * Subsequence inferences will narrow the domain of the symbol.
+     * f(:integer), g(:real)
+     * g(x) => x:real
+     * f(x) => x:integer narrowed from integer to real
+     */
+    infer(domain: BoxedDomain): boolean;
     get value(): BoxedExpression | undefined;
-    set value(value: BoxedExpression | number | undefined);
-    get domain(): BoxedDomain;
-    set domain(inDomain: BoxedExpression | DomainExpression | BoxedDomain);
-    get explicitDomain(): BoxedDomain | undefined;
+    set value(value: boolean | string | Decimal | Complex | [num: number, denom: number] | BoxedExpression | number | undefined);
+    get domain(): BoxedDomain | undefined;
+    set domain(inDomain: DomainExpression | BoxedDomain);
     get sgn(): -1 | 0 | 1 | undefined | null;
     has(x: string | string[]): boolean;
     isSame(rhs: BoxedExpression): boolean;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.17.0 */
 export type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
 export declare const DEFAULT_COMPLEXITY = 100000;
 /**

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

@@ -1,5 +1,5 @@
-/* 0.15.0 */
-import Decimal from 'decimal.js';
+/* 0.17.0 */
+import { Decimal } from 'decimal.js';
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, IComputeEngine, Metadata, Rational } from '../public';
 /**

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.17.0 */
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, IComputeEngine } from '../public';
 export declare function isLatexString(s: unknown): s is string;
@@ -12,15 +12,36 @@ export declare function latexString(s: unknown): string | null;
  * - ['Multiply', 'ImaginaryUnit', 5]
  */
 export declare function getImaginaryCoef(expr: BoxedExpression): number | null;
+export declare function getSymbols(expr: BoxedExpression, result: Set<string>): void;
 /**
- * Return the free symbols in the expression, recursively.
- * A variable, or free symbol, is a symbol that is not bound to a value.
- * Note: do not use `isFree`: it has a side effect of creating a definition
- * if one does not exist, and we want to avoid that. For example, `assume()`
- * relies on `expr.freeVars` *not* creating a definition.
- */
-export declare function getFreeVars(expr: BoxedExpression, set: Set<string>): void;
-export declare function getSymbols(expr: BoxedExpression, set: Set<string>): void;
+ * Return the unknowns in the expression, recursively.
+ *
+ * An unknown is an identifier (symbol or function) that is not bound
+ * to a value.
+ *
+ */
+export declare function getUnknowns(expr: BoxedExpression, result: Set<string>): void;
+/**
+ * Return the free variables (non local variable) in the expression,
+ * recursively.
+ *
+ * A free variable is an identifier that is not an argument to a function,
+ * or a local variable.
+ *
+ */
+export declare function getFreeVariables(expr: BoxedExpression, result: Set<string>): void;
+/** Return the local variables in the expression.
+ *
+ * A local variable is an identifier that is declared with a `Declare`
+ * expression in a `Block` expression.
+ *
+ * Note that the canonical form of a `Block` expression will hoist all
+ * `Declare` expressions to the top of the block. `Assign` expressions
+ * of undeclared variables will also have a matching `Declare` expressions
+ * hoisted.
+ *
+ */
+export declare function getLocalVariables(expr: BoxedExpression, result: Set<string>): void;
 export declare function getSubexpressions(expr: BoxedExpression, head: string): BoxedExpression[];
 /**
  * For any numeric result, if `bignumPreferred()` is true, calculate using

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

@@ -1,19 +1,39 @@
-/* 0.15.0 */
-export declare function validateArgumentCount(ce: IComputeEngine, ops: BoxedExpression[], count: number): BoxedExpression[];
+/* 0.17.0 */
+/**
+ * Check that the number of arguments is as expected.
+ *
+ * Converts the arguments to canonical, and flattens the sequence.
+ */
+export declare function checkArity(ce: IComputeEngine, ops: BoxedExpression[], count: number): BoxedExpression[];
 /**
  * Validation of arguments is normally done by checking the signature of the
  * function vs the arguments of the expression. However, we have a fastpath
  * for some common operations (add, multiply, power, neg, etc...) that bypasses
- * the regular checks. This is its replacements. Since all those fastpath
- * functions are numeric (i.e. have numeric arguments and return a numeric
- * value), we do a simple numeric check of all arguments, and verify we have
- * the number of expected arguments.
+ * the regular checks. This is its replacements.
+ *
+ * Since all those fastpath functions are numeric (i.e. have numeric arguments
+ * and a numeric result), we do a simple numeric check of all arguments, and
+ * verify we have the number of expected arguments.
+ *
+ * Converts the arguments to canonical, and flattens the sequence.
  */
-export declare function validateNumericArgs(ce: IComputeEngine, ops: BoxedExpression[], count?: number): BoxedExpression[];
-/** Return `null` if the `ops` match the sig. Otherwise, return an array
- * of expressions indicating the mismatched arguments.
+export declare function checkNumericArgs(ce: IComputeEngine, ops: BoxedExpression[], options?: number | {
+    count?: number;
+    flatten?: boolean | string;
+}): BoxedExpression[];
+/**
+ * Check that an argument is of the expected domain.
+ *
+ * Converts the arguments to canonical
+ */
+export declare function checkArg(ce: IComputeEngine, arg: BoxedExpression | undefined | null, dom: BoxedDomain | DomainLiteral | undefined): BoxedExpression;
+export declare function checkArgs(ce: IComputeEngine, args: BoxedExpression[], doms: (BoxedDomain | DomainLiteral)[]): BoxedExpression[];
+/**
+ *
+ * If the arguments match the parameters, return null.
+ *
+ * Otherwise return a list of expressions indicating the mismatched
+ * arguments.
  *
  */
-export declare function validateSignature(sig: BoxedDomain, ops: BoxedExpression[], codomain?: BoxedExpression): BoxedExpression[] | null;
-export declare function validateArgument(ce: IComputeEngine, arg: BoxedExpression | undefined, dom: BoxedDomain | DomainLiteral | undefined): BoxedExpression;
-export declare function validateArguments(ce: IComputeEngine, args: BoxedExpression[], doms: (BoxedDomain | DomainLiteral)[]): BoxedExpression[];
+export declare function adjustArguments(ce: IComputeEngine, ops: BoxedExpression[], hold: Hold, params: BoxedDomain[], optParams: BoxedDomain[], restParam: BoxedDomain | null): BoxedExpression[] | null;

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

@@ -1,10 +1,26 @@
-/* 0.15.0 */
+/* 0.17.0 */
+import { BoxedExpression } from './public';
 export type CompiledType = boolean | number | string | object;
+export type CompiledOperators = Record<MathJsonIdentifier, [
+    op: string,
+    prec: number
+]>;
+export type CompiledFunctions = {
+    [id: MathJsonIdentifier]: string | ((args: BoxedExpression[], compile: (expr: BoxedExpression) => CompiledType) => CompiledType);
+};
+export type CompileTarget = {
+    operators?: (op: MathJsonIdentifier) => [op: string, prec: number];
+    functions?: (id: MathJsonIdentifier) => string | ((...args: CompiledType[]) => CompiledType);
+    var: (id: MathJsonIdentifier) => string | undefined;
+    string: (str: string) => string;
+    number: (n: number) => string;
+};
 /** This is an extension of the Function class that allows us to pass
  * a custom scope for "global" functions. */
 export declare class ComputeEngineFunction extends Function {
     private sys;
     constructor(body: any);
 }
+export declare function compileToTarget(expr: BoxedExpression, target: CompileTarget): ((_: Record<string, CompiledType>) => CompiledType) | undefined;
 export declare function compileToJavascript(expr: BoxedExpression): ((_: Record<string, CompiledType>) => CompiledType) | undefined;
-export declare function compile(expr: BoxedExpression, freeVars?: string[], prec?: number): string;
+export declare function compile(expr: BoxedExpression, target: CompileTarget, prec?: number): CompiledType;

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

@@ -1,8 +1,8 @@
-/* 0.15.0 */
-import { Complex } from 'complex.js';
+/* 0.17.0 */
+import { Decimal } from 'decimal.js';
 import { Expression, MathJsonNumber } from '../math-json/math-json-format';
-import type { LibraryCategory, LatexDictionary, LatexDictionaryEntry, LatexString, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
-import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, IdTable, ExpressionMapInterface, NumericMode, Pattern, RuntimeScope, Scope, SemiBoxedExpression, SymbolDefinition, BoxedRuleSet, Rule, JsonSerializationOptions, ComputeEngineStats, Metadata, BoxedDomain, DomainExpression, FunctionDefinition, Rational, BoxedSubstitution, Substitution } from './public';
+import type { LibraryCategory, LatexDictionaryEntry, LatexString, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
+import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, IdentifierDefinitions, ExpressionMapInterface, NumericMode, Pattern, RuntimeScope, Scope, SemiBoxedExpression, SymbolDefinition, BoxedRuleSet, Rule, JsonSerializationOptions, ComputeEngineStats, Metadata, BoxedDomain, DomainExpression, FunctionDefinition, Rational, BoxedSubstitution, AssignValue, DomainLiteral } from './public';
 /**
  *
  * To use the CortexJS Compute Engine, create a `ComputeEngine` instance.
@@ -23,24 +23,25 @@ import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefi
  * ```
  */
 export declare class ComputeEngine implements IComputeEngine {
-    /** @internal */
-    readonly _ZERO: BoxedExpression;
-    /** @internal */
-    readonly _ONE: BoxedExpression;
-    /** @internal */
-    readonly _HALF: BoxedExpression;
-    /** @internal */
-    readonly _NEGATIVE_ONE: BoxedExpression;
-    /** @internal */
-    readonly _I: BoxedExpression;
-    /** @internal */
-    readonly _NAN: BoxedExpression;
-    /** @internal */
-    readonly _POSITIVE_INFINITY: BoxedExpression;
-    /** @internal */
-    readonly _NEGATIVE_INFINITY: BoxedExpression;
-    /** @internal */
-    readonly _COMPLEX_INFINITY: BoxedExpression;
+    readonly Anything: BoxedDomain;
+    readonly Void: BoxedDomain;
+    readonly Strings: BoxedDomain;
+    readonly Booleans: BoxedDomain;
+    readonly Numbers: BoxedDomain;
+    readonly True: BoxedExpression;
+    readonly False: BoxedExpression;
+    readonly Pi: BoxedExpression;
+    readonly E: BoxedExpression;
+    readonly Nothing: BoxedExpression;
+    readonly Zero: BoxedExpression;
+    readonly One: BoxedExpression;
+    readonly Half: BoxedExpression;
+    readonly NegativeOne: BoxedExpression;
+    readonly I: BoxedExpression;
+    readonly NaN: BoxedExpression;
+    readonly PositiveInfinity: BoxedExpression;
+    readonly NegativeInfinity: BoxedExpression;
+    readonly ComplexInfinity: BoxedExpression;
     /** @internal */
     _BIGNUM_NAN: Decimal;
     /** @internal */
@@ -93,8 +94,6 @@ export declare class ComputeEngine implements IComputeEngine {
     private _commonNumbers;
     /** @internal */
     private _commonDomains;
-    /** @internal */
-    private _latexDictionary?;
     /**
      * The current scope.
      *
@@ -121,19 +120,20 @@ export declare class ComputeEngine implements IComputeEngine {
      * manipulate them.
      *
      */
-    static getStandardLibrary(categories?: LibraryCategory[] | LibraryCategory | 'all'): Readonly<IdTable>[];
+    static getStandardLibrary(categories?: LibraryCategory[] | LibraryCategory | 'all'): readonly IdentifierDefinitions[];
     /**
      * Construct a new `ComputeEngine` instance.
      *
      * Identifier tables define functions and symbols (in `options.ids`).
-     * If no table is provided the standard library is used (`ComputeEngine.getStandardLibrary()`)
+     * If no table is provided the MathJSON Standard Library is used (`ComputeEngine.getStandardLibrary()`)
      *
      * The LaTeX syntax dictionary is defined in `options.latexDictionary`.
      *
      * The order of the dictionaries matter: the definitions from the later ones
      * override the definitions from earlier ones. The first dictionary should
      * be the `'core'` dictionary which include some basic definitions such
-     * as domains (`Boolean`, `Number`, etc...) that are used by later dictionaries.
+     * as domains (`Booleans`, `Numbers`, etc...) that are used by later
+     * dictionaries.
      *
      * @param options.numericMode The default mode is `"auto"`. Use `"machine"`
      * to perform numeric calculations using 64-bit floats. Use `"bignum"` to
@@ -146,17 +146,12 @@ export declare class ComputeEngine implements IComputeEngine {
      * @param options.tolerance If the absolute value of the difference of two
      * numbers is less than `tolerance`, they are considered equal. Used by
      * `chop()` as well.
-     *
-     * @param options.defaultDomain If an unknown symbol is encountered, assume
-     * this is its domain. **Default** `ExtendedRealNumber`
      */
     constructor(options?: {
         numericMode?: NumericMode;
         numericPrecision?: number;
-        ids?: Readonly<IdTable>[];
-        latexDictionary?: readonly LatexDictionaryEntry[];
+        ids?: readonly IdentifierDefinitions[];
         tolerance?: number;
-        defaultDomain?: string;
     });
     get latexDictionary(): readonly LatexDictionaryEntry[];
     set latexDictionary(dic: readonly LatexDictionaryEntry[]);
@@ -196,16 +191,6 @@ export declare class ComputeEngine implements IComputeEngine {
     get iterationLimit(): number;
     /** @experimental */
     get recursionLimit(): number;
-    /**
-     * If an unknown symbol is encountered, assume it should
-     * be a variable in this domain.
-     *
-     * If set to `null`, unknown symbols will trigger an error.
-     *
-     * **Default:** `"ExtendedRealNumber"`
-     */
-    get defaultDomain(): BoxedDomain | null;
-    set defaultDomain(domain: BoxedDomain | string | null);
     /**
      * Values smaller than the tolerance are considered to be zero for the
      * purpose of comparison, i.e. if `|b - a| <= tolerance`, `b` is considered
@@ -225,7 +210,7 @@ export declare class ComputeEngine implements IComputeEngine {
     isBignum(a: unknown): a is Decimal;
     isComplex(a: unknown): a is Complex;
     private get latexSyntax();
-    static getLatexDictionary(domain?: LibraryCategory | 'all'): Readonly<LatexDictionary>;
+    static getLatexDictionary(domain?: LibraryCategory | 'all'): readonly Readonly<object>[];
     set costFunction(fn: ((expr: BoxedExpression) => number) | undefined);
     get costFunction(): (expr: BoxedExpression) => number;
     /**
@@ -248,21 +233,59 @@ export declare class ComputeEngine implements IComputeEngine {
      * Add (or replace) a definition for a symbol in the current scope.
      */
     defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
+    _defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
     defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
+    _defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
     /**
      *
      * Create a new scope and add it to the top of the scope stack
      *
-     * The `options.scope` property can be used to specify custom precision,
+     * The `scope` argument can be used to specify custom precision,
      * etc... for this scope
      *
+     *
      */
-    pushScope(ids?: Readonly<IdTable> | Readonly<IdTable>[], scope?: Partial<Scope>): void;
+    pushScope(scope?: Partial<Scope>): IComputeEngine;
     /** Remove the topmost scope from the scope stack.
      */
-    popScope(): void;
-    set(identifiers: Substitution<SemiBoxedExpression | null | undefined>): void;
-    let(identifiers: IdTable): void;
+    popScope(): IComputeEngine;
+    swapScope(scope: RuntimeScope | null): RuntimeScope | null;
+    resetContext(): void;
+    _printScope(options?: {
+        details?: boolean;
+        maxDepth?: number;
+    }, scope?: RuntimeScope | null, depth?: number): RuntimeScope | null;
+    /**
+     * Declare one or more identifiers:
+     *
+     * associate an identifier with a definition, at minimum a domain, optionally
+     * a value and some other flags.
+     */
+    declare(id: string, def: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition): IComputeEngine;
+    declare(identifiers: {
+        [id: string]: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition;
+    }): IComputeEngine;
+    /**
+     * Assign a value to one or more identifiers.
+     *
+     * Domain of value must be compatible with existing domain.
+     *
+     * Declare identifier if it hasn't been declared yet.
+     *
+     */
+    assign(id: string, value: AssignValue): IComputeEngine;
+    assign(ids: {
+        [id: string]: AssignValue;
+    }): IComputeEngine;
+    /**
+     * Same as assign(), but for internal use:
+     * - skips validity checks
+     * - does not auto-declare
+     * - if assigning to a function, must pass a JS function
+     *
+     * @internal
+     */
+    _assign(id: string, value: AssignValue): IComputeEngine;
     get assumptions(): ExpressionMapInterface<boolean>;
     /**
      * Return false if the execution should stop.
@@ -288,6 +311,7 @@ export declare class ComputeEngine implements IComputeEngine {
     /** @internal */
     _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     error(message: string | [string, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
+    domainError(expectedDomain: BoxedDomain | DomainLiteral, actualDomain: undefined | BoxedDomain, where?: SemiBoxedExpression): BoxedExpression;
     hold(expr: SemiBoxedExpression): BoxedExpression;
     add(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     neg(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
@@ -303,7 +327,7 @@ export declare class ComputeEngine implements IComputeEngine {
         metadata?: Metadata;
         canonical?: boolean;
     }): BoxedExpression;
-    domain(domain: BoxedExpression | DomainExpression | BoxedDomain, metadata?: Metadata): BoxedDomain;
+    domain(domain: BoxedDomain | DomainExpression, metadata?: Metadata): BoxedDomain;
     number(value: number | bigint | string | MathJsonNumber | Decimal | Complex | Rational, options?: {
         canonical?: boolean;
         metadata?: Metadata;
@@ -331,14 +355,12 @@ export declare class ComputeEngine implements IComputeEngine {
      * Return a list of all the assumptions that match a pattern.
      *
      * ```js
-     *  ce.assume(x, 'PositiveInteger');
+     *  ce.assume(['Element', 'x', 'PositiveIntegers');
      *  ce.ask(['Greater', 'x', '_val'])
      *  //  -> [{'val': 0}]
      * ```
      */
-    ask(pattern: LatexString | SemiBoxedExpression): BoxedSubstitution[];
-    infer(symbol: BoxedExpression | string, _domain: BoxedDomain | DomainExpression): AssumeResult;
-    assume(symbol: LatexString | SemiBoxedExpression, domainValue: BoxedDomain | Expression | BoxedExpression): AssumeResult;
-    assume(predicate: LatexString | SemiBoxedExpression): AssumeResult;
+    ask(pattern: SemiBoxedExpression): BoxedSubstitution[];
+    assume(predicate: SemiBoxedExpression): AssumeResult;
     forget(symbol: undefined | string | string[]): void;
 }

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

@@ -1,3 +1,3 @@
-/* 0.15.0 */
+/* 0.17.0 */
 export declare function costFunction(expr: BoxedExpression): number;
 export declare const DEFAULT_COST_FUNCTION: typeof costFunction;