@cortex-js/compute-engine 0.4.0 → 0.4.3

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

@@ -0,0 +1,74 @@
+/* 0.4.3 */
+import { AbstractBoxedExpression } from './abstract-boxed-expression';
+import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SemiBoxedExpression, 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: SemiBoxedExpression | 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.3 */
+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,52 @@
+/* 0.4.3 */
+export declare type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
+/**
+ * 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.3 */
+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.3 */
+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

@@ -0,0 +1,252 @@
+/* 0.4.3 */
+import { DictionaryCategory, 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;
+    /**
+     * 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 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.
+     */
+    constructor(options?: {
+        dictionaries?: Readonly<Dictionary>[];
+        numericMode?: NumericMode;
+        assumptions?: (LatexString | Expression)[];
+        numericPrecision?: number;
+        tolerance?: number;
+        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');
+    /**
+     * 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);
+    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(): 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;
+    assert(condition: boolean, expr: BoxedExpression, msg: string, code?: SignalMessage): void;
+    /**
+     * 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.
+     *
+     */
+    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(): Required<NumberFormattingOptions> & Required<ParseLatexOptions> & Required<SerializeLatexOptions>;
+    set latexOptions(opts: NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions);
+    get jsonSerializationOptions(): JsonSerializationOptions;
+    set jsonSerializationOptions(val: Partial<JsonSerializationOptions>);
+    /**
+     * 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[];
+    /**
+     * 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

@@ -0,0 +1,3 @@
+/* 0.4.3 */
+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.3 */
+/** 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.3 */
+/**
+ * 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.3 */
+/** 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.3 */
+/**
+ *
+ * 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.0 */
-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.3 */
+export declare const ARITHMETIC_DICTIONARY: Dictionary[];

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

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

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

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

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

@@ -0,0 +1,26 @@
+/* 0.4.3 */
+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>[];
+};
+/**
+ * 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 boxed
+ * - The domain of entries is inferred and validated:
+ *  - check that domains are in canonical form
+ *  - check that domains are consistent with declarations
+ *
+ */
+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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,30 @@
+/* 0.4.3 */
+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.4.3 */
+export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

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

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

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

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

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

@@ -0,0 +1,4 @@
+/* 0.4.3 */
+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.4.3 */
+export declare const DEFINITIONS_INEQUALITIES: LatexDictionary;

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

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

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

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

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

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

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

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

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

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