@cortex-js/compute-engine 0.4.1 → 0.4.4

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

@@ -0,0 +1,74 @@
+/* 0.4.4 */
+import { AbstractBoxedExpression } from './abstract-boxed-expression';
+import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOption } from '../public';
+/**
+ * BoxedSymbol
+ *
+ * A boxed symbol is a reference to a BoxedSymbolDefinition.
+ * The BoxedSymbolDefinition "owns" all the information
+ * about the symbol, its value, domain and various attributes.
+ */
+export declare class BoxedSymbol extends AbstractBoxedExpression {
+    protected _name: string;
+    private _hash;
+    private _def;
+    constructor(ce: IComputeEngine, name: string, metadata?: Metadata);
+    get hash(): number;
+    _purge(): undefined;
+    get isPure(): boolean;
+    get isCanonical(): boolean;
+    set isCanonical(_va: boolean);
+    get wikidata(): string;
+    get description(): string[];
+    get url(): string;
+    get complexity(): number;
+    get head(): string;
+    get symbol(): string;
+    get isMissing(): boolean;
+    get isLiteral(): boolean;
+    get symbolDefinition(): BoxedSymbolDefinition | undefined;
+    _repairDefinition(): void;
+    get value(): BoxedExpression | undefined;
+    set value(value: BoxedExpression | number | undefined);
+    get numericValue(): BoxedExpression | undefined;
+    get domain(): BoxedExpression;
+    set domain(d: BoxedExpression);
+    get json(): Expression;
+    get sgn(): -1 | 0 | 1 | undefined | null;
+    has(x: string | string[]): boolean;
+    isSame(rhs: BoxedExpression): boolean;
+    match(rhs: BoxedExpression, _options?: PatternMatchOption): Substitution | null;
+    isEqual(rhs: BoxedExpression): boolean;
+    isLess(rhs: BoxedExpression): boolean | undefined;
+    isLessEqual(rhs: BoxedExpression): boolean | undefined;
+    isGreater(rhs: BoxedExpression): boolean | undefined;
+    isGreaterEqual(rhs: BoxedExpression): boolean | undefined;
+    get isZero(): boolean | undefined;
+    get isNotZero(): boolean | undefined;
+    get isOne(): boolean | undefined;
+    get isNegativeOne(): boolean | undefined;
+    get isOdd(): boolean | undefined;
+    get isEven(): boolean | undefined;
+    get isPrime(): boolean | undefined;
+    get isComposite(): boolean | undefined;
+    get isInfinity(): boolean | undefined;
+    get isNaN(): boolean | undefined;
+    get isPositive(): boolean | undefined;
+    get isNonPositive(): boolean | undefined;
+    get isNegative(): boolean | undefined;
+    get isNonNegative(): boolean | undefined;
+    get isNumber(): boolean | undefined;
+    get isInteger(): boolean | undefined;
+    get isRational(): boolean | undefined;
+    get isAlgebraic(): boolean | undefined;
+    get isReal(): boolean | undefined;
+    get isExtendedReal(): boolean | undefined;
+    get isComplex(): boolean | undefined;
+    get isImaginary(): boolean | undefined;
+    get canonical(): BoxedExpression;
+    simplify(options?: SimplifyOptions): BoxedExpression;
+    evaluate(options?: EvaluateOptions): BoxedExpression;
+    N(options?: NOptions): BoxedExpression;
+    replace(rules: BoxedRuleSet, options?: ReplaceOptions): BoxedExpression | null;
+    subs(sub: Substitution): BoxedExpression;
+}

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

@@ -0,0 +1,12 @@
+/* 0.4.4 */
+export declare class ExpressionMap<U> implements ExpressionMapInterface<U> {
+    readonly _items: Map<BoxedExpression, U>;
+    constructor(source?: ExpressionMapInterface<U> | readonly (readonly [BoxedExpression, U])[]);
+    has(expr: BoxedExpression): boolean;
+    get(expr: BoxedExpression): U | undefined;
+    clear(): void;
+    set(expr: BoxedExpression, value: U): void;
+    delete(expr: BoxedExpression): void;
+    [Symbol.iterator](): IterableIterator<[BoxedExpression, U]>;
+    entries(): IterableIterator<[BoxedExpression, U]>;
+}

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

