@cortex-js/compute-engine 0.4.3 → 0.6.0

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

@@ -1,8 +1,34 @@
-/* 0.4.3 */
-import { BoxedExpression, IComputeEngine, Metadata } from '../public';
-export declare class Domain extends BoxedSymbol {
-    constructor(ce: IComputeEngine, dom: string, metadata?: Metadata);
+/* 0.6.0 */
+import { BoxedExpression, Domain, DomainExpression, IComputeEngine, Metadata, PatternMatchOption, Substitution } from '../public';
+import { AbstractBoxedExpression } from './abstract-boxed-expression';
+export declare class _Domain extends AbstractBoxedExpression implements Domain {
+    _value: DomainExpression;
+    private _hash;
+    constructor(ce: IComputeEngine, dom: DomainExpression, metadata?: Metadata);
+    get domainExpression(): DomainExpression;
+    get hash(): number;
+    get isCanonical(): boolean;
+    isEqual(rhs: BoxedExpression): boolean;
+    isSame(rhs: BoxedExpression): boolean;
+    isSubdomainOf(rhs: _Domain | string): boolean;
+    isMemberOf(expr: BoxedExpression): boolean;
+    get json(): Expression;
+    match(rhs: BoxedExpression, _options?: PatternMatchOption): Substitution | null;
     get head(): string;
-    get domain(): BoxedExpression;
-    isSubsetOf(dom: BoxedExpression | string): boolean;
+    get domain(): Domain;
+    get codomain(): Domain | null;
+    is(rhs: BoxedExpression): boolean;
+    get isNothing(): boolean;
+    get isFunction(): boolean;
+    get isPredicate(): boolean;
+    get isNumericFunction(): boolean;
+    get isBoolean(): boolean;
+    get isRealFunction(): boolean;
+    get isNumeric(): boolean;
+    get isLogicOperator(): boolean;
+    get isRelationalOperator(): boolean;
 }
+/**
+ * Note that `boxDomain()` should only be called from `ComputeEngine`
+ */
+export declare function boxDomain(ce: IComputeEngine, dom: Domain | DomainExpression, metadata?: Metadata): Domain;

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

@@ -1,2 +1,2 @@
-/* 0.4.3 */
+/* 0.6.0 */
 export declare function makeFunctionDefinition(engine: IComputeEngine, def: FunctionDefinition): BoxedFunctionDefinition;

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

@@ -1,6 +1,6 @@
-/* 0.4.3 */
+/* 0.6.0 */
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, BoxedFunctionDefinition, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOption } from '../public';
+import { BoxedExpression, BoxedFunctionDefinition, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOption, Domain } from '../public';
 /**
  * BoxedFunction
  */
@@ -35,8 +35,10 @@ export declare class BoxedFunction extends AbstractBoxedExpression {
     get op3(): BoxedExpression;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
     _repairDefinition(): void;
+    /** Signature of the function */
+    get domain(): Domain;
     /** Domain of the value of the function */
-    get domain(): BoxedExpression;
+    get valueDomain(): Domain;
     isLess(rhs: BoxedExpression): boolean | undefined;
     isLessEqual(rhs: BoxedExpression): boolean | undefined;
     isGreater(rhs: BoxedExpression): boolean | undefined;
@@ -88,6 +90,8 @@ export declare function ungroup(expr: BoxedExpression): BoxedExpression;
  * - 'last': apply `f` to all elements except the last
  * - 'most': apply `f` to the last elements, skip the others
  *
+ * Account for `Hold`, `ReleaseHold` and  `Nothing`.
+ *
  * 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', f: (BoxedExpression: any) => BoxedExpression | null): BoxedExpression[];

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

@@ -1,7 +1,7 @@
-/* 0.4.3 */
+/* 0.6.0 */
 import { Complex } from 'complex.js';
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, IComputeEngine, Metadata, NOptions, PatternMatchOption, SimplifyOptions, Substitution } from '../public';
+import { BoxedExpression, Domain, IComputeEngine, Metadata, NOptions, PatternMatchOption, SimplifyOptions, Substitution } from '../public';
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
 /**
  * BoxedNumber
@@ -34,7 +34,7 @@ export declare class BoxedNumber extends AbstractBoxedExpression {
     get asFloat(): number | null;
     get asSmallInteger(): number | null;
     get asRational(): [number, number] | [null, null];
-    get domain(): BoxedExpression;
+    get domain(): Domain;
     get json(): Expression;
     get sgn(): -1 | 0 | 1 | undefined | null;
     isSame(rhs: BoxedExpression): boolean;

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

@@ -1,6 +1,6 @@
-/* 0.4.3 */
+/* 0.6.0 */
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, IComputeEngine, LatexString, Metadata, Pattern, PatternMatchOption, SemiBoxedExpression, Substitution } from '../public';
+import { BoxedExpression, Domain, IComputeEngine, LatexString, Metadata, Pattern, PatternMatchOption, SemiBoxedExpression, Substitution } from '../public';
 export declare class BoxedPattern extends AbstractBoxedExpression implements Pattern {
     _pattern: BoxedExpression;
     _canonicalPattern: BoxedExpression | undefined;
@@ -9,7 +9,7 @@ export declare class BoxedPattern extends AbstractBoxedExpression implements Pat
     _purge(): undefined;
     get json(): Expression;
     get head(): string | BoxedExpression;
-    get domain(): BoxedExpression;
+    get valueDomain(): Domain;
     get isCanonical(): boolean;
     set isCanonical(_val: boolean);
     isSame(rhs: BoxedExpression): boolean;

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

@@ -1,6 +1,6 @@
-/* 0.4.3 */
+/* 0.6.0 */
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, IComputeEngine, Metadata, PatternMatchOption, Substitution } from '../public';
+import { BoxedExpression, Domain, IComputeEngine, Metadata, PatternMatchOption, Substitution } from '../public';
 /**
  * BoxedString
  */
