@cortex-js/compute-engine 0.4.2 → 0.4.3

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.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>[];
 };
 /**
- * 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.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

@@ -1,2 +1,2 @@
-/* 0.4.2 */
+/* 0.4.3 */
 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.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;

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

@@ -0,0 +1,57 @@
+/* 0.4.3 */
+import { WarningSignal } from '../../../common/signals';
+export declare type CommonEntry = {
+    name?: string;
+    serialize: SerializeHandler | LatexString;
+};
+export declare type SymbolEntry = CommonEntry & {
+    kind: 'symbol';
+    precedence: number;
+    arguments: 'group' | 'implicit' | '';
+    optionalLatexArg: number;
+    requiredLatexArg: number;
+    parse: SymbolParseHandler;
+};
+export declare type MatchfixEntry = CommonEntry & {
+    kind: 'matchfix';
+    openDelimiter: Delimiter | LatexToken[];
+    closeDelimiter: Delimiter | LatexToken[];
+    parse: MatchfixParseHandler;
+};
+export declare type InfixEntry = CommonEntry & {
+    kind: 'infix';
+    associativity: 'right' | 'left' | 'non' | 'both';
+    precedence: number;
+    parse: InfixParseHandler;
+};
+export declare type PrefixEntry = CommonEntry & {
+    kind: 'prefix';
+    precedence: number;
+    parse: PrefixParseHandler;
+};
+export declare type PostfixEntry = CommonEntry & {
+    kind: 'postfix';
+    precedence: number;
+    parse: PostfixParseHandler;
+};
+export declare type EnvironmentEntry = CommonEntry & {
+    kind: 'environment';
+    optionalLatexArg: number;
+    requiredLatexArg: number;
+    parse: EnvironmentParseHandler;
+};
+export declare type IndexedLatexDictionaryEntry = SymbolEntry | MatchfixEntry | InfixEntry | PrefixEntry | PostfixEntry | EnvironmentEntry;
+export declare type IndexedLatexDictionary = {
+    lookahead: number;
+    name: Map<string, IndexedLatexDictionaryEntry>;
+    symbol: (Map<LatexString, SymbolEntry[]> | null)[];
+    prefix: (Map<LatexString, PrefixEntry[]> | null)[];
+    infix: (Map<LatexString, InfixEntry[]> | null)[];
+    postfix: (Map<LatexString, PostfixEntry[]> | null)[];
+    matchfix: MatchfixEntry[];
+    environment: Map<string, EnvironmentEntry>;
+};
+export declare function indexLatexDictionary(dic: readonly LatexDictionaryEntry[], onError: (sig: WarningSignal) => void): IndexedLatexDictionary;
+export declare const DEFAULT_LATEX_DICTIONARY: {
+    [category in DictionaryCategory]?: LatexDictionary;
+};

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

@@ -0,0 +1,23 @@
+/* 0.4.3 */
+import { Serializer } from './serializer';
+import { Expression } from '../../math-json/math-json-format';
+import { WarningSignalHandler } from '../../common/signals';
+import { IComputeEngine } from '../public';
+export declare const DEFAULT_SERIALIZE_LATEX_OPTIONS: Required<SerializeLatexOptions>;
+export declare class LatexSyntax {
+    onError: WarningSignalHandler;
+    options: Required<NumberFormattingOptions> & Required<ParseLatexOptions> & Required<SerializeLatexOptions>;
+    readonly computeEngine: IComputeEngine;
+    private dictionary;
+    private _serializer?;
+    constructor(options: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions> & {
+        computeEngine: IComputeEngine;
+        dictionary?: readonly LatexDictionaryEntry[];
+        onError?: WarningSignalHandler;
+    });
+    updateOptions(opt: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>): void;
+    static getDictionary(domain?: DictionaryCategory | 'all'): Readonly<LatexDictionary>;
+    parse(latex: LatexString): Expression;
+    serialize(expr: Expression): LatexString;
+    get serializer(): Serializer;
+}

package/dist/types/compute-engine/latex-syntax/parse.d.ts