@@ -0,0 +1,53 @@
+/* 0.4.4 */
+export declare type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
+export declare const DEFAULT_COMPLEXITY = 100000;
+/**
+ * Sort by higher total degree (sum of degree), if tied, sort by max degree,
+ * if tied,
+ */
+export declare function sortAdd(ce: IComputeEngine, ops: BoxedExpression[]): BoxedExpression[];
+/**
+ * Given two expressions `a` and `b`, return:
+ * - `-1` if `a` should be ordered before `b`
+ * - `+1` if `b` should be ordered before `a`
+ * - `0` if they have the same order (they are structurally equal)
+ *
+ * The default order is as follow:
+ *
+ * 1/ Literal numeric values (rational,  machine numbers and Decimal numbers),
+ *  ordered by they numeric value (smaller numbers before larger numbers)
+ *
+ * 2/ Literal complex numbers, ordered by their real parts. In case of a tie,
+ * ordered by the absolute value of their imaginary parts. In case of a tie,
+ * ordered by the value of their imaginary parts.
+ *
+ * 3/ Symbols, ordered by their name as strings
+ *
+ * 4/ Addition, ordered as a polynom, with higher degree terms first
+ *
+ * 5/ Other functions, ordered by their `complexity` property. In case
+ * of a tie, ordered by the head of the expression as a string. In case of a
+ * tie, by the leaf count of each expression. In case of a tie, by the order
+ * of each argument, left to right.
+ *
+ * 6/ Strings, ordered by comparing their Unicode code point values. While this
+ * sort order is quick to calculate, it can produce unexpected results, for
+ * example "E" < "e" < "È" and "11" < "2". This ordering is not suitable to
+ * collate natural language strings.
+ *
+ * 7/ Dictionaries, ordered by the number of keys. If there is a tie, by the
+ * sum of the complexities of the values of the dictionary
+ *
+ *
+ */
+export declare function order(a: BoxedExpression, b: BoxedExpression): number;
+/**
+ * Sort the terms of a polynomial expression (`Add` expression) according
+ * to the deglex polynomial ordering
+ *
+ */
+export declare function polynomialOrder(expr: BoxedExpression): SemiBoxedExpression;
+export declare function lexicographicOrder(expr: BoxedExpression, vars?: string[]): SemiBoxedExpression;
+export declare function degreeLexicographicOrder(expr: BoxedExpression, vars?: string[]): SemiBoxedExpression;
+export declare function degreeReverseLexicographicOrder(expr: BoxedExpression, vars?: string[]): SemiBoxedExpression;
+export declare function eliminationOrder(expr: BoxedExpression, vars?: string[]): SemiBoxedExpression;

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

@@ -0,0 +1,15 @@
+/* 0.4.4 */
+import Decimal from 'decimal.js';
+import { Expression } from '../../math-json/math-json-format';
+import { BoxedExpression, IComputeEngine, Metadata } from '../public';
+/**
+ * The canonical version of `serializeJsonFunction()` applies
+ * additional transformations to "reverse" some of the effects
+ * of canonicalization (or boxing), for example it uses `Divide`
+ * instead of `Multiply`/`Power` when applicable.
+ */
+export declare function serializeJsonCanonicalFunction(ce: IComputeEngine, head: string | BoxedExpression, args: BoxedExpression[], metadata?: Metadata): Expression;
+export declare function serializeJsonFunction(ce: IComputeEngine, head: string | BoxedExpression, args: BoxedExpression[], metadata?: Metadata): Expression;
+export declare function serializeJsonString(ce: IComputeEngine, s: string): Expression;
+export declare function serializeJsonSymbol(ce: IComputeEngine, sym: string, metadata?: Metadata): Expression;
+export declare function serializeJsonNumber(ce: IComputeEngine, value: number | Decimal | Complex | [number, number], metadata?: Metadata): Expression;

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

