@cortex-js/compute-engine 0.4.3 → 0.6.0

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

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

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.4.3 */
+/* 0.6.0 */
 import { WarningSignal } from '../../../common/signals';
 export declare type CommonEntry = {
     name?: string;
@@ -7,7 +7,6 @@ export declare type CommonEntry = {
 export declare type SymbolEntry = CommonEntry & {
     kind: 'symbol';
     precedence: number;
-    arguments: 'group' | 'implicit' | '';
     optionalLatexArg: number;
     requiredLatexArg: number;
     parse: SymbolParseHandler;

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

@@ -1,4 +1,4 @@
-/* 0.4.3 */
+/* 0.6.0 */
 import { Serializer } from './serializer';
 import { Expression } from '../../math-json/math-json-format';
 import { WarningSignalHandler } from '../../common/signals';
@@ -6,7 +6,7 @@ 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>;
+    options: NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
     readonly computeEngine: IComputeEngine;
     private dictionary;
     private _serializer?;
@@ -16,7 +16,7 @@ export declare class LatexSyntax {
         onError?: WarningSignalHandler;
     });
     updateOptions(opt: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>): void;
-    static getDictionary(domain?: DictionaryCategory | 'all'): Readonly<LatexDictionary>;
+    static getDictionary(category?: 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

@@ -1,20 +1,20 @@
-/* 0.4.3 */
+/* 0.6.0 */
 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 const DEFAULT_LATEX_NUMBER_OPTIONS: NumberFormattingOptions;
+export declare const DEFAULT_PARSE_LATEX_OPTIONS: ParseLatexOptions;
 export declare class _Parser implements Parser {
     readonly onError: WarningSignalHandler;
-    readonly options: Required<NumberFormattingOptions> & Required<ParseLatexOptions>;
+    readonly options: NumberFormattingOptions & 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);
+    constructor(tokens: LatexToken[], options: NumberFormattingOptions & ParseLatexOptions, dictionary: IndexedLatexDictionary, computeEngine: IComputeEngine, onError: WarningSignalHandler);
     updateOptions(opt: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions>): void;
     clone(start: number, end: number): Parser;
     get atEnd(): boolean;
@@ -79,11 +79,13 @@ export declare class _Parser implements Parser {
     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
+     * - 'enclosure' : will look for an argument inside an enclosure (open/close fence)
+     * - 'implicit': either an expression inside a pair of `()`, or just a primary
      *  (i.e. we interpret `\cos x + 1` as `\cos(x) + 1`)
+     * - 'group': the arguments follow until an end of group, `<}>`. This is the
+     * case for example for `\displaystyle`
      */
-    matchArguments(kind: undefined | '' | 'group' | 'implicit'): Expression[] | null;
+    matchArguments(kind: undefined | '' | 'enclosure' | 'implicit' | 'group'): Expression[] | null;
     /** If matches the normalized open delimiter, returns the
      * expected closing delimiter.
      *
@@ -103,7 +105,8 @@ export declare class _Parser implements Parser {
     /**
      * A symbol can be:
      * - a constant: `\pi`
-     * - a variable: `x`
+     * - a single-letter variable: `x`
+     * - a multi-letter variable: `\mathit{speed}` or `\mathrm{speed}`
      * - a function with explicit arguments `f(x)`
      * - a function with implicit arguments: `\cos x`
      * - a command: `\frac{2}{3}`
@@ -133,9 +136,7 @@ export declare class _Parser implements Parser {
      */
     matchSupsub(lhs: Expression | null): Expression | null;
     matchPostfix(lhs: Expression | null): Expression | null;
-    matchString(until: {
-        tokens: LatexToken[];
-    } & Partial<Terminator>): string;
+    matchString(until: Partial<Terminator>): string;
     matchEnvironmentName(command: '\\begin' | '\\end', envName: string): boolean;
     /**
      * Match an expression in a tabular format,
@@ -192,7 +193,7 @@ export declare class _Parser implements Parser {
      */
     matchExpression(until?: Partial<Terminator>): Expression | null;
     /**
-     * Add latex or other requested metadata to the expression
+     * Add LaTeX or other requested metadata to the expression
      */
     decorate(expr: Expression | null, start: number): Expression | null;
 }

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

@@ -1,6 +1,6 @@
-/* 0.4.3 */
+/* 0.6.0 */
 import { Expression } from '../../math-json/math-json-format';
-import { IComputeEngine } from '../public';
+import type { IComputeEngine } from '../public';
 /**
  * A `LatexToken` is a token as returned by `Scanner.peek`.
  *
@@ -13,7 +13,11 @@ export declare type LatexToken = string | '<{>' | '<}>' | '<space>' | '<$>' | '<
  * `\frac{\pi}{2}`
  */
 export declare type LatexString = string;
-export declare type Delimiter = ')' | '(' | ']' | '[' | '{' | '<' | '>' | '}' | '|' | '||' | '\\lceil' | '\\lfloor' | '\\rceil' | '\\rfloor';
+/**
+ * Open and close delimiters that can be used with {@link MatchfixEntry}
+ * record to define new LaTeX dictionary entries.
+ */
+export declare type Delimiter = ')' | '(' | ']' | '[' | '{' /** \lbrace */ | '}' /** \rbrace */ | '<' /** \langle  */ | '>' /** \rangle  */ | '|' | '||' | '\\lceil' | '\\rceil' | '\\lfloor' | '\\rfloor';
 export declare type DictionaryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collections' | 'combinatorics' | 'core' | 'dimensions' | 'domains' | 'linear-algebra' | 'logic' | 'numeric' | 'other' | 'physics' | 'polynomials' | 'relop' | 'sets' | 'statistics' | 'symbols' | 'trigonometry' | 'units';
 /**
  * This indicates a condition under which parsing should stop:
@@ -108,11 +112,11 @@ export declare type InfixEntry = BaseEntry & {
     /**
      * Infix position, with an operand before and an operand after: `a ⊛ b`.
      *
-     *      Example: `+`, `\times`
+     * Example: `+`, `\times`.
      */
     kind: 'infix';
     /**
-     * - **`both`**: a + b + c -> +(a, b, c)
+     * - **`both`**: a + b + c  +(a, b, c)
      * - **`left`**: a / b / c -> /(/(a, b), c)
      * - **`right`**: a = b = c -> =(a, =(b, c))
      * - **`non`**: a < b < c -> syntax error
@@ -131,7 +135,7 @@ export declare type PostfixEntry = BaseEntry & {
     /**
      * Postfix position, with an operand before: `a ⊛`
      *
-     *      Example: `!`
+     * Example: `!`.
      */
     kind: 'postfix';
     precedence?: number;
@@ -141,25 +145,27 @@ export declare type PrefixEntry = BaseEntry & {
     /**
      * Prefix position, with an operand after: `⊛ a`
      *
-     *      Example: `-`, `\not`
+     * Example: `-`, `\not`.
      */
     kind: 'prefix';
     precedence: number;
     parse: PrefixParseHandler;
 };
+/**
+ * A LaTeX dictionary entry for an environment, that is a LaTeX
+ * construct using `\begin{...}...\end{...}`.
+ */
 export declare type EnvironmentEntry = BaseEntry & {
-    /**
-     * The name of an environment, as used in `\begin{matrix}` where
-     * `"matrix"` is the name of the environment.
-     */
     kind: 'environment';
     parse: EnvironmentParseHandler;
 };
 export declare type SymbolEntry = BaseEntry & {
     kind: 'symbol';
+    /** Used for appropriate wrapping (i.e. when to surround it with parens) */
     precedence?: number;
     /**
      * Indicate if this symbol can be followed by arguments.
+     *
      * The presence of arguments will indicate that the arguments should be
      * applied to the symbol. Otherwise, the invisible operator is applied
      * to the symbol and the arguments.
@@ -167,14 +173,14 @@ export declare type SymbolEntry = BaseEntry & {
      * If `arguments` is `"group"`:
      *
      * "f(x)" -> `["f", "x"]`
-     * "f x" -> `["multiply", "f", "x"]`
+     * "f x" -> `["Multiply", "f", "x"]`
      *
      * If `arguments` is `""`:
      *
-     * "f(x)" -> `["multiply", "f", ["group", "x"]]`
-     * "f x" -> `["multiply", "f", "x"]`
+     * "f(x)" -> `["Multiply", "f", "x"]`
+     * "f x" -> `["Multiply", "f", "x"]`
      *
-     * If `arguments` is `"group/primary"` and the symbol is followed either
+     * If `arguments` is `"implicit"` and the symbol is followed either
      * by a group or by a primary (prefix + symbol + subsupfix + postfix).
      * Used for trig functions. i.e. `\sin x` vs `\sin(x)`:
      *
@@ -182,9 +188,7 @@ export declare type SymbolEntry = BaseEntry & {
      * "f x" -> `["f", "x"]`
      *
      */
-    arguments?: 'group' | 'implicit' | '';
     /**
-     * Applicable when `kind` is `"symbol"`.
      *
      * If a LaTeX command (i.e. the trigger starts with `\`, e.g. `\sqrt`)
      * indicates the number of optional arguments expected (indicate with
@@ -195,7 +199,6 @@ export declare type SymbolEntry = BaseEntry & {
      */
     optionalLatexArg?: number;
     /**
-     * Applicable when `kind` is `"symbol"`.
      *
      * If a LaTeX command (i.e. the trigger starts with `\`, e.g. `\frac`)
      * indicates the number of required arguments expected (indicated with
@@ -207,19 +210,27 @@ export declare type SymbolEntry = BaseEntry & {
     requiredLatexArg?: number;
     parse: Expression | SymbolParseHandler;
 };
+/**
+ * A simple LaTeX dictionary entry, for example for a command like `\pi`.
+ */
 export declare type DefaultEntry = BaseEntry & {
     precedence?: number;
-    arguments?: 'group' | 'implicit' | '';
     optionalLatexArg?: number;
     requiredLatexArg?: number;
     parse?: Expression | SymbolParseHandler;
 };
 export declare type LatexDictionaryEntry = DefaultEntry | MatchfixEntry | InfixEntry | PostfixEntry | PrefixEntry | SymbolEntry | EnvironmentEntry;
+/** @internal */
 export declare function isSymbolEntry(entry: LatexDictionaryEntry): entry is SymbolEntry;
+/** @internal */
 export declare function isMatchfixEntry(entry: LatexDictionaryEntry): entry is MatchfixEntry;
+/** @internal */
 export declare function isInfixEntry(entry: LatexDictionaryEntry): entry is InfixEntry;
+/** @internal */
 export declare function isPrefixEntry(entry: LatexDictionaryEntry): entry is PrefixEntry;
+/** @internal */
 export declare function isPostfixEntry(entry: LatexDictionaryEntry): entry is PostfixEntry;
+/** @internal */
 export declare function isEnvironmentEntry(entry: LatexDictionaryEntry): entry is EnvironmentEntry;
 export declare type LatexDictionary = LatexDictionaryEntry[];
 export declare type ParseLatexOptions = {
@@ -266,25 +277,31 @@ export declare type ParseLatexOptions = {
      */
     parseNumbers: boolean;
     /**
-     * The `parseUnknownToken`  function is invoked when a token (`a`,
-     * `\alpha`...) is encountered at a position where a symbol or a function
-     * could be parsed.
+     * This handler is invoked when the parser encounter a set of tokens
+     * at a position that could be a symbol or function.
+     *
+     * The `symbol` argument is one or more tokens.
      *
-     * If it returns `symbol` or `function`, the token is interpreted as a symbol
-     * or function, respectively.
+     * The handler can return:
      *
-     * If a `function` and the token is followed by an apply function operator
-     * (typically, parentheses), parse them as arguments to the function.
+     * - `symbol` to indicate the string represent a constant or variable.
      *
-     * If `skip`, the token is skipped as if it was not present. This is
-     * convenient for purely presentational commands, such as `\displaystyle`.
+     * - `function` to indicate the string is a function name. If an apply
+     * function operator (typically, parentheses) follow, parse them as arguments
+     * to the function.
      *
-     * If `error`, an error condition is raised.
+     * - `error`, an error condition is raised.
      */
-    parseUnknownToken: (token: LatexToken, parser: Parser) => 'symbol' | 'function' | 'skip' | 'error';
+    parseUnknownSymbol: (symbol: string, parser: Parser) => 'symbol' | 'function' | 'unknown';
     /**
      * If true, the expression will be decorated with the LaTeX
-     * fragments corresponding to each elements of the expression
+     * fragments corresponding to each elements of the expression.
+     *
+     * The top-level expression, that is the one returned by `parse()`, will
+     * include the verbatim LaTeX input that was parsed. The sub-expressions
+     * may contain a slightly different LaTeX, for example with consecutive spaces
+     * replaced by one, with comments removed and with some low-level LaTeX
+     * commands replaced, for example `\egroup` and `\bgroup`.
      */
     preserveLatex: boolean;
 };
@@ -447,7 +464,7 @@ export interface Parser {
     readonly atEnd: boolean;
     /** Return the next token, without advancing the index */
     readonly peek: LatexToken;
-    /** Return true if the terminator conditin is met */
+    /** Return true if the terminator condition is met */
     atTerminator(t: Terminator): boolean;
     /** Return an array of string corresponding to tokens ahead.
      * The index is unchanged.
@@ -495,16 +512,18 @@ export interface Parser {
     /** If the next tokens correspond to an optional LaTeX argument,
      * enclosed with `[` and `]` return the content of the argument
      * as an expression and advance the index past the closing `]`.
+     *
      * Otherwise, return `null`.
      */
     matchOptionalLatexArgument(): Expression | null;
     matchRequiredLatexArgument(): 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`)
+     * - 'enclosure' : will look for an argument inside an enclosure (an open/close fence)
+     * - 'group': arguments follow directly the symbol, until an end of group token `<}>`
+     * - '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: '' | 'group' | 'implicit'): Expression[] | null;
+    matchArguments(kind: '' | 'group' | 'implicit' | 'enclosure'): Expression[] | null;
     /** If matches the normalized open delimiter, returns the
      * expected closing delimiter.
      *
@@ -516,16 +535,22 @@ export interface Parser {
     matchMiddleDelimiter(delimiter: '|' | ':' | LatexToken): boolean;
     matchSupsub(lhs: Expression | null): Expression | null;
     /**
-     * <primary> :=
-     * (<number> | <symbol> | <latex-command> | <function-call> | <matchfix-expr>)
-     * (<subsup> | <postfix-operator>)*
      *
-     * <matchfix-expr> :=
-     *  <matchfix-op-open> <expression> <matchfix-op-close>
-     *
-     * <function-call> ::=
-     *  | <function><matchfix-op-group-open><expression>[',' <expression>]<matchfix-op-group-close>
+     * ```
+     *    <primary> :=
+     *       (<number> | <symbol> | <latex-command> | <function-call> | <matchfix-expr>)
+     *       (<subsup> | <postfix-operator>)*
+     * ```
      *
+     * ```
+     *    <matchfix-expr> :=
+     *        <matchfix-op-open> <expression> <matchfix-op-close>
+     *```
+     *
+     *```
+     *    <function-call> ::=
+     *      | <function><matchfix-op-group-open><expression>[',' <expression>]<matchfix-op-group-close>
+     *```
      * If not a primary, return `null` and do not advance the index.
      */
     matchPrimary(): Expression | null;

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

@@ -1,7 +1,7 @@
-/* 0.4.3 */
+/* 0.6.0 */
 import { NumberFormattingOptions } from './public';
-export declare function serializeNumber(expr: Expression | null, options: Required<NumberFormattingOptions>): string;
-export declare function serializeEngineeringNotationNumber(value: number, options: Required<NumberFormattingOptions>): string;
+export declare function serializeNumber(expr: Expression | null, options: NumberFormattingOptions): string;
+export declare function serializeEngineeringNotationNumber(value: number, options: NumberFormattingOptions): string;
 /**
  * `value` is a base-10 number, possibly a floating point number with an
  * exponent, i.e. "0.31415e1"

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

@@ -1,4 +1,4 @@
-/* 0.4.3 */
+/* 0.6.0 */
 export declare function getApplyFunctionStyle(_expr: Expression, _level: number): 'paren' | 'leftright' | 'big' | 'none';
 export declare function getGroupStyle(_expr: Expression, _level: number): 'paren' | 'leftright' | 'big' | 'none';
 export declare function getRootStyle(_expr: Expression | null, level: number): 'radical' | 'quotient' | 'solidus';

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

@@ -1,15 +1,13 @@
-/* 0.4.3 */
+/* 0.6.0 */
 import { NumberFormattingOptions, LatexString, SerializeLatexOptions } from './public';
 import { IndexedLatexDictionary, SymbolEntry } from './dictionary/definitions';
 import { WarningSignalHandler } from '../../common/signals';
-import { IComputeEngine } from '../public';
 export declare class Serializer {
     readonly onError: WarningSignalHandler;
-    options: Required<NumberFormattingOptions> & Required<SerializeLatexOptions>;
-    readonly computeEngine?: IComputeEngine;
+    options: NumberFormattingOptions & SerializeLatexOptions;
     readonly dictionary: IndexedLatexDictionary;
     level: number;
-    constructor(options: Required<NumberFormattingOptions> & Required<SerializeLatexOptions>, dictionary: IndexedLatexDictionary, computeEngine: undefined | IComputeEngine, onError: WarningSignalHandler);
+    constructor(options: NumberFormattingOptions & SerializeLatexOptions, dictionary: IndexedLatexDictionary, onError: WarningSignalHandler);
     updateOptions(opt: Partial<NumberFormattingOptions> & Partial<SerializeLatexOptions>): void;
     /**
      * Serialize the expression, and if the expression is an operator

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

@@ -1,4 +1,4 @@
-/* 0.4.3 */
+/* 0.6.0 */
  * ## Reference
  * TeX source code:
  * {@link  http://tug.org/texlive/devsrc/Build/source/texk/web2c/tex.web | Tex.web}

package/dist/types/compute-engine/numerics/numeric-complex.d.ts

@@ -1,3 +1,3 @@
-/* 0.4.3 */
+/* 0.6.0 */
 export declare function gamma(c: Complex): Complex;
 export declare function lngamma(c: Complex): Complex;

package/dist/types/compute-engine/numerics/numeric-decimal.d.ts

@@ -1,4 +1,4 @@
-/* 0.4.3 */
+/* 0.6.0 */
 import { IComputeEngine } from '../public';
 export declare function gcd(a: Decimal, b: Decimal): Decimal;
 export declare function lcm(a: Decimal, b: Decimal): Decimal;

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

@@ -1,8 +1,8 @@
-/* 0.4.3 */
+/* 0.6.0 */
 export declare const MACHINE_PRECISION: number;
 export declare const MACHINE_TOLERANCE_BITS = 7;
 export declare const MACHINE_TOLERANCE: number;
-export declare const NUMERICAL_TOLERANCE: number;
+export declare const NUMERIC_TOLERANCE: number;
 export declare const SMALL_INTEGERS = 1000000;
 /**
  * Returns the smallest floating-point number greater than x.

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

@@ -1,2 +1,2 @@
-/* 0.4.3 */
+/* 0.6.0 */
 export declare function isPrime(n: number): boolean | undefined;