@@ -14,7 +14,7 @@ export declare class BoxedString extends AbstractBoxedExpression {
     get isLiteral(): boolean;
     get isCanonical(): boolean;
     set isCanonical(_va: boolean);
-    get domain(): BoxedExpression;
+    get domain(): Domain;
     get complexity(): number;
     get string(): string;
     isEqual(rhs: BoxedExpression): boolean;

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

@@ -1,5 +1,5 @@
-/* 0.4.3 */
-export declare function domainToFlags(dom: BoxedExpression | undefined | null): Partial<SymbolFlags>;
+/* 0.6.0 */
+export declare function domainToFlags(dom: Domain | undefined | null): Partial<SymbolFlags>;
 export declare class BoxedSymbolDefinitionImpl implements BoxedSymbolDefinition {
     private _engine;
     private _value;
@@ -38,13 +38,13 @@ export declare class BoxedSymbolDefinitionImpl implements BoxedSymbolDefinition
     readonly hold: boolean;
     private _def;
     prototype?: BoxedFunctionDefinition;
-    self?: any;
+    self?: unknown;
     constructor(ce: IComputeEngine, def: SymbolDefinition);
     _purge(): undefined;
     get value(): BoxedExpression | undefined;
-    set value(val: BoxedExpression | undefined);
-    get domain(): BoxedExpression | undefined;
-    set domain(domain: BoxedExpression | undefined | string);
+    set value(val: BoxedExpression | number | undefined);
+    get domain(): Domain | undefined;
+    set domain(domain: Domain | undefined | string);
     updateFlags(flags: Partial<SymbolFlags>): void;
     setProps(props: Omit<Partial<BoxedSymbolDefinition>, 'domain' | 'value'>): void;
     get number(): boolean | undefined;

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

@@ -1,6 +1,6 @@
-/* 0.4.3 */
+/* 0.6.0 */
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SemiBoxedExpression, SimplifyOptions, Substitution, Metadata, PatternMatchOption } from '../public';
+import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOption, Domain } from '../public';
 /**
  * BoxedSymbol
  *
@@ -29,10 +29,10 @@ export declare class BoxedSymbol extends AbstractBoxedExpression {
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
     _repairDefinition(): void;
     get value(): BoxedExpression | undefined;
-    set value(value: SemiBoxedExpression | undefined);
+    set value(value: BoxedExpression | number | undefined);
     get numericValue(): BoxedExpression | undefined;
-    get domain(): BoxedExpression;
-    set domain(d: BoxedExpression);
+    get domain(): Domain;
+    set domain(d: Domain);
     get json(): Expression;
     get sgn(): -1 | 0 | 1 | undefined | null;
     has(x: string | string[]): boolean;

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

@@ -1,4 +1,4 @@
-/* 0.4.3 */
+/* 0.6.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,5 +1,6 @@
-/* 0.4.3 */
+/* 0.6.0 */
 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,

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

