@cortex-js/compute-engine 0.29.1 → 0.30.0

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

@@ -1,6 +1,8 @@
-/* 0.29.1 */
-import { ParseLatexOptions, LatexToken, Terminator, Parser, SymbolTable, SymbolType } from './types';
+/* 0.30.0 */
+import { ParseLatexOptions, LatexToken, Terminator, Parser, SymbolTable } from './types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry, IndexedInfixEntry, IndexedPostfixEntry, IndexedPrefixEntry, IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry } from './dictionary/definitions';
+import { BoxedType } from '../../common/type/boxed-type';
+import { TypeString } from '../types';
 /**
  * ## THEORY OF OPERATIONS
  *
@@ -17,7 +19,7 @@ import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry, IndexedInfixE
  * a function to interpret the expression as a function application.
  *
  * The parser uses the current state of the compute engine, and any
- * identifier that may have been declared, to determine the correct
+ * symbol that may have been declared, to determine the correct
  * interpretation.
  *
  * Some constructs declare variables or functions while parsing. For example,
@@ -25,9 +27,9 @@ import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry, IndexedInfixE
  *
  * The parser keeps track of the parsing state with a stack of symbol tables.
  *
- * In addition, the handler `getIdentifierType()` is called when the parser
- * encounters an unknown identifier. This handler can be used to declare the
- * identifier, or to return `unknown` if the identifier is not known.
+ * In addition, the handler `getSymbolType()` is called when the parser
+ * encounters an unknown symbol. This handler can be used to declare the
+ * symbol, or to return `unknown` if the symbol is not known.
  *
  * Some functions affect the state of the parser:
  * - `Declare`, `Assign` modify the symbol table
@@ -42,7 +44,7 @@ export declare class _Parser implements Parser {
     symbolTable: SymbolTable;
     pushSymbolTable(): void;
     popSymbolTable(): void;
-    addSymbol(id: string, type: SymbolType): void;
+    addSymbol(id: string, type: BoxedType | TypeString): void;
     get index(): number;
     set index(val: number);
     private _tokens;
@@ -62,7 +64,7 @@ export declare class _Parser implements Parser {
     private _lastPeek;
     private _peekCounter;
     constructor(tokens: LatexToken[], dictionary: IndexedLatexDictionary, options: Readonly<ParseLatexOptions>);
-    getIdentifierType(id: MathJsonIdentifier): SymbolType;
+    getSymbolType(id: MathJsonSymbol): BoxedType;
     get peek(): LatexToken;
     nextToken(): LatexToken;
     get atEnd(): boolean;
@@ -140,8 +142,8 @@ export declare class _Parser implements Parser {
      * > (radix 16, preceded by "), an alphabetic constant (preceded by `), or
      * > an internal variable.
      */
-    matchLatexNumber(isInteger?: boolean): null | number;
-    matchChar(): string | null;
+    parseLatexNumber(isInteger?: boolean): null | number;
+    parseChar(): string | null;
     /**
      *
      * If the next token matches the open delimiter, set a boundary with
@@ -167,7 +169,7 @@ export declare class _Parser implements Parser {
      * and empty cells are also indicated with `Nothing`.
      */
     parseTabular(): null | Expression[][];
-    /** Match a string used as a LaTeX identifier, for example an environment
+    /** Match a string used as a LaTeX symbol, for example an environment
      * name.
      * Not suitable for general purpose text, e.g. argument of a `\text{}
      * command. See `matchChar()` instead.
@@ -224,7 +226,7 @@ export declare class _Parser implements Parser {
      */
     private parseGenericExpression;
     /**
-     * A function is an identifier followed by postfix operators
+     * A function is an symbol followed by postfix operators
      * (`\prime`...) and some arguments.
      */
     private parseFunction;

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.0 */
 import { NumberSerializationFormat } from './types';
 /**
  * @param expr - A number, can be represented as a string

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.0 */
 import { DelimiterScale } from './types';
 export declare function getApplyFunctionStyle(_expr: Expression, _level: number): DelimiterScale;
 export declare function getGroupStyle(_expr: Expression, _level: number): DelimiterScale;

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.0 */
 import { LatexString, SerializeLatexOptions, DelimiterScale } from './types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
 export declare class Serializer {
@@ -14,7 +14,7 @@ export declare class Serializer {
     wrap(expr: Expression | null | undefined, prec?: number): string;
     /**
      * If this is a "short" expression, wrap it.
-     * Do not wrap identifiers, positive numbers or functions.
+     * Do not wrap symbols, positive numbers or functions.
      *
      * This is called by the serializer for power and division (i.e. "(a+1)/b")
      *

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

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

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

@@ -1,11 +1,11 @@
-/* 0.29.1 */
-import type { Expression, MathJsonIdentifier } from '../../math-json/types';
+/* 0.30.0 */
+import type { Expression, MathJsonSymbol } from '../../math-json/types';
+import { BoxedType, TypeString } from '../types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
-export type SymbolType = 'symbol' | 'function' | 'unknown';
 export type SymbolTable = {
     parent: SymbolTable | null;
     ids: {
-        [id: MathJsonIdentifier]: SymbolType;
+        [id: MathJsonSymbol]: BoxedType;
     };
 };
 /**
@@ -30,13 +30,13 @@ export type LatexString = string;
  *
  * @category Latex Parsing and Serialization
  */
-export type Delimiter = ')' | '(' | ']' | '[' | '{' /** \lbrace */ | '}' /** \rbrace */ | '<' /** \langle  */ | '>' /** \rangle  */ | '|' | '||' | '\\lceil' | '\\rceil' | '\\lfloor' | '\\rfloor' | '\\llbracket' | '\\rrbracket';
+export type Delimiter = '.' | ')' | '(' | ']' | '[' | '{' /** \lbrace */ | '}' /** \rbrace */ | '<' /** \langle  */ | '>' /** \rangle  */ | '|' | '||' | '\\lceil' | '\\rceil' | '\\lfloor' | '\\rfloor' | '\\llbracket' | '\\rrbracket';
 /** @category Latex Parsing and Serialization */
 export type DelimiterScale = 'normal' | 'scaled' | 'big' | 'none';
 /**
  * @category Latex Parsing and Serialization
  */
-export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collections' | 'control-structures' | 'combinatorics' | 'complex' | 'core' | 'data-structures' | 'dimensions' | 'domains' | 'linear-algebra' | 'logic' | 'numeric' | 'other' | 'physics' | 'polynomials' | 'relop' | 'sets' | 'statistics' | 'styling' | 'symbols' | 'trigonometry' | 'units';
+export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collections' | 'control-structures' | 'combinatorics' | 'complex' | 'core' | 'data-structures' | 'dimensions' | 'domains' | 'linear-algebra' | 'logic' | 'number-theory' | 'numeric' | 'other' | 'physics' | 'polynomials' | 'relop' | 'sets' | 'statistics' | 'styling' | 'symbols' | 'trigonometry' | 'units';
 /**
  *
  * :::info[THEORY OF OPERATIONS]
@@ -119,25 +119,32 @@ export type Terminator = {
     condition?: (parser: Parser) => boolean;
 };
 /**
- * Custom parsing handler.
+ * **Custom parsing handler.**
  *
- * When invoked the parser points right after the LaTeX fragment that triggered
- * this parsing handler.
+ * When this handler is invoked the parser points right after the LaTeX
+ * fragment that triggered it.
  *
- * The parser should be moved, by calling `parser.nextToken()` for
- * every consumed token.
+ * Tokens can be consumed with `parser.nextToken()` and other parser methods
+ * such as `parser.parseGroup()`, `parser.parseOptionalGroup()`, etc...
  *
  * If it was in an infix or postfix context, `lhs` will represent the
  * left-hand side argument. In a prefix or matchfix context, `lhs` is `null`.
  *
- * In a superfix (^) or subfix (_) context (that is if the first token of the
- * trigger is `^` or `_`), lhs is `["Superscript", lhs, rhs]`
+ * In a superfix (`^`) or subfix (`_`) context (that is if the first token of
+ * the trigger is `^` or `_`), `lhs` is `["Superscript", lhs, rhs]`
  * and `["Subscript", lhs, rhs]`, respectively.
  *
- * The handler should return `null` if the expression could not be parsed
- * (didn't match the syntax that was expected). The matching expression
+ * The handler should return `null` if the tokens could not be parsed
+ * (didn't match the syntax that was expected), or the matching expression
  * otherwise.
  *
+ * If the tokens were parsed but should be ignored, the handler should
+ * return `Nothing`.
+ *
+ * @category Latex Parsing and Serialization
+ */
+export type ParseHandler = ExpressionParseHandler | SymbolParseHandler | FunctionParseHandler | EnvironmentParseHandler | PostfixParseHandler | InfixParseHandler | MatchfixParseHandler;
+/**
  * @category Latex Parsing and Serialization
  */
 export type ExpressionParseHandler = (parser: Parser, until?: Readonly<Terminator>) => Expression | null;
@@ -179,9 +186,9 @@ export type LatexArgumentType = '{expression}' /** A required math mode expressi
  * If the trigger matches, the `parse` handler is called, if available.
  *
  * The trigger can be specified either as a LaTeX string (`latexTrigger`) or
- * as an identifier (`identifierTrigger`). An identifier match several
- * LaTeEx expressions that are equivalent, for example `\operatorname{gcd}` or
- *  `\mathbin{gcd}`, match the `"gcd"` identifier
+ * as an symbol (`symbolTrigger`). A symbol match several
+ * LaTeX expressions that are equivalent, for example `\operatorname{gcd}` or
+ *  `\mathbin{gcd}`, match the `"gcd"` symbol
  *
  * `matchfix` operators use `openTrigger` and `closeTrigger` instead.
  *
@@ -189,7 +196,7 @@ export type LatexArgumentType = '{expression}' /** A required math mode expressi
  */
 export type Trigger = {
     latexTrigger?: LatexString | LatexToken[];
-    identifierTrigger?: MathJsonIdentifier;
+    symbolTrigger?: MathJsonSymbol;
 };
 /**
  * Maps a string of LaTeX tokens to a function or symbol and vice-versa.
@@ -197,7 +204,7 @@ export type Trigger = {
  */
 export type BaseEntry = {
     /**
-     * Map a MathJSON identifier to this entry.
+     * Map a MathJSON symbol to this entry.
      *
      * Each entry should have at least a `name` or a `parse` handler.
      *
@@ -212,7 +219,7 @@ export type BaseEntry = {
      * entry. Otherwise, if the trigger of the entry matches the current
      * token, the `parse` handler is invoked.
      */
-    name?: MathJsonIdentifier;
+    name?: MathJsonSymbol;
     /**
      * Transform an expression into a LaTeX string.
      * If no `serialize` handler is provided, the trigger is used.
@@ -308,7 +315,7 @@ export type PrefixEntry = BaseEntry & Trigger & {
 export type EnvironmentEntry = BaseEntry & {
     kind: 'environment';
     parse: EnvironmentParseHandler;
-    identifierTrigger: MathJsonIdentifier;
+    symbolTrigger: MathJsonSymbol;
 };
 /**
  * @category Latex Parsing and Serialization
@@ -320,7 +327,7 @@ export type SymbolEntry = BaseEntry & Trigger & {
     parse: Expression | SymbolParseHandler;
 };
 /**
- * A function is an identifier followed by:
+ * A function is a symbol followed by:
  * - some postfix operators such as `\prime`
  * - an optional list of arguments in an enclosure (parentheses)
  *
@@ -479,21 +486,13 @@ export type ParseLatexOptions = NumberFormat & {
      */
     parseNumbers: 'auto' | 'rational' | 'decimal' | 'never';
     /**
-     * This handler is invoked when the parser encounters an identifier
+     * This handler is invoked when the parser encounters a
      * that has not yet been declared.
      *
-     * The `identifier` argument is a [valid identifier](/math-json/#identifiers).
+     * The `symbol` argument is a [valid symbol](/math-json/#symbols).
      *
-     * The handler can return:
-     *
-     * - `"variable"`: the identifier is a variable
-     * - `"function"`: the identifier is a function name. If an apply
-     * function operator (typically, parentheses) follow, they will be parsed
-     * as arguments to the function.
-     *
-     * - `"unknown"`: the identifier is not recognized.
      */
-    getIdentifierType: (identifier: MathJsonIdentifier) => SymbolType;
+    getSymbolType: (symbol: MathJsonSymbol) => BoxedType;
     /** This handler is invoked when the parser encounters an unexpected token.
      *
      * The `lhs` argument is the left-hand side of the token, if any.
@@ -535,10 +534,10 @@ export type ParseLatexOptions = NumberFormat & {
  */
 export interface Parser {
     readonly options: Required<ParseLatexOptions>;
-    getIdentifierType(id: MathJsonIdentifier): SymbolType;
+    getSymbolType(id: MathJsonSymbol): BoxedType;
     pushSymbolTable(): void;
     popSymbolTable(): void;
-    addSymbol(id: MathJsonIdentifier, type: SymbolType): void;
+    addSymbol(id: MathJsonSymbol, type: BoxedType | TypeString): void;
     /** The index of the current token */
     index: number;
     /** True if the last token has been reached.
@@ -580,7 +579,7 @@ export interface Parser {
      * This includes plain characters (e.g. 'a', '+'...), characters
      * defined in hex (^^ and ^^^^), the `\char` and `\unicode` command.
      */
-    matchChar(): string | null;
+    parseChar(): string | null;
     /**
      * Parse an expression in a LaTeX group enclosed in curly brackets `{}`.
      * These are often used as arguments to LaTeX commands, for example
@@ -631,9 +630,9 @@ export interface Parser {
     parseStringGroup(optional?: boolean): string | null;
     /**
      * A symbol can be:
-     * - a single-letter identifier: `x`
+     * - a single-letter symbol: `x`
      * - a single LaTeX command: `\pi`
-     * - a multi-letter identifier: `\operatorname{speed}`
+     * - a multi-letter symbol: `\operatorname{speed}`
      */
     parseSymbol(until?: Partial<Terminator>): Expression | null;
     /**
@@ -727,6 +726,19 @@ export type SerializeLatexOptions = NumberSerializationFormat & {
      *
      */
     prettify: boolean;
+    /**
+     * Controls the materialization of the lazy collections.
+     *
+     * - If `true`, lazy collections are materialized, i.e. it is rendered as a
+     *   LaTeX expression with all its elements.
+     * - If `false`, the expression is not materialized, i.e. it is
+     *   rendered as a LaTeX command with its arguments.
+     * - If a number is provided, it is the maximum number of elements
+     *   that will be materialized.
+     * - If a pair of numbers is provided, it is the number of elements
+     *   of the head and the tail that will be materialized, respectively.
+     */
+    materialization: boolean | number | [number, number];
     /**
      * LaTeX string used to render an invisible multiply, e.g. in '2x'.
      *

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

@@ -0,0 +1,5 @@
+/* 0.30.0 */
+export declare function asLatexString(s: unknown): string | null;
+export declare function isRelationalOperator(name: string | undefined): boolean;
+export declare function isInequalityOperator(operator: string | undefined): boolean;
+export declare function isEquationOperator(operator: string | undefined): boolean;

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.0 */
 export type CanonicalArithmeticOperators = 'Add' | 'Negate' | 'Multiply' | 'Divide' | 'Power' | 'Sqrt' | 'Root' | 'Ln';
-export declare const ARITHMETIC_LIBRARY: IdentifierDefinitions[];
+export declare const ARITHMETIC_LIBRARY: SymbolDefinitions[];
 export declare function isPrime(expr: BoxedExpression): boolean | undefined;

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
-export declare const CALCULUS_LIBRARY: IdentifierDefinitions[];
+/* 0.30.0 */
+export declare const CALCULUS_LIBRARY: SymbolDefinitions[];

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

@@ -1,6 +1,6 @@
-/* 0.29.1 */
+/* 0.30.0 */
 export declare const DEFAULT_LINSPACE_COUNT = 50;
-export declare const COLLECTIONS_LIBRARY: IdentifierDefinitions;
+export declare const COLLECTIONS_LIBRARY: SymbolDefinitions;
 /**
  * Normalize the arguments of range:
  * - [from, to] -> [from, to, 1] if to > from, or [from, to, -1] if to < from
@@ -24,4 +24,4 @@ export declare function rangeLast(r: [lower: number, upper: number, step: number
  */
 export declare function reduceCollection<T>(collection: BoxedExpression, fn: (acc: T, next: BoxedExpression) => T | null, initial: T): Generator<T | undefined>;
 export declare function fromRange(start: number, end: number): number[];
-export declare function canonicalDictionary(engine: ComputeEngine, dict: BoxedExpression): BoxedExpression;
+export declare function sortedIndices(expr: BoxedExpression, fn?: BoxedExpression | undefined): number[] | undefined;

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

@@ -0,0 +1,2 @@
+/* 0.30.0 */
+export declare const COMBINATORICS_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
-export declare const COMPLEX_LIBRARY: IdentifierDefinitions[];
+/* 0.30.0 */
+export declare const COMPLEX_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/control-structures.d.ts

@@ -1,2 +1,2 @@
-/* 0.29.1 */
-export declare const CONTROL_STRUCTURES_LIBRARY: IdentifierDefinitions[];
+/* 0.30.0 */
+export declare const CONTROL_STRUCTURES_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
-export declare const CORE_LIBRARY: IdentifierDefinitions[];
+/* 0.30.0 */
+export declare const CORE_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/invisible-operator.d.ts

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.0 */
 export declare function canonicalInvisibleOperator(ops: ReadonlyArray<BoxedExpression>, { engine: ce }: {
     engine: ComputeEngine;
 }): BoxedExpression | null;

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

@@ -1,8 +1,8 @@
-/* 0.29.1 */
-import type { IdentifierDefinitions, ComputeEngine } from '../global-types';
-export declare function getStandardLibrary(categories: LibraryCategory[] | LibraryCategory | 'all'): readonly IdentifierDefinitions[];
+/* 0.30.0 */
+import type { SymbolDefinitions, ComputeEngine } from '../global-types';
+export declare function getStandardLibrary(categories: LibraryCategory[] | LibraryCategory | 'all'): readonly SymbolDefinitions[];
 export declare const LIBRARIES: {
-    [category in LibraryCategory]?: IdentifierDefinitions | IdentifierDefinitions[];
+    [category in LibraryCategory]?: SymbolDefinitions | SymbolDefinitions[];
 };
 /**
  * Set the symbol table of the current context (`engine.context`) to `table`
@@ -14,4 +14,4 @@ export declare const LIBRARIES: {
  * or function name that has not yet been added to the symbol table.
  *
  */
-export declare function setIdentifierDefinitions(engine: ComputeEngine, table: IdentifierDefinitions): void;
+export declare function setSymbolDefinitions(engine: ComputeEngine, table: SymbolDefinitions): void;

package/dist/types/compute-engine/library/linear-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.29.1 */
-export declare const LINEAR_ALGEBRA_LIBRARY: IdentifierDefinitions[];
+/* 0.30.0 */
+export declare const LINEAR_ALGEBRA_LIBRARY: SymbolDefinitions[];

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

@@ -1,5 +1,5 @@
-/* 0.29.1 */
-export declare const LOGIC_LIBRARY: IdentifierDefinitions;
+/* 0.30.0 */
+export declare const LOGIC_LIBRARY: SymbolDefinitions;
 export declare function simplifyLogicFunction(x: BoxedExpression): {
     value: BoxedExpression;
     because: string;

package/dist/types/compute-engine/library/number-theory.d.ts

@@ -0,0 +1,2 @@
+/* 0.30.0 */
+export declare const NUMBER_THEORY_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
-export declare const POLYNOMIALS_LIBRARY: IdentifierDefinitions[];
+/* 0.30.0 */
+export declare const POLYNOMIALS_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/random-expression.d.ts

@@ -1,2 +1,2 @@
-/* 0.29.1 */
+/* 0.30.0 */
 export declare function randomExpression(level?: number): Expression;

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
-export declare const RELOP_LIBRARY: IdentifierDefinitions;
+/* 0.30.0 */
+export declare const RELOP_LIBRARY: SymbolDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
-export declare const SETS_LIBRARY: IdentifierDefinitions;
+/* 0.30.0 */
+export declare const SETS_LIBRARY: SymbolDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
-export declare const STATISTICS_LIBRARY: IdentifierDefinitions[];
+/* 0.30.0 */
+export declare const STATISTICS_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
-export declare const TRIGONOMETRY_LIBRARY: IdentifierDefinitions[];
+/* 0.30.0 */
+export declare const TRIGONOMETRY_LIBRARY: SymbolDefinitions[];

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.0 */
 export type IndexingSet = {
     index: string | undefined;
     lower: number;
@@ -39,8 +39,30 @@ export declare function indexingSetCartesianProduct(indexingSets: IndexingSet[])
  * @returns The cartesian product as a 2D array.
  */
 export declare function cartesianProduct(array1: number[], array2: number[]): number[][];
+/** Given a sequence of arguments, return an array of Limits:
+ *
+ * - ["Range", 1, 10] -> ["Limits", "Unknown", 1, 10]
+ * - 1, 10 -> ["Limits", "Nothing", 1, 10]
+ * - [Tuple, "x", 1, 10] -> ["Limits", "x", 1, 10]
+ *
+ */
+export declare function canonicalLimitsSequence(ops: ReadonlyArray<BoxedExpression>, options: {
+    engine: ComputeEngine;
+}): BoxedExpression[];
+export declare function canonicalLimits(ops: ReadonlyArray<BoxedExpression>, { engine: ce }: {
+    engine: ComputeEngine;
+}): BoxedExpression | null;
+/** Return a limit/indexing set in canonical form as a `Limits` expression
+ * with:
+ * - `index` (a symbol), `Nothing` if none is present
+ * - `lower` (a number), `Nothing` if none is present
+ * - `upper` (a number), `Nothing` if none is present
+ *
+ * Assume we are in the context of a big operator
+ * (i.e. `pushScope()` has been called)
+ */
 export declare function canonicalIndexingSet(expr: BoxedExpression): BoxedExpression | undefined;
-export declare function canonicalBigop(operator: string, body: BoxedExpression, indexingSets: BoxedExpression[]): BoxedExpression | null;
+export declare function canonicalBigop(bigOp: string, body: BoxedExpression, indexingSets: BoxedExpression[], scope: Scope | undefined): BoxedExpression | null;
 /**
  * Process an expression of the form
  * - ['Operator', body, ['Tuple', index1, lower, upper]]

package/dist/types/compute-engine/numeric-value/big-numeric-value.d.ts

@@ -1,16 +1,15 @@
-/* 0.29.1 */
+/* 0.30.0 */
 import { BigNumFactory, NumericValue, NumericValueData } from './types';
 import { ExactNumericValue } from './exact-numeric-value';
 import { Expression } from '../../math-json/types';
 import { SmallInteger } from '../numerics/types';
-import { NumericType } from '../../common/type/types';
+import { NumericPrimitiveType } from '../../common/type/types';
 export declare class BigNumericValue extends NumericValue {
     __brand: 'BigNumericValue';
     decimal: Decimal;
-    im: number;
     bignum: BigNumFactory;
     constructor(value: number | Decimal | NumericValueData, bignum: BigNumFactory);
-    get type(): NumericType;
+    get type(): NumericPrimitiveType;
     get isExact(): boolean;
     get asExact(): ExactNumericValue | undefined;
     toJSON(): Expression;

package/dist/types/compute-engine/numeric-value/exact-numeric-value.d.ts

@@ -1,8 +1,8 @@
-/* 0.29.1 */
+/* 0.30.0 */
 import { Rational, SmallInteger } from '../numerics/types';
 import { BigNumFactory, ExactNumericValueData, NumericValue, NumericValueFactory } from './types';
 import { Expression } from '../../math-json/types';
-import { NumericType } from '../../common/type/types';
+import { NumericPrimitiveType } from '../../common/type/types';
 /**
  * An ExactNumericValue is the sum of a Gaussian imaginary and the product of
  * a rational number and a square root:
@@ -25,7 +25,7 @@ export declare class ExactNumericValue extends NumericValue {
      * - radical is an integer
      */
     constructor(value: number | bigint | ExactNumericValueData, factory: NumericValueFactory, bignum: BigNumFactory);
-    get type(): NumericType;
+    get type(): NumericPrimitiveType;
     get isExact(): boolean;
     get asExact(): NumericValue | undefined;
     toJSON(): Expression;

package/dist/types/compute-engine/numeric-value/machine-numeric-value.d.ts

@@ -1,16 +1,15 @@
-/* 0.29.1 */
+/* 0.30.0 */
 import { BigNumFactory, NumericValue, NumericValueData } from './types';
 import type { Expression } from '../../math-json/types';
 import type { SmallInteger } from '../numerics/types';
-import { NumericType } from '../../common/type/types';
+import { NumericPrimitiveType } from '../../common/type/types';
 export declare class MachineNumericValue extends NumericValue {
     __brand: 'MachineNumericValue';
     decimal: number;
-    im: number;
     bignum: BigNumFactory;
     constructor(value: number | Decimal | NumericValueData, bignum: BigNumFactory);
     private _makeExact;
-    get type(): NumericType;
+    get type(): NumericPrimitiveType;
     get isExact(): boolean;
     get asExact(): NumericValue | undefined;
     toJSON(): Expression;

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.0 */
  *
  * ## THEORY OF OPERATIONS
  *
@@ -25,7 +25,7 @@
  */
 import { Decimal } from 'decimal.js';
 import type { Rational, SmallInteger } from '../numerics/types';
-import { NumericType } from '../../common/type/types';
+import { NumericPrimitiveType } from '../../common/type/types';
 export type BigNumFactory = (value: Decimal.Value) => Decimal;
 /** The value is equal to `(decimal * rational * sqrt(radical)) + im * i`
  * @category Numerics */
@@ -42,7 +42,7 @@ export type NumericValueData = {
 export type NumericValueFactory = (data: number | Decimal | NumericValueData) => NumericValue;
 /** @category Numerics */
 export declare abstract class NumericValue {
-    abstract get type(): NumericType;
+    abstract get type(): NumericPrimitiveType;
     /** True if numeric value is the product of a rational and the square root of an integer.
      *
      * This includes: 3/4√5, -2, √2, etc...
@@ -65,7 +65,7 @@ export declare abstract class NumericValue {
      *
      * Can be negative, zero or positive.
      */
-    readonly im: number;
+    im: number;
     get bignumIm(): Decimal | undefined;
     abstract get numerator(): NumericValue;
     abstract get denominator(): NumericValue;
@@ -79,6 +79,7 @@ export declare abstract class NumericValue {
     abstract get isNegativeOne(): boolean;
     /** The sign of complex numbers is undefined */
     abstract sgn(): -1 | 0 | 1 | undefined;
+    /** Return a non-exact representation of the numeric value */
     abstract N(): NumericValue;
     abstract neg(): NumericValue;
     abstract inv(): NumericValue;
@@ -104,7 +105,8 @@ export declare abstract class NumericValue {
     abstract lte(other: number | NumericValue): boolean | undefined;
     abstract gt(other: number | NumericValue): boolean | undefined;
     abstract gte(other: number | NumericValue): boolean | undefined;
-    /** Object.valueOf(): returns a primitive value */
+    /** Object.valueOf(): returns a primitive value, preferably a JavaScript
+     *  number over a string, even if at the expense of precision */
     valueOf(): number | string;
     /** Object.toPrimitive() */
     [Symbol.toPrimitive](hint: 'number' | 'string' | 'default'): number | string | null;

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

@@ -1,2 +1,2 @@
-/* 0.29.1 */
+/* 0.30.0 */
 export declare function bigint(a: Decimal | number | bigint | string): bigint | null;

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.0 */
 export declare function bigintValue(expr: Expression | null | undefined): bigint | null;
 /** Output a shorthand if possible */
 export declare function numberToExpression(num: number | bigint, fractionalDigits?: string | number): Expression;

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

@@ -1,4 +1,4 @@
-/* 0.29.1 */
+/* 0.30.0 */
 /** An interval is a continuous set of real numbers */
 export type Interval = {
     start: number;