@cortex-js/compute-engine 0.25.1 → 0.26.2

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

@@ -1,4 +1,4 @@
-/* 0.25.1 */
+/* 0.26.2 */
 import { Delimiter, EnvironmentParseHandler, ExpressionParseHandler, InfixParseHandler, LatexDictionary, LatexDictionaryEntry, LatexString, LatexToken, LibraryCategory, MatchfixParseHandler, PostfixParseHandler, Precedence, SerializeHandler } from '../public';
 export type CommonEntry = {
     /** Note: a name is required if a serialize handler is provided */

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

@@ -1,4 +1,4 @@
-/* 0.25.1 */
+/* 0.26.2 */
 import { Parser } from './public';
 /** For error handling, if we have a identifier prefix, assume
  * the identifier is invalid (it would have been captured by
@@ -18,4 +18,4 @@ export declare function parseInvalidIdentifier(parser: Parser): Expression | nul
  *    - `\mathrm{\alpha_{12}}` or
  *    - `\mathit{speed\unicode{"2012}of\unicode{"2012}sound}`
  */
-export declare function parseIdentifier(parser: Parser): string | null;
+export declare function parseIdentifier(parser: Parser): MathJsonIdentifier | null;

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

@@ -1,4 +1,4 @@
-/* 0.25.1 */
+/* 0.26.2 */
 import { ParseLatexOptions, LatexToken, Terminator, Parser, SymbolTable, SymbolType } from './public';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry, IndexedInfixEntry, IndexedPostfixEntry, IndexedPrefixEntry, IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry } from './dictionary/definitions';
 /**
@@ -62,7 +62,7 @@ export declare class _Parser implements Parser {
     private _lastPeek;
     private _peekCounter;
     constructor(tokens: LatexToken[], dictionary: IndexedLatexDictionary, options: Readonly<ParseLatexOptions>);
-    getIdentifierType(id: string): SymbolType;
+    getIdentifierType(id: MathJsonIdentifier): SymbolType;
     get peek(): LatexToken;
     nextToken(): LatexToken;
     get atEnd(): boolean;
@@ -129,19 +129,31 @@ export declare class _Parser implements Parser {
     match(token: LatexToken): boolean;
     matchAll(tokens: LatexToken[]): boolean;
     matchAny(tokens: LatexToken[]): LatexToken;
+    /**
+     * 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;
     matchChar(): string | null;
     /**
      *
      * If the next token matches the open delimiter, set a boundary with
      * the close token and return true.
      *
-     * Note this method handles "shorthand" delimiters, i.e. '(' will match both
+     * This method handles prefixes like `\left` and `\bigl`.
+     *
+     * It also handles "shorthand" delimiters, i.e. '(' will match both
      * `(` and `\lparen`. If a shorthand is used for the open delimiter, the
      * corresponding shorthand will be used for the close delimiter.
      * See DELIMITER_SHORTHAND.
      *
-     * It also handles prefixes like `\left` and `\bigl`.
-     *
      */
     private matchDelimiter;
     parseGroup(): Expression | null;
@@ -185,18 +197,6 @@ export declare class _Parser implements Parser {
      * repeating decimals, etc...
      */
     parseNumber(): Expression | null;
-    /**
-     * 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;
     private parsePrefixOperator;
     private parseInfixOperator;
     /**
@@ -209,23 +209,13 @@ export declare class _Parser implements Parser {
      *  (i.e. we interpret `\cos 2x + 1` as `\cos(2x) + 1`)
      *
      */
-    parseArguments(kind?: 'enclosure' | 'implicit', until?: Readonly<Terminator>): Expression[] | null;
-    /** If matches the normalized open delimiter, return 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()`
-     *
-     * @internal
-     */
+    parseArguments(kind?: 'enclosure' | 'implicit', until?: Readonly<Terminator>): ReadonlyArray<Expression> | null;
     /**
      * An enclosure is an opening matchfix operator, an optional expression,
      * optionally followed multiple times by a separator and another expression,
      * and finally a closing matching operator.
      */
-    private parseEnclosure;
+    parseEnclosure(): Expression | null;
     /**
      * A generic expression is used for dictionary entries that do
      * some complex (non-standard) parsing. This includes trig functions (to
@@ -299,8 +289,13 @@ export declare class _Parser implements Parser {
      */
     decorate(expr: Expression | null, start: number): Expression | null;
     error(code: string | [string, ...Expression[]], fromToken: number): Expression;
-    private isFunctionHead;
-    /** Return all defs of the specified kind */
+    private isFunctionOperator;
+    /** Return all defs of the specified kind.
+     * The defs at the end of the dictionary have priority, since they may
+     * override previous definitions. (For example, there is a core definition
+     * for matchfix[], which maps to a List, and a logic definition which
+     * matches to Boole. The logic definition should take precedence.)
+     */
     getDefs(kind: string): Iterable<IndexedLatexDictionaryEntry>;
 }
 export declare function parse(latex: string, dictionary: IndexedLatexDictionary, options: Readonly<ParseLatexOptions>): Expression | null;

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