@@ -1,4 +1,4 @@
-/* 0.4.3 */
+/* 0.6.0 */
 import Decimal from 'decimal.js';
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, IComputeEngine, Metadata } from '../public';

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

@@ -1,6 +1,6 @@
-/* 0.4.3 */
-export declare function isLatexString(s: any): s is string;
-export declare function latexString(s: any): string | null;
+/* 0.6.0 */
+export declare function isLatexString(s: unknown): s is string;
+export declare function latexString(s: unknown): string | null;
 /**
  * Return a multiple of the imaginary unit, e.g.
  * - 'ImaginaryUnit'

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

@@ -1,33 +1,62 @@
-/* 0.4.3 */
-import { DictionaryCategory, LatexString, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
-import { Decimal } from 'decimal.js';
+/* 0.6.0 */
 import { Complex } from 'complex.js';
+import { Expression, MathJsonNumber } from '../math-json/math-json-format';
 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';
+import type { DictionaryCategory, LatexDictionary, 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, Domain, DomainExpression } 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.
+ * 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;
@@ -45,17 +74,22 @@ export declare class ComputeEngine implements IComputeEngine {
     private _commonSymbols;
     private _commonNumbers;
     private _commonDomains;
+    private _latexDictionary?;
     /**
      * The current scope.
      *
-     * A scope is a dictionary that contains the definition of local symbols.
+     * 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 */
+    /** Absolute time beyond which evaluation should not proceed.
+     * @internal
+     */
     deadline?: number;
     /**
      * Return dictionaries suitable for the specified categories, or `"all"`
@@ -67,22 +101,37 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     static getDictionaries(categories?: DictionaryCategory[] | 'all'): Readonly<Dictionary>[];
     /**
-     * Construct a new `ComputeEngine` environment.
+     * 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.
      *
-     * If no `options.dictionaries` is provided a default set of dictionaries
-     * is used. The `ComputeEngine.getDictionaries()` method can be called
-     * to access some 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.
+     *
+     * @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>[];
+        latexDictionary?: readonly LatexDictionaryEntry[];
         numericMode?: NumericMode;
-        assumptions?: (LatexString | Expression)[];
         numericPrecision?: number;
         tolerance?: number;
+        assumptions?: (LatexString | Expression)[];
         defaultDomain?: string;
     });
     /** After the configuration of the engine has changed, clear the caches
@@ -90,15 +139,21 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      * 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 numerical calculations
+    /** 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
@@ -109,26 +164,24 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     get precision(): number;
     set precision(p: number | 'machine');
-    /**
-     * 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);
+    /** @experimental */
     get timeLimit(): number;
+    /** @experimental */
     get iterationLimit(): number;
+    /** @experimental */
     get recursionLimit(): number;
-    get defaultDomain(): BoxedExpression | null;
-    set defaultDomain(domain: BoxedExpression | string | null);
+    /**
+     * 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(): Domain | null;
+    set defaultDomain(domain: Domain | 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
@@ -136,10 +189,15 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     get tolerance(): number;
     set tolerance(val: number);
+    /** 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();
+    static getLatexDictionary(domain?: DictionaryCategory | 'all'): Readonly<LatexDictionary>;
     set costFunction(fn: ((expr: BoxedExpression) => number) | undefined);
     get costFunction(): (expr: BoxedExpression) => number;
     /**
@@ -148,11 +206,12 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     getSymbolDefinition(symbol: string, wikidata?: string): undefined | BoxedSymbolDefinition;
     /**
-     * Return the definition for a function matching this head.
+     * Return the definition for a function matching this head and
+     * these arguments.
      *
      * Start looking in the current scope, than up the scope chain.
      */
-    getFunctionDefinition(head: string): undefined | BoxedFunctionDefinition;
+    getFunctionDefinition(head: string, args?: BoxedExpression[]): undefined | BoxedFunctionDefinition;
     /**
      * Add (or replace) a definition for a symbol in the current scope.
      */
@@ -180,8 +239,11 @@ export declare class ComputeEngine implements IComputeEngine {
      * This can occur if:
      * - an error has been signaled
      * - the time limit or memory limit has been exceeded
+     *
+     * @internal
      */
     shouldContinueExecution(): boolean;
+    /** @internal */
     checkContinueExecution(): void;
     assert(condition: boolean, expr: BoxedExpression, msg: string, code?: SignalMessage): void;
     /**
@@ -196,9 +258,11 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     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;
@@ -211,16 +275,16 @@ export declare class ComputeEngine implements IComputeEngine {
     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;
+    domain(domain: BoxedExpression | DomainExpression | Domain, metadata?: Metadata): Domain;
     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: null): null;
     parse(s: LatexString | string | null): null | BoxedExpression;
     serialize(x: Expression | BoxedExpression): string;
-    get latexOptions(): Required<NumberFormattingOptions> & Required<ParseLatexOptions> & Required<SerializeLatexOptions>;
-    set latexOptions(opts: NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions);
+    get latexOptions(): NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
+    set latexOptions(opts: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>);
     get jsonSerializationOptions(): JsonSerializationOptions;
     set jsonSerializationOptions(val: Partial<JsonSerializationOptions>);
     /**
@@ -233,19 +297,6 @@ export declare class ComputeEngine implements IComputeEngine {
      * ```
      */
     ask(pattern: LatexString | SemiBoxedExpression): Substitution[];
-    /**
-     * Add an assumption.
-     *
-     * Return `contradiction` if the new assumption is incompatible with previous
-     * ones.
-     *
-     * 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.
-     *
-     */
     assume(symbol: LatexString | SemiBoxedExpression, domain: string | BoxedExpression): AssumeResult;
     assume(predicate: LatexString | SemiBoxedExpression): AssumeResult;
     forget(symbol: undefined | string | string[]): void;

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

@@ -1,3 +1,3 @@
-/* 0.4.3 */
+/* 0.6.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

@@ -1,4 +1,4 @@
-/* 0.4.3 */
+/* 0.6.0 */
 /** The canonical form of `Add`:
  * - removes `0`
  * - adds up small integers and rational numbers
@@ -6,6 +6,6 @@
  * - 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 domainAdd(_ce: IComputeEngine, args: BoxedExpression[]): Domain | string | null;
 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

@@ -1,4 +1,4 @@
-/* 0.4.3 */
+/* 0.6.0 */
 /**
  * Canonical form of 'Divide' (and 'Rational')
  * - remove denominator of 1

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

@@ -1,4 +1,4 @@
-/* 0.4.3 */
+/* 0.6.0 */
 /** The canonical form of `Multiply`:
  * - remove `1`
  * - combine literal small integers and rationals

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

@@ -1,4 +1,4 @@
-/* 0.4.3 */
+/* 0.6.0 */
 /**
  *
  * Return `null` if there is no canonicalization necessary and the result is

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

@@ -1,2 +1,2 @@
-/* 0.4.3 */
+/* 0.6.0 */
 export declare const ARITHMETIC_DICTIONARY: Dictionary[];

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

@@ -1,2 +1,2 @@
-/* 0.4.3 */
+/* 0.6.0 */
 export declare const COLLECTIONS_DICTIONARY: Dictionary;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.4.3 */
+/* 0.6.0 */
 import { IComputeEngine, Dictionary } from '../public';
 export declare function getDefaultDictionaries(categories?: DictionaryCategory[] | 'all'): Readonly<Dictionary>[];
 export declare const DICTIONARIES: {

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

@@ -1,2 +1,2 @@
-/* 0.4.3 */
+/* 0.6.0 */
 export declare const LOGIC_DICTIONARY: Dictionary;

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

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

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

@@ -1,2 +1,2 @@
-/* 0.4.3 */
+/* 0.6.0 */
 export declare const RELOP_DICTIONARY: Dictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.3 */
+/* 0.6.0 */
 export declare const SETS_DICTIONARY: Dictionary;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.4.3 */
+/* 0.6.0 */
 import { Decimal } from 'decimal.js';
 import { BoxedExpression } from './public';
 /** Quickly determine the numeric domain of a number or constant

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

@@ -1,2 +1,2 @@
-/* 0.4.3 */
+/* 0.6.0 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.3 */
+/* 0.6.0 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.3 */
+/* 0.6.0 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.4.3 */
+/* 0.6.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

@@ -1,2 +1,2 @@
-/* 0.4.3 */
+/* 0.6.0 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionary;