@cortex-js/compute-engine 0.4.2 → 0.5.0

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

@@ -1,116 +1,301 @@
-/* 0.4.2 */
-import { CollectionDefinition, ComputeEngine as ComputeEngineInterface, Definition, Dictionary, Domain, Form, FunctionDefinition, Numeric, NumericFormat, RuleSet, RuntimeScope, Scope, SetDefinition, Simplification, SymbolDefinition } from './public';
-import { InternalComputeEngine } from './internal-compute-engine';
-import { ExpressionMap } from './expression-map';
-export declare class ComputeEngine<T extends number = number> implements ComputeEngineInterface {
-    readonly internal: InternalComputeEngine;
-    static getDictionaries(categories?: DictionaryCategory[] | 'all'): Readonly<Dictionary<Numeric>>[];
+/* 0.5.0 */
+import { Complex } from 'complex.js';
+import { Expression, MathJsonNumber } from '../math-json/math-json-format';
+import { SignalMessage, WarningSignal } from '../common/signals';
+import type { DictionaryCategory, LatexDictionaryEntry, LatexString, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
+import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, Dictionary, ExpressionMapInterface, NumericMode as NumericMode, Pattern, RuntimeScope, Scope, SemiBoxedExpression, Substitution, SymbolDefinition, BoxedRuleSet, Rule, JsonSerializationOptions, ComputeEngineStats, Metadata } from './public';
+/**
+ *
+ * To use the CortexJS Compute Engine, create a `ComputeEngine` instance.
+ *
+ * Use the instance to create expressions with `ce.parse()` and `ce.box()`.
+ *
+ *
+ * ```ts
+ * const ce = new ComputeEngine();
+ * let expr = ce.parse("e^{i\\pi}");
+ * console.log(expr.N().latex);
+ * // ➔ "-1"
+ *
+ * expr = ce.box(["Expand", ["Power", ["Add", "a", "b"], 2]]);
+ * console.log(expr.evaluate().latex);
+ * // ➔ "a^2 +  2ab + b^2"
+ *
+ * ```
+ */
+export declare class ComputeEngine implements IComputeEngine {
+    /** @internal */
+    readonly ZERO: BoxedExpression;
+    /** @internal */
+    readonly ONE: BoxedExpression;
+    /** @internal */
+    readonly TWO: 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;
+    /** @internal */
+    DECIMAL_NAN: Decimal;
+    /** @internal */
+    DECIMAL_ZERO: Decimal;
+    /** @internal */
+    DECIMAL_ONE: Decimal;
+    /** @internal */
+    DECIMAL_TWO: Decimal;
+    /** @internal */
+    DECIMAL_HALF: Decimal;
+    /** @internal */
+    DECIMAL_PI: Decimal;
+    /** @internal */
+    DECIMAL_NEGATIVE_ONE: Decimal;
+    private _precision;
+    private _numericMode;
+    private _latexSyntax?;
+    private _tolerance;
+    private _decimalTolerance;
+    private _cache;
+    private _stats;
+    private _cost?;
+    private _jsonSerializationOptions;
+    /** The domain of unknown symbols. If `null` unknown symbols do not have a
+     * definition automatically associated with them.
+     */
+    private _defaultDomain;
+    private _commonSymbols;
+    private _commonNumbers;
+    private _commonDomains;
+    private _latexDictionary?;
+    /**
+     * The current scope.
+     *
+     * A **scope** stores the definition of symbols and assumptions.
+     *
+     * Scopes form a stack, and definitions in more recent
+     * scopes can obscure definitions from older scopes.
+     *
+     * The `ce.context` property represents the current scope.
+     *
+     */
+    context: RuntimeScope;
+    /** Absolute time beyond which evaluation should not proceed.
+     * @internal
+     */
+    deadline?: number;
+    /**
+     * Return dictionaries suitable for the specified categories, or `"all"`
+     * for all categories (`"arithmetic"`, `"algebra"`, etc...).
+     *
+     * A symbol dictionary defines how the symbols and function names in a MathJSON
+     * expression should be interpreted, i.e. how to evaluate and manipulate them.
+     *
+     */
+    static getDictionaries(categories?: DictionaryCategory[] | 'all'): Readonly<Dictionary>[];
+    /**
+     * Construct a new `ComputeEngine` instance.
+     *
+     * Dictionaries define functions and symbols (in `options.dictionaries`) and
+     * the LaTeX syntax (in `options.latexDictionaries`). If no dictionaries
+     * are provided, the default ones are used.
+     *
+     * 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.
+     *
+     * @param options.numericMode The default mode is `auto`. Use `machine` to only
+     * use 64-bit float, use `decimal` to always use arbitrary precision floating
+     * point numbers or `complex` for complex numbers.
+     *
+     * @param options.numericPrecision Specific how many digits of precision for the
+     * numeric calculations. Default is 100.
+     *
+     * @param options.tolerance If the absolute value of the difference of two numbers
+     * is less than `toleranc`, they are considered equal. Used by `chop()` as well.
+     *
+     * @param options.defaultDomain If an unknown symbol is encountered, assume it should
+     * be a variable in this domain. **Default** `ExtendedRealNumber`
+     */
     constructor(options?: {
-        dictionaries?: Readonly<Dictionary<Numeric>>[];
+        dictionaries?: Readonly<Dictionary>[];
+        latexDictionary?: readonly LatexDictionaryEntry[];
+        numericMode?: NumericMode;
+        numericPrecision?: number;
+        tolerance?: number;
+        assumptions?: (LatexString | Expression)[];
+        defaultDomain?: string;
     });
+    /** After the configuration of the engine has changed, clear the caches
+     * so that new values can be recalculated.
+     *
+     * This needs to happen for example when the numeric precision changes.
+     *
+     * @internal
+     */
+    purge(): void;
+    /** @internal */
+    _register(expr: BoxedExpression): void;
+    /** @internal */
+    _unregister(expr: BoxedExpression): void;
+    get stats(): ComputeEngineStats;
+    /** @internal */
+    _decimal: Decimal.Constructor;
+    /** @internal */
+    decimal: (a: Decimal.Value) => Decimal;
+    /** @internal */
+    complex: (a: number | Complex, b?: number) => Complex;
+    /** The precision, or number of significant digits, for numeric calculations
+     * such as when calling `ce.N()`.
+     *
+     * To  make calculations using more digits, at the cost of expended memory
+     * usage and slower computations, set the `precision` higher.
+     *
+     * Trigonometric operations are accurate for precision up to 1,000.
+     *
+     */
     get precision(): number;
     set precision(p: number | 'machine');
-    get numericFormat(): NumericFormat;
-    set numericFormat(f: NumericFormat);
+    get numericMode(): NumericMode;
+    set numericMode(f: NumericMode);
+    /** @experimental */
+    get timeLimit(): number;
+    /** @experimental */
+    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(): BoxedExpression | null;
+    set defaultDomain(domain: BoxedExpression | 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
+     * equal to `a`.
+     */
     get tolerance(): number;
     set tolerance(val: number);
-    get context(): RuntimeScope<Numeric>;
-    pushScope(dictionary: Readonly<Dictionary<Numeric>>, scope?: Partial<Scope>): void;
-    popScope(): void;
-    get assumptions(): ExpressionMap<T, boolean>;
-    shouldContinueExecution(): boolean;
-    checkContinueExecution(): void;
-    signal(sig: ErrorSignal | WarningSignal): void;
-    getFunctionDefinition(name: string): FunctionDefinition | null;
-    getSymbolDefinition(name: string): SymbolDefinition<Numeric> | null;
-    getSetDefinition(name: string): SetDefinition<Numeric> | null;
-    getCollectionDefinition(name: string): CollectionDefinition<Numeric> | null;
-    getDefinition(name: string): Definition<Numeric> | null;
-    getRules(topic: string | string[]): RuleSet;
-    format(expr: Expression | null, forms?: Form | Form[]): Expression | null;
+    /** Replace a number that is close to 0 with the exact integer 0.
+     *
+     * How close to 0 the number has to be to be considered 0 is determined by {@link tolerance}.
+     */
+    chop(n: number): number;
+    chop(n: Decimal): Decimal | 0;
+    chop(n: Complex): Complex | 0;
+    private get latexSyntax();
+    set costFunction(fn: ((expr: BoxedExpression) => number) | undefined);
+    get costFunction(): (expr: BoxedExpression) => number;
+    /**
+     * Return a matching symbol definition, starting with the current
+     * scope and going up the scope chain.
+     */
+    getSymbolDefinition(symbol: string, wikidata?: string): undefined | BoxedSymbolDefinition;
+    /**
+     * Return the definition for a function matching this head.
+     *
+     * Start looking in the current scope, than up the scope chain.
+     */
+    getFunctionDefinition(head: string): undefined | BoxedFunctionDefinition;
+    /**
+     * Add (or replace) a definition for a symbol in the current scope.
+     */
+    defineSymbol(def: SymbolDefinition): BoxedSymbolDefinition;
     /**
-     * Return the canonical form of an expression.
+     *
+     * 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,
+     * etc... for this scope
+     *
+     */
+    pushScope(options?: {
+        dictionary?: Readonly<Dictionary> | Readonly<Dictionary>[];
+        assumptions?: (LatexString | Expression)[];
+        scope?: Partial<Scope>;
+    }): void;
+    /** Remove the topmost scope from the scope stack.
      */
-    canonical(expr: Expression | null): Expression | null;
+    popScope(): void;
+    get assumptions(): ExpressionMapInterface<boolean>;
     /**
-     * Return a numerical approximation of an expression.
+     * Return false if the execution should stop.
+     *
+     * This can occur if:
+     * - an error has been signaled
+     * - the time limit or memory limit has been exceeded
+     *
+     * @internal
      */
-    N(expr: Expression): Expression | null;
+    shouldContinueExecution(): boolean;
+    /** @internal */
+    checkContinueExecution(): void;
+    assert(condition: boolean, expr: BoxedExpression, msg: string, code?: SignalMessage): void;
     /**
-     * Attempt to simplify an expression, that is rewrite it in a simpler form,
-     * making use of the available assumptions.
+     * Call this function if an unexpected condition occurs during execution of a
+     * function in the engine.
      *
-     * The simplification steps will proceed multiple times until either:
-     * 1/ the expression stop changing
-     * 2/ the number of iteration exceeds `iterationLimit`
-     * 3/ the time to compute exceeds `timeLimit`, expressed in seconds
+     * An `ErrorSignal` is a problem that cannot be recovered from.
      *
-     * If no `timeLimit` or `iterationLimit` are provided, the values
-     * from the current ComputeEngine context are used. By default those
-     * values are an infinite amount of iterations and a 2s time limit.
+     * A `WarningSignal` indicates a minor problem that does not prevent the
+     * execution to continue.
      *
      */
-    simplify(expr: Expression, options?: {
-        timeLimit?: number;
-        iterationLimit?: number;
-        simplifications?: Simplification[];
-    }): Expression | null;
+    signal(expr: BoxedExpression, msg: string, code?: SignalMessage): void;
+    signal(sig: WarningSignal): void;
+    /** @internal */
+    cache<T>(cacheName: string, build: () => T, purge: (T: any) => T | undefined): T;
+    box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression): BoxedExpression;
+    fn(head: string, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    /** @internal */
+    _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    error(val: BoxedExpression, message: string, messageArg: SemiBoxedExpression): BoxedExpression;
+    add(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    mul(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    power(base: BoxedExpression, exponent: number | [number, number] | BoxedExpression, metadata?: Metadata): BoxedExpression;
+    inverse(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    negate(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    divide(num: BoxedExpression, denom: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    pair(first: BoxedExpression, second: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    tuple(elements: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    string(s: string, metadata?: Metadata): BoxedExpression;
+    symbol(sym: string, metadata?: Metadata): BoxedExpression;
+    domain(domain: BoxedExpression | string, metadata?: Metadata): BoxedExpression;
+    number(value: number | MathJsonNumber | Decimal | Complex | [num: number, denom: number], metadata?: Metadata): BoxedExpression;
+    rules(rules: Rule[]): BoxedRuleSet;
+    pattern(expr: LatexString | SemiBoxedExpression): Pattern;
+    parse(s: LatexString | string): BoxedExpression;
+    parse(s: null): null;
+    parse(s: LatexString | string | null): null | BoxedExpression;
+    serialize(x: Expression | BoxedExpression): string;
+    get latexOptions(): NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
+    set latexOptions(opts: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>);
+    get jsonSerializationOptions(): JsonSerializationOptions;
+    set jsonSerializationOptions(val: Partial<JsonSerializationOptions>);
     /**
-     * Return a simplified and numerically approximation of an expression
-     * in canonical form.
-     *
-     * The simplification steps will proceed multiple times until either:
-     * 1/ the expression stop changing
-     * 2/ the number of iteration exceeds `iterationLimit`
-     * 3/ the time to compute exceeds `timeLimit`, expressed in seconds
-     *
-     * If no `timeLimit` or `iterationLimit` are provided, the values
-     * from the current ComputeEngine context are used. By default those
-     * values are an infinite amount of iterations and a 2s time limit.
-     */
-    evaluate(expr: Expression, options?: {
-        timeLimit?: number;
-        iterationLimit?: number;
-    }): Promise<Expression | null>;
-    parse(s: string): Expression;
-    serialize(x: Expression): string;
-    domain(expr: Expression): Expression | null;
-    /** Query the assumption database
-     */
-    is(symbol: Expression, domain: Domain): boolean | undefined;
-    is(predicate: Expression): boolean | undefined;
-    ask(pattern: Expression): {
-        [symbol: string]: Expression;
-    }[];
-    assume(symbol: Expression, domain: Domain): 'contradiction' | 'tautology' | 'ok';
-    assume(predicate: Expression): 'contradiction' | 'tautology' | 'ok';
-    replace(rules: RuleSet<T>, expr: Expression<T>): Expression<T>;
-    getVars(expr: Expression): Set<string>;
-    chop(n: Numeric): Numeric;
-    isZero(x: Expression<T>): boolean | undefined;
-    isNotZero(x: Expression<T>): boolean | undefined;
-    isNumeric(x: Expression<T>): boolean | undefined;
-    isInfinity(x: Expression<T>): boolean | undefined;
-    isFinite(x: Expression<T>): boolean | undefined;
-    isNonNegative(x: Expression<T>): boolean | undefined;
-    isPositive(x: Expression<T>): boolean | undefined;
-    isNegative(x: Expression<T>): boolean | undefined;
-    isNonPositive(x: Expression<T>): boolean | undefined;
-    isInteger(x: Expression<T>): boolean | undefined;
-    isRational(x: Expression<T>): boolean | undefined;
-    isAlgebraic(x: Expression<T>): boolean | undefined;
-    isReal(x: Expression<T>): boolean | undefined;
-    isExtendedReal(x: Expression<T>): boolean | undefined;
-    isComplex(x: Expression<T>): boolean | undefined;
-    isOne(x: Expression<T>): boolean | undefined;
-    isNegativeOne(x: Expression<T>): boolean | undefined;
-    isElement(x: Expression<T>, set: Expression<T>): boolean | undefined;
-    isSubsetOf(lhs: Domain | null, rhs: Domain | null): boolean;
-    isEqual(lhs: Expression, rhs: Expression): boolean | undefined;
-    isLess(lhs: Expression, rhs: Expression): boolean | undefined;
-    isLessEqual(lhs: Expression, rhs: Expression): boolean | undefined;
-    isGreater(lhs: Expression, rhs: Expression): boolean | undefined;
-    isGreaterEqual(lhs: Expression, rhs: Expression): boolean | undefined;
+     * Return a list of all the assumptions that match a pattern.
+     *
+     * ```js
+     *  ce.assume(x, 'PositiveInteger');
+     *  ce.ask(['Greater', 'x', '_val'])
+     *  //  -> [{'val': 0}]
+     * ```
+     */
+    ask(pattern: LatexString | SemiBoxedExpression): Substitution[];
+    assume(symbol: LatexString | SemiBoxedExpression, domain: string | BoxedExpression): AssumeResult;
+    assume(predicate: LatexString | SemiBoxedExpression): AssumeResult;
+    forget(symbol: undefined | string | string[]): void;
 }
-export declare function format(expr: Expression, forms: Form | Form[]): Expression | null;
-export declare function evaluate(expr: Expression): Promise<Expression | null>;

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

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

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

@@ -0,0 +1,11 @@
+/* 0.5.0 */
+/** The canonical form of `Add`:
+ * - removes `0`
+ * - adds up small integers and rational numbers
+ * - capture complex numbers (a + ib or ai +b)
+ * - groups repeated terms (a + a -> 2a)
+ * */
+export declare function canonicalAdd(ce: IComputeEngine, ops: BoxedExpression[]): BoxedExpression;
+export declare function domainAdd(ce: IComputeEngine, args: BoxedExpression[]): BoxedExpression | string;
+export declare function numEvalAdd(ce: IComputeEngine, args: BoxedExpression[]): BoxedExpression;
+export declare function processAdd(ce: IComputeEngine, args: BoxedExpression[], _mode: 'simplify' | 'evaluate'): BoxedExpression | undefined;

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

@@ -0,0 +1,9 @@
+/* 0.5.0 */
+/**
+ * Canonical form of 'Divide' (and 'Rational')
+ * - remove denominator of 1
+ * - simplify the signs
+ * - factor out negate (make the numerator and denominator positive)
+ * - if Divide, transform into Multiply/Power
+ */
+export declare function canonicalDivide(ce: IComputeEngine, op1: BoxedExpression, op2: BoxedExpression): BoxedExpression;

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

@@ -0,0 +1,17 @@
+/* 0.5.0 */
+/** The canonical form of `Multiply`:
+ * - remove `1`
+ * - combine literal small integers and rationals
+ * - any arg is literal 0 -> return 0
+ * - simplify signs
+ * - combine terms with same base
+ *    `a a^3` -> `a^4`
+ * - simplify the signs:
+ *    - i.e. `-2 \times -3` -> `2 \times 3`
+ *    - `2 \times -x` -> `-2 \times x`
+ *
+ * The ops must be canonical, the result is canonical.
+ */
+export declare function canonicalMultiply(ce: IComputeEngine, ops: BoxedExpression[]): BoxedExpression;
+export declare function processMultiply(ce: IComputeEngine, ops: BoxedExpression[], _mode: 'simplify' | 'evaluate'): BoxedExpression | undefined;
+export declare function numEvalMultiply(ce: IComputeEngine, ops: BoxedExpression[]): BoxedExpression | undefined;

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

@@ -0,0 +1,9 @@
+/* 0.5.0 */
+/**
+ *
+ * Return `null` if there is no canonicalization necessary and the result is
+ * simply `ce._fn('Power', [base, exponent])`
+ */
+export declare function canonicalPower(ce: IComputeEngine, base: BoxedExpression, exponent: BoxedExpression, metadata?: Metadata): BoxedExpression | null;
+export declare function square(ce: IComputeEngine, base: BoxedExpression): BoxedExpression;
+export declare function processPower(ce: IComputeEngine, base: BoxedExpression, exponent: BoxedExpression, mode: 'simplify' | 'evaluate' | 'N'): BoxedExpression | undefined;

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

@@ -1,12 +1,2 @@
-/* 0.4.2 */
-import type { ComputeEngine, Dictionary, Numeric } from '../public';
-export declare const ARITHMETIC_DICTIONARY: Dictionary<Numeric>;
-/** Apply some simplifications for `Negate`.
- *  Used by `canonical-negate` and `simplify`
- */
-export declare function applyNegate(expr: Expression): Expression;
-export declare function ungroup(expr: Expression | null): Expression;
-export declare function applyPower(engine: ComputeEngine, expr: Expression): Expression;
-/** Used by `simplify` and `canonical` to simplify some arithmetic
- * and trigonometric constants */
-export declare function applyConstants(expr: Expression): Expression;
+/* 0.5.0 */
+export declare const ARITHMETIC_DICTIONARY: Dictionary[];

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

@@ -1,2 +1,2 @@
-/* 0.4.2 */
+/* 0.5.0 */
 export declare const COLLECTIONS_DICTIONARY: Dictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.2 */
-export declare const CORE_DICTIONARY: Dictionary;
+/* 0.5.0 */
+export declare const CORE_DICTIONARY: Dictionary[];

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

@@ -1,19 +1,26 @@
-/* 0.4.2 */
-import type { Dictionary, CompiledDictionary, ComputeEngine, Numeric } from '../public';
-export declare function getDefaultDictionaries<T extends number = number>(categories?: DictionaryCategory[] | 'all'): Readonly<Dictionary<T>>[];
-export declare const DICTIONARY: {
-    [category in DictionaryCategory]?: Dictionary<Numeric>;
+/* 0.5.0 */
+import { IComputeEngine, Dictionary } from '../public';
+export declare function getDefaultDictionaries(categories?: DictionaryCategory[] | 'all'): Readonly<Dictionary>[];
+export declare const DICTIONARIES: {
+    [category in DictionaryCategory]?: Readonly<Dictionary> | Readonly<Dictionary>[];
 };
 /**
- * Return a compiled and validated version of the dictionary.
+ * Set the dictionary of the current context (`engine.context`) to `dicts`
+ *
+ * `dicts` can be an array of dictionaries, in order to deal with circular
+ * dependencies: it is possible to partition a dictionary into multiple
+ * sub-dictionary, to control the order in which they are processe and
+ * avoid having expressions in the definition of an entry reference a symbol
+ * or function name that has not yet been added to the dictionary.
  *
  * Specifically:
- * - Expressions (for values, evaluate, domain, isElementOf, etc..) are compiled
- * when possible, put in canonical form otherwise
+ * - Expressions (for values, evaluate, domain, isElementOf, etc..) are boxed
  * - The domain of entries is inferred and validated:
  *  - check that domains are in canonical form
- *  - check that domains are consistent with declarations (for example that
- * the signature of predicate have a "MaybeBoolean" codomain)
+ *  - check that domains are consistent with declarations
  *
  */
-export declare function compileDictionary<T extends number = Numeric>(dict: Dictionary<T>, engine: ComputeEngine<T>): CompiledDictionary<T>;
+export declare function setCurrentContextDictionary(engine: IComputeEngine, dicts: Dictionary | Dictionary[] | undefined): void;
+/**
+ * For debugging: a textual representation of the inheritance chain of sets.
+ */

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

@@ -1,2 +1,2 @@
-/* 0.4.2 */
+/* 0.5.0 */
 export declare const LOGIC_DICTIONARY: Dictionary;

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

@@ -0,0 +1,2 @@
+/* 0.5.0 */
+export declare const POLYNOMIALS_DICTIONARY: Dictionary[];

package/dist/types/compute-engine/dictionary/relational-operator.d.ts

@@ -0,0 +1,2 @@
+/* 0.5.0 */
+export declare const RELOP_DICTIONARY: Dictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.2 */
+/* 0.5.0 */
 export declare const SETS_DICTIONARY: Dictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.2 */
-export declare const TRIGONOMETRY_DICTIONARY: Dictionary;
+/* 0.5.0 */
+export declare const TRIGONOMETRY_DICTIONARY: Dictionary[];

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

@@ -0,0 +1,30 @@
+/* 0.5.0 */
+import { Decimal } from 'decimal.js';
+import { BoxedExpression } from './public';
+/** Quickly determine the numeric domain of a number or constant
+ * For the symbols, this is a hard-coded optimization that doesn't rely on the
+ * dictionaries. The regular path is in `internalDomain()`
+ */
+export declare function inferNumericDomain(value: number | Decimal | Complex | [numer: number, denom: number]): string;
+/**
+ * Simple description of a numeric domain as a base domain, a min and
+ * max value, possibly open ends, and some excluded values.
+ */
+export declare type NumericDomainInfo = {
+    domain?: string;
+    min?: number;
+    max?: number;
+    open?: 'left' | 'right' | 'both';
+    /** Values from _excludedValues_ are considered not in this domain */
+    excludedValues?: number[];
+    /** If defined, the values in this domain must follow the relation
+     * _period_ * _n_ + _phase_ when _n_ is in _domain_.
+     */
+    multiple?: [period: number, domain: BoxedExpression, phase: number];
+};
+/**
+ * Return an efficient data structure describing a numeric domain,
+ * an `Interval` or `Range`
+ * @todo could also check for `Multiple`
+ */
+export declare function inferNumericDomainInfo(expr: BoxedExpression): NumericDomainInfo | null;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-algebra.d.ts

@@ -0,0 +1,2 @@
+/* 0.5.0 */
+export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-arithmetic.d.ts

@@ -0,0 +1,2 @@
+/* 0.5.0 */
+export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-calculus.d.ts

@@ -0,0 +1,2 @@
+/* 0.5.0 */
+export declare const DEFINITIONS_CALCULUS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-core.d.ts

@@ -0,0 +1,4 @@
+/* 0.5.0 */
+import { LatexDictionary, Serializer } from '../public';
+export declare function serializeLatex(serializer: Serializer, expr: Expression | null): string;
+export declare const DEFINITIONS_CORE: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-inequalities.d.ts

@@ -0,0 +1,2 @@
+/* 0.5.0 */
+export declare const DEFINITIONS_INEQUALITIES: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-logic.d.ts

@@ -0,0 +1,2 @@
+/* 0.5.0 */
+export declare const DEFINITIONS_LOGIC: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-other.d.ts

@@ -0,0 +1,2 @@
+/* 0.5.0 */
+export declare const DEFINITIONS_OTHERS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-sets.d.ts

@@ -0,0 +1,2 @@
+/* 0.5.0 */
+export declare const DEFINITIONS_SETS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-symbols.d.ts

@@ -0,0 +1,2 @@
+/* 0.5.0 */
+export declare const DEFINITIONS_SYMBOLS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-trigonometry.d.ts

@@ -0,0 +1,2 @@
+/* 0.5.0 */
+export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;