@@ -1,9 +1,10 @@
-/* 0.25.1 */
+/* 0.26.2 */
+import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
 export type SymbolType = 'symbol' | 'function' | 'unknown';
 export type SymbolTable = {
     parent: SymbolTable | null;
     ids: {
-        [id: string]: SymbolType;
+        [id: MathJsonIdentifier]: SymbolType;
     };
 };
 /**
@@ -28,7 +29,7 @@ export type LatexString = string;
  *
  * @category Latex Parsing and Serialization
  */
-export type Delimiter = ')' | '(' | ']' | '[' | '{' /** \lbrace */ | '}' /** \rbrace */ | '<' /** \langle  */ | '>' /** \rangle  */ | '|' | '||' | '\\lceil' | '\\rceil' | '\\lfloor' | '\\rfloor';
+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';
 /**
@@ -185,7 +186,7 @@ export type LatexArgumentType = '{expression}' /** A required math mode expressi
  */
 export type Trigger = {
     latexTrigger?: LatexString | LatexToken[];
-    identifierTrigger?: string;
+    identifierTrigger?: MathJsonIdentifier;
 };
 /**
  * Maps a string of LaTeX tokens to a function or symbol and vice-versa.
@@ -208,7 +209,7 @@ export type BaseEntry = {
      * entry. Otherwise, if the trigger of the entry matches the current
      * token, the `parse` handler is invoked.
      */
-    name?: string;
+    name?: MathJsonIdentifier;
     /**
      * Transform an expression into a LaTeX string.
      * If no `serialize` handler is provided, the trigger is used.
@@ -304,7 +305,7 @@ export type PrefixEntry = BaseEntry & Trigger & {
 export type EnvironmentEntry = BaseEntry & {
     kind: 'environment';
     parse: EnvironmentParseHandler;
-    identifierTrigger: string;
+    identifierTrigger: MathJsonIdentifier;
 };
 /**
  * @category Latex Parsing and Serialization
@@ -485,7 +486,7 @@ export type ParseLatexOptions = NumberFormat & {
      *
      * - `"unknown"`: the identifier is not recognized.
      */