@@ -0,0 +1,37 @@
+/* 0.4.4 */
+export declare function isLatexString(s: any): s is string;
+export declare function latexString(s: any): string | null;
+/**
+ * Return a multiple of the imaginary unit, e.g.
+ * - 'ImaginaryUnit'
+ * - ['Negate', 'ImaginaryUnit']
+ * - ['Negate', ['Multiply', 3, 'ImaginaryUnit']]
+ * - ['Multiply', 5, 'ImaginaryUnit']
+ * - ['Multiply', 'ImaginaryUnit', 5]
+ */
+export declare function getImaginaryCoef(expr: BoxedExpression): number;
+/**
+ * Return the free symbols in the expression, recursively.
+ * A variable, or free symbol,is a symbol that is not bound to a value.
+ */
+export declare function getVars(expr: BoxedExpression): string[];
+/**
+ * For any numeric result, or when boxing numbers,
+ * if `ce.useDecimal` is true, create them as Decimal number
+ * if `ce.useDecimal` is false, create them as machine number
+ */
+export declare function useDecimal(ce: IComputeEngine): boolean;
+/** If result of a numeric evaluation is a complex number,
+ * return `NaN` if `ce.useComplex` is false
+ */
+export declare function complexAllowed(ce: IComputeEngine): boolean;
+/**
+ * Assert that `expr` is  in fact canonical.
+ *
+ * Called for example from within a `canonical` handler.
+ *
+ * To make an expression whose canonical status is unknown, canonical, call
+ * `expr.canonical`.
+ */
+export declare function asCanonical(expr: BoxedExpression): BoxedExpression;
+export declare function hashCode(s: string): number;

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