@@ -0,0 +1,198 @@
+/* 0.4.3 */
+import { ParseLatexOptions, LatexToken, NumberFormattingOptions, Delimiter, Terminator, Parser } from './public';
+import { IndexedLatexDictionary, InfixEntry, PostfixEntry, PrefixEntry, SymbolEntry } from './dictionary/definitions';
+import { WarningSignalHandler } from '../../common/signals';
+import { IComputeEngine } from '../public';
+export declare const DEFAULT_LATEX_NUMBER_OPTIONS: Required<NumberFormattingOptions>;
+export declare const DEFAULT_PARSE_LATEX_OPTIONS: Required<ParseLatexOptions>;
+export declare class _Parser implements Parser {
+    readonly onError: WarningSignalHandler;
+    readonly options: Required<NumberFormattingOptions> & Required<ParseLatexOptions>;
+    readonly engine: IComputeEngine;
+    readonly _dictionary: IndexedLatexDictionary;
+    index: number;
+    _lastPeek: string;
+    _peekCounter: number;
+    readonly _tokens: LatexToken[];
+    constructor(tokens: LatexToken[], options: Required<NumberFormattingOptions> & Required<ParseLatexOptions>, dictionary: IndexedLatexDictionary, computeEngine: IComputeEngine, onError: WarningSignalHandler);
+    updateOptions(opt: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions>): void;
+    clone(start: number, end: number): Parser;
+    get atEnd(): boolean;
+    get peek(): LatexToken;
+    /**
+     * Return true if
+     * - at end of the token stream
+     * - the upcoming tokens match `t.tokens`
+     * - the `t.condition` function returns true
+     * Note: the `minPrec` condition is not checked. It should be checked separately.
+     */
+    atTerminator(t?: Terminator): boolean;
+    latex(start: number, end?: number): string;
+    latexAhead(n: number): string;
+    latexBefore(): string;
+    latexAfter(): string;
+    /**
+     * Return at most `lookahead` strings made from the tokens
+     * ahead.
+     *
+     * The index in the returned array correspond to the number of tokens.
+     * Note that since a token can be longer than one char ('\\pi', but also
+     * some astral plane unicode characters), the length of the string
+     * does not match that index. However, knowing the index is important
+     * to know by how many tokens to advance.
+     *
+     */
+    lookAhead(): string[];
+    /** Return all the definitions that potentially match the tokens ahead */
+    peekDefinitions(kind: 'symbol'): [SymbolEntry, number][] | null;
+    peekDefinitions(kind: 'postfix'): [PostfixEntry, number][] | null;
+    peekDefinitions(kind: 'postfix'): [PostfixEntry, number][] | null;
+    peekDefinitions(kind: 'operator'): [InfixEntry | PrefixEntry | PostfixEntry, number][] | null;
+    peekDefinitions(kind: 'infix'): [InfixEntry, number][] | null;
+    peekDefinitions(kind: 'prefix'): [PrefixEntry, number][] | null;
+    next(): LatexToken;
+    skipSpace(): boolean;
+    matchChar(): string | null;
+    matchColor(_background?: boolean): string | null;
+    matchLatexDimension(): string | null;
+    match(token: LatexToken): boolean;
+    matchAll(tokens: LatexToken | LatexToken[]): boolean;
+    matchAny(tokens: LatexToken[]): LatexToken;
+    matchWhile(tokens: LatexToken[]): LatexToken[];
+    matchSign(): string;
+    matchDecimalDigits(): string;
+    matchSignedInteger(): string;
+    matchExponent(): string;
+    matchNumber(): string;
+    /**
+     * A Latex number can be a decimal, hex or octal number.
+     * It is used in some Latex commands, such as `\char`
+     *
+     * From TeX:8695 (scan_int):
+     * > An integer number can be preceded by any number of spaces and `+' or
+     * > `-' signs. Then comes either a decimal constant (i.e., radix 10), an
+     * > octal constant (i.e., radix 8, preceded by '), a hexadecimal constant
+     * > (radix 16, preceded by "), an alphabetic constant (preceded by `), or
+     * > an internal variable.
+     */
+    matchLatexNumber(isInteger?: boolean): null | number;
+    matchPrefixOperator(until?: Terminator): Expression | null;
+    matchInfixOperator(lhs: Expression, until?: Terminator): Expression | null;
+    /**
+     * 'group' : will look for an argument inside a pair of `()`
+     * 'implicit': either an expression inside a pair of `()`, or just a primary
+     *  (i.e. we interpret `\cos x + 1` as `\cos(x) + 1`)
+     */
+    matchArguments(kind: undefined | '' | 'group' | 'implicit'): Expression[] | null;
+    /** If matches the normalized open delimiter, returns the
+     * expected closing delimiter.
+     *
+     * For example, if `delimiter` is `(`, it would match `\left\lparen` and
+     * return `['\right', '\rparen']`, which can be matched with `matchAll()`
+     *
+     * If you need to match several tokens, use `matchAll()`
+     */
+    matchOpenDelimiter(openDelim: Delimiter, closeDelim: Delimiter): LatexToken[] | null;
+    matchMiddleDelimiter(delimiter: '|' | ':' | LatexToken): boolean;
+    /**
+     * An enclosure is an opening matchfix operator, an expression, optionally
+     * followed multiple times by a separator and another expression,
+     * and finally a closing matching operator.
+     */
+    matchEnclosure(): Expression | null;
+    /**
+     * A symbol can be:
+     * - a constant: `\pi`
+     * - a variable: `x`
+     * - a function with explicit arguments `f(x)`
+     * - a function with implicit arguments: `\cos x`
+     * - a command: `\frac{2}{3}`
+     */
+    matchSymbol(): Expression | null;
+    matchOptionalLatexArgument(): Expression | null;
+    /**
+     * Match a required LaTeX argument:
+     * - either enclosed in `{}`
+     * - or a single token.
+     *
+     * Return null if an argument was not found
+     * Return 'Nothing' if an empty argument `{}` was found
+     */
+    matchRequiredLatexArgument(): Expression | null;
+    /**
+     *  Match a sequence superfix/subfix operator, e.g. `^{*}`
+     *
+     * Superfix and subfix need special handling:
+     *
+     * - they act mostly like an infix operator, but they are commutative, i.e.
+     * `x_a^b` should be parsed identically to `x^b_a`.
+     *
+     * - furthermore, in LaTeX, consecutive `^` or `_` are treated as concatenated,
+     * that is `x^a^b` parses the same as `x^{ab}`.
+     *
+     */
+    matchSupsub(lhs: Expression | null): Expression | null;
+    matchPostfix(lhs: Expression | null): Expression | null;
+    matchString(until: {
+        tokens: LatexToken[];
+    } & Partial<Terminator>): string;
+    matchEnvironmentName(command: '\\begin' | '\\end', envName: string): boolean;
+    /**
+     * Match an expression in a tabular format,
+     * where row are separated by `\\` and columns by `&`
+     *
+     * Return rows of sparse columns as a list: empty rows are indicated with NOTHING,
+     * and empty cells are also indicated with NOTHING.
+     */
+    matchTabular(endName: string): null | Expression;
+    matchEnvironment(): Expression | null;
+    /**
+     * Apply an invisible operator between two expressions.
+     *
+     * If the `lhs` is an literal integer and the `rhs` is a literal rational
+     * -> 'invisible plus'
+     *
+     * That is '2 3/4' -> ['Add', 2, ['Rational', 3, 4]]
+     *
+     * If `lhs` is a number and `rhs` is a number but not a literal -> 'invisible multiply'.
+     * - 2x
+     * - 2(x+1)
+     * - x(x+1)
+     * - f(x)g(y)
+     * - 2 sin(x)
+     * - 2 f(x)
+     * - x f(x)
+     * - (x-1)(x+1)
+     * - (x+1)2 -> no
+     * - x2 -> no
+     * => lhs is a number, rhs is a number, but not a literal
+     */
+    applyInvisibleOperator(terminator: Terminator, rawLhs: Expression | null): Expression | null;
+    matchUnknownLatexCommand(): Expression | null;
+    /**
+     * <primary> :=
+     * (<number> | <symbol> | <environment> | <matchfix-expr>) <subsup>* <postfix-operator>*
+     *
+     * <symbol> ::= (<symbol-id> | (<latex-command><latex-arguments>)) <arguments>
+     *
+     * <matchfix-expr> :=
+     *  <matchfix-op-open> <expression> [<matchfix-op-separator> <expression>] <matchfix-op-close>
+     *
+     */
+    matchPrimary(): Expression | null;
+    /**
+     *  Parse an expression:
+     *
+     * <expression> ::=
+     *  | <primary>
+     *  | <prefix-op> <primary>
+     *  | <primary> <infix-op> <expression>
+     *
+     * Stop when an operator of precedence less than `minPrec` is encountered
+     */
+    matchExpression(until?: Partial<Terminator>): Expression | null;
+    /**
+     * Add latex or other requested metadata to the expression
+     */
+    decorate(expr: Expression | null, start: number): Expression | null;
+}