-    getIdentifierType: (identifier: string) => SymbolType;
+    getIdentifierType: (identifier: MathJsonIdentifier) => SymbolType;
     /** This handler is invoked when the parser encounters an unexpected token.
      *
      * The `lhs` argument is the left-hand side of the token, if any.
@@ -527,10 +528,10 @@ export type ParseLatexOptions = NumberFormat & {
  */
 export interface Parser {
     readonly options: Required<ParseLatexOptions>;
-    getIdentifierType(id: string): SymbolType;
+    getIdentifierType(id: MathJsonIdentifier): SymbolType;
     pushSymbolTable(): void;
     popSymbolTable(): void;
-    addSymbol(id: string, type: SymbolType): void;
+    addSymbol(id: MathJsonIdentifier, type: SymbolType): void;
     /** The index of the current token */
     index: number;
     /** True if the last token has been reached.
@@ -579,7 +580,7 @@ export interface Parser {
      * `\frac{1}{2}`.
      *
      * Return `null` if none was found
-     * Return `['Sequence']` if an empty group `{}` was found
+     * Return `Nothing` if an empty group `{}` was found
      */
     parseGroup(): Expression | null;
     /**
@@ -603,6 +604,8 @@ export interface Parser {
      * Return `null` if none was found.
      */
     parseOptionalGroup(): Expression | null;
+    /** Parse an enclosure (open paren/close paren, etc..) and return the expression inside the enclosure */
+    parseEnclosure(): Expression | null;
     /**
      * Some LaTeX commands have arguments that are not interpreted as
      * expressions, but as strings. For example, `\begin{array}{ccc}` (both
@@ -645,7 +648,7 @@ export interface Parser {
      * Return an array of expressions, one for each argument, or `null` if no
      * argument was found.
      */
-    parseArguments(kind?: 'implicit' | 'enclosure', until?: Terminator): Expression[] | null;
+    parseArguments(kind?: 'implicit' | 'enclosure', until?: Terminator): ReadonlyArray<Expression> | null;
     /**
      * Parse a postfix operator, such as `'` or `!`.
      *
@@ -728,7 +731,7 @@ export type SerializeLatexOptions = NumberSerializationFormat & {
      */
     invisibleMultiply: LatexString;
     /**
-     * LaTeX string used to render mixed numbers e.g. in '1 3/4'.
+     * LaTeX string used to render [mixed numbers](https://en.wikipedia.org/wiki/Fraction#Mixed_numbers) e.g. '1 3/4'.
      *
      * Leave it empty to join the main number and the fraction, i.e. render it
      * as `1\frac{3}{4}`.
@@ -742,6 +745,8 @@ export type SerializeLatexOptions = NumberSerializationFormat & {
     /**
      * LaTeX string used to render an explicit multiply operator.
      *
+     * For example, `\times`, `\cdot`, etc...
+     *
      * Default: `\times`
      */
     multiply: LatexString;
@@ -768,10 +773,11 @@ export type SerializeLatexOptions = NumberSerializationFormat & {
  */
 export interface Serializer {
     readonly options: Required<SerializeLatexOptions>;
+    readonly dictionary: IndexedLatexDictionary;
     /** "depth" of the expression:
      * - 0 for the root
-     * - 1 for the arguments of the root
-     * - 2 for the arguments of the arguments of the root
+     * - 1 for a subexpression of the root
+     * - 2 for subexpressions of the subexpressions of the root
      * - etc...
      *
      * This allows the serialized LaTeX to vary depending on the depth of the
@@ -781,8 +787,8 @@ export interface Serializer {
      */
     level: number;
     /** Output a LaTeX string representing the expression */
-    serialize: (expr: Expression | null) => string;
-    serializeFunction(expr: Expression): LatexString;
+    serialize: (expr: Expression | null | undefined) => string;
+    serializeFunction(expr: Expression, def?: IndexedLatexDictionaryEntry): LatexString;
     serializeSymbol(expr: Expression): LatexString;
     /** Output `s` surrounded by delimiters.
      *
@@ -797,11 +803,11 @@ export interface Serializer {
     /** Add a group fence around the expression if it is
      * an operator of precedence less than or equal to `prec`.
      */
-    wrap: (expr: Expression | null, prec?: number) => LatexString;
+    wrap: (expr: Expression | null | undefined, prec?: number) => LatexString;
     /** Add a group fence around the expression if it is
      * short (not a function)
      */
-    wrapShort(expr: Expression | null): LatexString;
+    wrapShort(expr: Expression | null | undefined): LatexString;
     /** Styles */
     applyFunctionStyle: (expr: Expression, level: number) => DelimiterScale;
     groupStyle: (expr: Expression, level: number) => DelimiterScale;

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

@@ -1,8 +1,8 @@
-/* 0.25.1 */
+/* 0.26.2 */
 import { NumberSerializationFormat } from './public';
 /**
  * @param expr - A number, can be represented as a string
- *  particularly useful for arbitrary precision numbers) or a number (-12.45)
+ *  (particularly useful for arbitrary precision numbers) or a number (-12.45)
  * @return A textual representation of the number, formatted according to the
  * `options`
  */

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

@@ -1,4 +1,4 @@
-/* 0.25.1 */
+/* 0.26.2 */
 import { DelimiterScale } from './public';
 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,6 +1,6 @@
-/* 0.25.1 */
+/* 0.26.2 */
 import { LatexString, SerializeLatexOptions, DelimiterScale } from './public';
-import { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
+import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
 export declare class Serializer {
     options: SerializeLatexOptions;
     readonly dictionary: IndexedLatexDictionary;
@@ -11,7 +11,7 @@ export declare class Serializer {
      * of precedence less than or equal to prec, wrap it in some parens.
      * @todo: don't wrap Abs, Floor, Ceil, Delimiter
      */
-    wrap(expr: Expression | null, prec?: number): string;
+    wrap(expr: Expression | null | undefined, prec?: number): string;
     /**
      * If this is a "short" expression, wrap it.
      * Do not wrap identifiers, positive numbers or functions.
@@ -19,15 +19,12 @@ export declare class Serializer {
      * This is called by the serializer for power and division (i.e. "(a+1)/b")
      *
      */
-    wrapShort(expr: Expression | null): string;
+    wrapShort(expr: Expression | null | undefined): string;
     wrapString(s: string, style: DelimiterScale, fence?: string): string;
     wrapArguments(expr: Expression): string;
     serializeSymbol(expr: Expression, def?: IndexedLatexDictionaryEntry): LatexString;
     serializeFunction(expr: Expression, def?: IndexedLatexDictionaryEntry): LatexString;
-    serializeDictionary(dict: {
-        [key: string]: Expression;
-    }): string;
-    serialize(expr: Expression | null): LatexString;
+    serialize(expr: Expression | null | undefined): LatexString;
     applyFunctionStyle(expr: Expression, level: number): DelimiterScale;
     groupStyle(expr: Expression, level: number): DelimiterScale;
     rootStyle(expr: Expression, level: number): 'radical' | 'quotient' | 'solidus';

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

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

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

@@ -1,3 +1,5 @@
-/* 0.25.1 */
-export type CanonicalArithmeticFunctions = 'Add' | 'Negate' | 'Sqrt' | 'Multiply' | 'Divide' | 'Power' | 'Ln';
+/* 0.26.2 */
+import { BoxedExpression } from '../boxed-expression/public';
+export type CanonicalArithmeticOperators = 'Add' | 'Negate' | 'Multiply' | 'Divide' | 'Power' | 'Sqrt' | 'Root' | 'Ln';
 export declare const ARITHMETIC_LIBRARY: IdentifierDefinitions[];
+export declare function isPrime(expr: BoxedExpression): boolean | undefined;

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

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const CALCULUS_LIBRARY: IdentifierDefinitions[];

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

@@ -1,3 +1,26 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const DEFAULT_LINSPACE_COUNT = 50;
 export declare const COLLECTIONS_LIBRARY: IdentifierDefinitions;
+/**
+ * Normalize the arguments of range:
+ * - [from, to] -> [from, to, 1] if to > from, or [from, to, -1] if to < from
+ * - [x] -> [1, x]
+ * - arguments rounded to integers
+ *
+ */
+export declare function range(expr: BoxedExpression): [lower: number, upper: number, step: number];
+/** Return the last value in the range
+ * - could be less that lower if step is negative
+ * - could be less than upper if step is positive, for
+ * example `rangeLast([1, 6, 2])` = 5
+ */
+export declare function rangeLast(r: [lower: number, upper: number, step: number]): number;
+/**
+ * This function is used to reduce a collection of expressions to a single value. It
+ * iterates over the collection, applying the given function to each element and the
+ * accumulator. If the function returns `null`, the iteration is stopped and `undefined`
+ * is returned. Otherwise, the result of the function is used as the new accumulator.
+ * If the iteration completes, the final accumulator is returned.
+ */
+export declare function reduceCollection<T>(collection: BoxedExpression, fn: (acc: T, next: BoxedExpression) => T | null, initial: T): T | undefined;
+export declare function fromRange(start: number, end: number): number[];

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

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const COMPLEX_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const CONTROL_STRUCTURES_LIBRARY: IdentifierDefinitions[];

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

@@ -1,4 +1,2 @@
-/* 0.25.1 */
-import { BoxedExpression } from '../boxed-expression/public';
+/* 0.26.2 */
 export declare const CORE_LIBRARY: IdentifierDefinitions[];
-export declare function canonicalInvisibleOperator(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression | null;

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

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

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

@@ -1,5 +1,5 @@
-/* 0.25.1 */
-import { FunctionDefinition, IComputeEngine, IdentifierDefinitions, SymbolDefinition } from '../public';
+/* 0.26.2 */
+import { IComputeEngine, IdentifierDefinitions } from '../public';
 export declare function getStandardLibrary(categories: LibraryCategory[] | LibraryCategory | 'all'): readonly IdentifierDefinitions[];
 export declare const LIBRARIES: {
     [category in LibraryCategory]?: IdentifierDefinitions | IdentifierDefinitions[];
@@ -15,5 +15,3 @@ export declare const LIBRARIES: {
  *
  */
 export declare function setIdentifierDefinitions(engine: IComputeEngine, table: IdentifierDefinitions): void;
-export declare function isSymbolDefinition(def: any): def is SymbolDefinition;
-export declare function isFunctionDefinition(def: any): def is FunctionDefinition;

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

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const LINEAR_ALGEBRA_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,6 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const LOGIC_LIBRARY: IdentifierDefinitions;
+export declare function simplifyLogicFunction(x: BoxedExpression): {
+    value: BoxedExpression;
+    because: string;
+} | undefined;

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

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const POLYNOMIALS_LIBRARY: IdentifierDefinitions[];

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

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

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

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const RELOP_LIBRARY: IdentifierDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const SETS_LIBRARY: IdentifierDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const STATISTICS_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
 export declare const TRIGONOMETRY_LIBRARY: IdentifierDefinitions[];

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

@@ -1,51 +1,57 @@
-/* 0.25.1 */
+/* 0.26.2 */
+export type IndexingSet = {
+    index: string | undefined;
+    lower: number;
+    upper: number;
+    isFinite: boolean;
+};
 /**
- * Assume the caller has setup a scope. The index
- * variable will be declared in that scope.
- *
- * @param indexingSet
-
  * IndexingSet is an expression describing an index variable
  * and a range of values for that variable.
  *
- * The MultiIndexingSet function takes an expression of the form
- * \sum_{i=1,j=1}^{10,10} x and returns an array of expressions
- * ["Sum","x",["Triple","i",1,10],["Triple","j",1,10]
- */
-export declare function MultiIndexingSet(indexingSet: BoxedExpression | undefined): ReadonlyArray<BoxedExpression> | undefined;
-/**
- * Assume the caller has setup a scope. The index
- * variable will be declared in that scope.
- *
- * @param indexingSet
-
- * IndexingSet is an expression describing an index variable
- * and a range of values for that variable.
- *
- * The SingleIndexingSet function takes an expression of the form
- * \sum_{i=1}^{10} x and returns an array of expressions
- * ["Sum","x",["Triple","i",1,10]
- */
-export declare function SingleIndexingSet(indexingSet: BoxedExpression | undefined): BoxedExpression | undefined;
-/**
- * IndexingSet is an expression describing an index variable
- * and a range of values for that variable.
+ * Note that when this function is called the indexing set is assumed to be canonical: 'Hold' has been handled, the indexing set is a tuple, and the bounds are canonical.
  *
  * This can take several valid forms:
  * - a symbol, e.g. `n`, the upper and lower bounds are assumed ot be infinity
- * - a tuple, e.g. `["Pair", "n", 1]` or `["Tuple", "n", 1, 10]` with one or two bounds
+ * - a tuple, e.g. `["Pair", "n", 1]` or `["Tuple", "n", 1, 10]` with one
+ *   or two bounds
  *
- * The result is a normalized version that includes the
- * index, the lower and upper bounds of the range, and
- * a flag indicating whether the range is finite.
- * @param limits
+ * The result is a normalized version that includes the index, the lower and
+ * upper bounds of the range, and a flag indicating whether the range is finite.
+ * @param indexingSet
  * @returns
  */
-export declare function normalizeIndexingSet(limits: BoxedExpression | undefined): [
-    index: string | undefined,
-    lower: number,
-    upper: number,
-    isFinite: boolean
-];
+export declare function normalizeIndexingSet(indexingSet: BoxedExpression): IndexingSet;
+export declare function normalizeIndexingSets(ops: ReadonlyArray<BoxedExpression>): IndexingSet[];
+export declare function indexingSetCartestianProduct(indexingSets: IndexingSet[]): number[][];
+/**
+ * Calculates the cartesian product of two arrays.
+ * ```ts
+ * // Example usage
+ * const array1 = [1, 2, 3];
+ * const array2 = ['a', 'b', 'c'];
+ * const result = cartesianProduct(array1, array2);
+ * console.log(result);
+ * // Output: [[1, 'a'], [1, 'b'], [1, 'c'], [2, 'a'], [2, 'b'], [2, 'c'], [3, 'a'], [3, 'b'], [3, 'c']]
+ * ```
+ * @param array1 - The first array.
+ * @param array2 - The second array.
+ * @returns The cartesian product as a 2D array.
+ */
 export declare function cartesianProduct(array1: number[], array2: number[]): number[][];
-export declare function range(start: number, end: number): number[];
+export declare function canonicalIndexingSet(expr: BoxedExpression): BoxedExpression | undefined;
+export declare function canonicalBigop(operator: string, body: BoxedExpression, indexingSets: BoxedExpression[]): BoxedExpression | null;
+/**
+ * Process an expression of the form
+ * - ['Operator', body, ['Tuple', index1, lower, upper]]
+ * - ['Operator', body, ['Tuple', index1, lower, upper], ['Tuple', index2, lower, upper], ...]
+ * - ['Operator', body]
+ * - ['Operator', collection]
+ *
+ * `fn()` is the processing done on each element
+ */
+/**
+ * Apply the function `fn` to the body of a big operator, according to the
+ * indexing sets.
+ */
+export declare function reduceBigOp<T>(body: BoxedExpression, indexes: ReadonlyArray<BoxedExpression>, fn: (acc: T, x: BoxedExpression) => T | null, initial: T): T | undefined;

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

@@ -0,0 +1,59 @@
+/* 0.26.2 */
+import { NumericValue, NumericValueData } from './public';
+import { ExactNumericValue } from './exact-numeric-value';
+import { Expression } from '../../math-json/types';
+import { SmallInteger } from '../numerics/numeric';
+import { NumericType } from '../../common/type/types';
+export type BigNumFactory = (value: Decimal.Value) => Decimal;
+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 isExact(): boolean;
+    get asExact(): ExactNumericValue | undefined;
+    toJSON(): Expression;
+    toString(): string;
+    clone(value: number | Decimal | NumericValueData): BigNumericValue;
+    private _makeExact;
+    get re(): number;
+    get bignumRe(): Decimal;
+    get numerator(): BigNumericValue;
+    get denominator(): ExactNumericValue;
+    get isNaN(): boolean;
+    get isPositiveInfinity(): boolean;
+    get isNegativeInfinity(): boolean;
+    get isComplexInfinity(): boolean;
+    get isZero(): boolean;
+    isZeroWithTolerance(tolerance: number | Decimal): boolean;
+    get isOne(): boolean;
+    get isNegativeOne(): boolean;
+    sgn(): -1 | 0 | 1 | undefined;
+    N(): NumericValue;
+    neg(): BigNumericValue;
+    inv(): BigNumericValue;
+    add(other: number | NumericValue): NumericValue;
+    sub(other: NumericValue): NumericValue;
+    mul(other: number | Decimal | NumericValue): NumericValue;
+    div(other: SmallInteger | NumericValue): NumericValue;
+    pow(exponent: number | NumericValue | {
+        re: number;
+        im: number;
+    }): NumericValue;
+    root(exp: number): NumericValue;
+    sqrt(): NumericValue;
+    gcd(other: NumericValue): NumericValue;
+    abs(): NumericValue;
+    ln(base?: number): NumericValue;
+    exp(): NumericValue;
+    floor(): NumericValue;
+    ceil(): NumericValue;
+    round(): NumericValue;
+    eq(other: number | NumericValue): boolean;
+    lt(other: number | NumericValue): boolean | undefined;
+    lte(other: number | NumericValue): boolean | undefined;
+    gt(other: number | NumericValue): boolean | undefined;
+    gte(other: number | NumericValue): boolean | undefined;
+}