@@ -1,116 +1,257 @@
-/* 0.4.1 */
-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.4.4 */
+import { DictionaryCategory, LatexDictionaryEntry, LatexString, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
+import { Decimal } from 'decimal.js';
+import { Complex } from 'complex.js';
+import { SignalMessage, WarningSignal } from '../common/signals';
+import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, Dictionary, ExpressionMapInterface, NumericMode as NumericMode, Pattern, RuntimeScope, Scope, SemiBoxedExpression, Substitution, SymbolDefinition, BoxedRuleSet, Rule, JsonSerializationOptions, ComputeEngineStats, Metadata } from './public';
+/**
+ * Create a `CustomEngine` instance to customize its behavior and the syntax
+ * and operation dictionaries it uses.
+ *
+ * The constructor of `ComputeEngine` will compile and optimize the dictionary
+ * upfront.
+ */
+export declare class ComputeEngine implements IComputeEngine {
+    readonly ZERO: BoxedExpression;
+    readonly ONE: BoxedExpression;
+    readonly TWO: BoxedExpression;
+    readonly HALF: BoxedExpression;
+    readonly NEGATIVE_ONE: BoxedExpression;
+    readonly I: BoxedExpression;
+    readonly NAN: BoxedExpression;
+    readonly POSITIVE_INFINITY: BoxedExpression;
+    readonly NEGATIVE_INFINITY: BoxedExpression;
+    readonly COMPLEX_INFINITY: BoxedExpression;
+    DECIMAL_NAN: Decimal;
+    DECIMAL_ZERO: Decimal;
+    DECIMAL_ONE: Decimal;
+    DECIMAL_TWO: Decimal;
+    DECIMAL_HALF: Decimal;
+    DECIMAL_PI: Decimal;
+    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 is a dictionary that contains the definition of local symbols.
+     *
+     * Scopes form a stack, and definitions in more recent
+     * scopes can obscure definitions from older scopes.
+     *
+     */
+    context: RuntimeScope;
+    /** Absolute time beyond which evaluation should not proceed */
+    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` environment.
+     *
+     * If no `options.dictionaries` is provided a default set of dictionaries
+     * is used.
+     *
+     * The `ComputeEngine.getDictionaries()` method can be called
+     * to access a subset of dictionaries, e.g. for arithmetic, calculus, etc...
+     *
+     * 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.
+     */
     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.
+     *
+     */
+    purge(): void;
+    _register(expr: BoxedExpression): void;
+    _unregister(expr: BoxedExpression): void;
+    get stats(): ComputeEngineStats;
+    _decimal: Decimal.Constructor;
+    decimal: (a: Decimal.Value) => Decimal;
+    complex: (a: number | Complex, b?: number) => Complex;
+    /** The precision, or number of significant digits, for numerical 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);
+    /**
+     * Mode to use for numerical calculations:
+     *
+     * - `auto`:  use machine number if the precision is 15 or less, Decimal
+     * otherwise. Complex numbers are allowed.
+     * - `number`: use the machine format (64-bit float, 52-bit mantissa, about
+     * 15 digits of precision).
+     * - `decimal`: arbitrary precision floating-point numbers, as provided by the
+     * "decimal.js" library
+     * - `complex`: machine and complex numbers: two 64-bit float, as provided by the
+     * "complex.js" library
+     *
+     */
+    get numericMode(): NumericMode;
+    set numericMode(f: NumericMode);
+    get timeLimit(): number;
+    get iterationLimit(): number;
+    get recursionLimit(): number;
+    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;
+    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;
+    /**
+     *
+     * 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.
+     */
     popScope(): void;
-    get assumptions(): ExpressionMap<T, boolean>;
+    get assumptions(): ExpressionMapInterface<boolean>;
+    /**
+     * 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
+     */
     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;
+    assert(condition: boolean, expr: BoxedExpression, msg: string, code?: SignalMessage): void;
     /**
-     * Return the canonical form of an expression.
+     * Call this function if an unexpected condition occurs during execution of a
+     * function in the engine.
+     *
+     * An `ErrorSignal` is a problem that cannot be recovered from.
+     *
+     * A `WarningSignal` indicates a minor problem that does not prevent the
+     * execution to continue.
+     *
      */
-    canonical(expr: Expression | null): Expression | null;
+    signal(expr: BoxedExpression, msg: string, code?: SignalMessage): void;
+    signal(sig: WarningSignal): void;
+    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;
+    _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: null): null;
+    parse(s: LatexString | string): BoxedExpression;
+    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 numerical approximation of an expression.
+     * Return a list of all the assumptions that match a pattern.
+     *
+     * ```js
+     *  ce.assume(x, 'PositiveInteger');
+     *  ce.ask(['Greater', 'x', '_val'])
+     *  //  -> [{'val': 0}]
+     * ```
      */
-    N(expr: Expression): Expression | null;
+    ask(pattern: LatexString | SemiBoxedExpression): Substitution[];
     /**
-     * Attempt to simplify an expression, that is rewrite it in a simpler form,
-     * making use of the available assumptions.
+     * Add an assumption.
      *
-     * 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
+     * Return `contradiction` if the new assumption is incompatible with previous
+     * ones.
      *
-     * 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.
+     * Return `tautology` if the new assumption is redundant with previous ones.
+     *
+     * Return `ok` if the assumption was successfully added to the assumption set.
+     *
+     * Note that the assumption is put into canonical form before being added.
      *
      */
-    simplify(expr: Expression, options?: {
-        timeLimit?: number;
-        iterationLimit?: number;
-        simplifications?: Simplification[];
-    }): Expression | null;
-    /**
-     * 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;
+    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.4.4 */
+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.4.4 */
+/** 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.4.4 */
+/**
+ * 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.4.4 */
+/** 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.4.4 */
+/**
+ *
+ * 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.1 */
-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.4.4 */
+export declare const ARITHMETIC_DICTIONARY: Dictionary[];

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

@@ -1,2 +1,2 @@
-/* 0.4.1 */
+/* 0.4.4 */
 export declare const COLLECTIONS_DICTIONARY: Dictionary;

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

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