@cortex-js/compute-engine 0.32.1 → 0.33.0

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * Expression is a function of a single variable (`x`) or an Equality

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare class Terms {
     private engine;
     private terms;

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

@@ -1,5 +1,4 @@
-/* 0.32.1 */
-export declare function Fu(exp: BoxedExpression): RuleStep | undefined;
+/* 0.33.0 */
 /** Assuming x in an expression in radians, convert to current angular unit. */
 export declare function radiansToAngle(x: BoxedExpression | undefined): BoxedExpression | undefined;
 export declare function evalTrig(name: string, op: BoxedExpression | undefined): BoxedExpression | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 import { Type } from '../../common/type/types';
 import { NumericValue } from '../numeric-value/types';
 /**

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 import type { BoxedExpression, ComputeEngine } from '../global-types';
 /**
  * Check that the number of arguments is as expected.

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 /** If a collection has fewer than this many elements, eagerly evaluate it.
  *
  * For example, evaluate the Union of two sets with 10 elements each will

package/dist/types/compute-engine/cost-function.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 /**
  * The default cost function, used to determine if a new expression is simpler
  * than the old one.

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 import type { BoxedDefinition, BoxedExpression, ComputeEngine, Scope } from './global-types';
 /***
  * ### THEORY OF OPERATIONS

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 import type { OneOf } from '../common/one-of';
 import type { Expression, MathJsonNumberObject, MathJsonStringObject, MathJsonFunctionObject, MathJsonSymbolObject, MathJsonSymbol, MathJsonDictionaryObject } from '../math-json';
 import type { Type, TypeReference, TypeResolver, TypeString } from '../common/type/types';
@@ -107,7 +107,7 @@ export interface Tensor<DT extends TensorDataType> extends TensorData<DT> {
     readonly isZero: boolean;
     at(...indices: number[]): DataTypeMap[DT] | undefined;
     diagonal(axis1?: number, axis2?: number): undefined | DataTypeMap[DT][];
-    trace(axis1?: number, axis2?: number): undefined | DataTypeMap[DT];
+    trace(axis1?: number, axis2?: number): undefined | DataTypeMap[DT] | Tensor<DT>;
     reshape(...shape: number[]): Tensor<DT>;
     slice(index: number): Tensor<DT>;
     flatten(): DataTypeMap[DT][];
@@ -615,7 +615,7 @@ export interface BoxedExpression {
      * Return the value of this expression, if a number literal.
      *
      * Note it is possible for `expr.numericValue` to be `null`, and for
-     * `expr.isNotZero` to be true. For example, when a symbol has been
+     * `expr.is(0)` to be false. For example, when a symbol has been
      * defined with an assumption.
      *
      * Conversely, `expr.isNumber` may be true even if `expr.numericValue` is
@@ -1242,6 +1242,30 @@ export interface BoxedExpression {
      *
      */
     simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
+    /**
+     * Apply the Fu algorithm to simplify trigonometric expressions.
+     *
+     * The Fu algorithm is a systematic approach to trigonometric simplification
+     * that uses transformation rules (TR1-TR22), combination transforms (CTR),
+     * and rule lists (RL) to reduce the number of trigonometric functions.
+     *
+     * This is equivalent to calling `simplify({ strategy: 'fu' })` but is
+     * more convenient for trig-heavy expressions.
+     *
+     * Reference: Fu, Hongguang, Xiuqin Zhong, and Zhenbing Zeng.
+     * "Automated and readable simplification of trigonometric expressions."
+     * Mathematical and Computer Modelling 44.11 (2006): 1169-1177.
+     *
+     * @example
+     * ```typescript
+     * ce.parse('\\sin(x)\\cos(x)').trigSimplify()
+     * // => sin(2x)/2
+     *
+     * ce.parse('\\sin^2(x) + \\cos^2(x)').trigSimplify()
+     * // => 1
+     * ```
+     */
+    trigSimplify(): BoxedExpression;
     /**
      * Expand the expression: distribute multiplications over additions,
      * and expand powers.
@@ -2041,6 +2065,21 @@ export type SimplifyOptions = {
      * used.
      */
     costFunction?: (expr: BoxedExpression) => number;
+    /**
+     * The simplification strategy to use.
+     *
+     * - `'default'`: Use standard simplification rules (default)
+     * - `'fu'`: Use the Fu algorithm for trigonometric simplification.
+     *   This is more aggressive for trig expressions and may produce
+     *   different results than the default strategy.
+     *
+     *   **Note:** When using the `'fu'` strategy, the `costFunction` and `rules`
+     *   options are ignored. The Fu algorithm uses its own specialized cost
+     *   function that prioritizes minimizing the number of trigonometric
+     *   functions. Standard simplification is applied before and after the
+     *   Fu transformations using the engine's default rules.
+     */
+    strategy?: 'default' | 'fu';
 };
 /**
  * A table mapping symbols to their definition.

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 import { Decimal } from 'decimal.js';
 import { Type, TypeResolver, TypeString } from '../common/type/types';
 import { BoxedType } from '../common/type/boxed-type';

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const DEFINITIONS_COMPLEX: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const DEFINITIONS_CORE: LatexDictionary;
 export declare const DELIMITERS_SHORTHAND: {
     '(': string;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const DEFINITIONS_LINEAR_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const DEFINITIONS_LOGIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionaryEntry[];

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const DEFINITIONS_STATISTICS: LatexDictionary;

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

@@ -1,3 +1,3 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const SYMBOLS: [string, string, number][];
 export declare const DEFINITIONS_SYMBOLS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 import { Delimiter, EnvironmentParseHandler, ExpressionParseHandler, InfixParseHandler, LatexDictionary, LatexDictionaryEntry, LatexString, LatexToken, LibraryCategory, MatchfixParseHandler, PostfixParseHandler, Precedence, SerializeHandler } from '../types';
 export type CommonEntry = {
     /** Note: a name is required if a serialize handler is provided */
@@ -75,7 +75,9 @@ export type IndexedEnvironmentEntry = CommonEntry & {
 };
 /** @internal */
 export declare function isIndexedEnvironmentEntry(entry: IndexedLatexDictionaryEntry): entry is IndexedEnvironmentEntry;
+/** @internal */
 export type IndexedLatexDictionaryEntry = IndexedExpressionEntry | IndexedFunctionEntry | IndexedSymbolEntry | IndexedMatchfixEntry | IndexedInfixEntry | IndexedPrefixEntry | IndexedPostfixEntry | IndexedEnvironmentEntry;
+/** @internal */
 export type IndexedLatexDictionary = {
     ids: Map<string, IndexedLatexDictionaryEntry>;
     lookahead: number;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 import { Parser } from './types';
 /** For error handling, if we have a symbol prefix, assume
  * the symbol is invalid (it would have been captured by

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.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';

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.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.32.1 */
+/* 0.33.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.32.1 */
+/* 0.33.0 */
 import { LatexString, SerializeLatexOptions, DelimiterScale } from './types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
 export declare class Serializer {

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.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,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 import type { Expression, MathJsonSymbol } from '../../math-json/types';
 import { BoxedType, TypeString } from '../types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
@@ -365,7 +365,7 @@ export type FunctionEntry = BaseEntry & Trigger & {
  * A dictionary entry is a record that maps a LaTeX token or string of tokens
  * ( a trigger) to a MathJSON expression or to a parsing handler.
  *
- * Set the {@linkcode ComputeEngine.latexDictionary} property to an array of
+ * Set the `ComputeEngine.latexDictionary` property to an array of
  * dictionary entries to define custom LaTeX parsing and serialization.
  *
  * @category Latex Parsing and Serialization
@@ -563,6 +563,15 @@ export type ParseLatexOptions = NumberFormat & {
      * // parses as: ∀x. (P(x) → Q(x))
      */
     quantifierScope: 'tight' | 'loose';
+    /**
+     * The variable used for time derivatives in Newton notation
+     * (`\dot{x}`, `\ddot{x}`, etc.).
+     *
+     * When parsing `\dot{x}`, it will be interpreted as `["D", "x", timeDerivativeVariable]`.
+     *
+     * **Default:** `"t"`
+     */
+    timeDerivativeVariable: string;
 };
 /**
  *

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.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;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export type CanonicalArithmeticOperators = 'Add' | 'Negate' | 'Multiply' | 'Divide' | 'Power' | 'Sqrt' | 'Root' | 'Ln';
 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.32.1 */
+/* 0.33.0 */
 export declare const CALCULUS_LIBRARY: SymbolDefinitions[];

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const DEFAULT_LINSPACE_COUNT = 50;
 export declare const COLLECTIONS_LIBRARY: SymbolDefinitions;
 /**

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

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

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const COMPLEX_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const CONTROL_STRUCTURES_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const CORE_LIBRARY: SymbolDefinitions[];

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

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

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 import type { SymbolDefinitions, ComputeEngine } from '../global-types';
 export declare function getStandardLibrary(categories: LibraryCategory[] | LibraryCategory | 'all'): readonly SymbolDefinitions[];
 export declare const LIBRARIES: {

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const LINEAR_ALGEBRA_LIBRARY: SymbolDefinitions[];

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

@@ -1,8 +1,37 @@
-/* 0.32.1 */
+/* 0.33.0 */
 /**
  * Quantifier domain helpers and boolean analysis functions.
  * Extracted from logic.ts for better code organization.
  */
+/**
+ * Result of extracting a finite domain from an Element expression.
+ * - `status: 'success'` - Domain was successfully extracted
+ * - `status: 'non-enumerable'` - Domain exists but cannot be enumerated (e.g., infinite set, unknown symbol)
+ * - `status: 'error'` - Invalid Element expression (missing variable, malformed domain)
+ */
+export type ExtractDomainResult = {
+    status: 'success';
+    variable: string;
+    values: BoxedExpression[];
+} | {
+    status: 'non-enumerable';
+    variable: string;
+    domain: BoxedExpression;
+    reason: string;
+} | {
+    status: 'error';
+    reason: string;
+};
+/**
+ * Extract the finite domain from a quantifier's condition.
+ * Supports:
+ * - ["Element", "x", ["Set", 1, 2, 3]] → [1, 2, 3]
+ * - ["Element", "x", ["Range", 1, 5]] → [1, 2, 3, 4, 5]
+ * - ["Element", "x", ["Interval", 1, 5]] → [1, 2, 3, 4, 5] (integers only)
+ * - ["Element", "x", ["Set", 1, 2, 3], condition] → filtered values (EL-3)
+ * Returns detailed result indicating success, non-enumerable domain, or error.
+ */
+export declare function extractFiniteDomainWithReason(condition: BoxedExpression, ce: ComputeEngine): ExtractDomainResult;
 /**
  * Extract the finite domain from a quantifier's condition.
  * Supports:
@@ -10,6 +39,7 @@
  * - ["Element", "x", ["Range", 1, 5]] → [1, 2, 3, 4, 5]
  * - ["Element", "x", ["Interval", 1, 5]] → [1, 2, 3, 4, 5] (integers only)
  * Returns null if the domain is not finite or not recognized.
+ * @deprecated Use extractFiniteDomainWithReason for better error handling
  */
 export declare function extractFiniteDomain(condition: BoxedExpression, ce: ComputeEngine): {
     variable: string;

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

@@ -1,8 +1,4 @@
-/* 0.32.1 */
-/**
- * Basic evaluation functions for logical operators.
- * Extracted from logic.ts for better code organization.
- */
+/* 0.33.0 */
 export declare function evaluateAnd(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
     engine: ComputeEngine;
 }): BoxedExpression | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const LOGIC_LIBRARY: SymbolDefinitions;
 export declare function simplifyLogicFunction(x: BoxedExpression): {
     value: BoxedExpression;

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

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

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const POLYNOMIALS_LIBRARY: SymbolDefinitions[];

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

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

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const RELOP_LIBRARY: SymbolDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const SETS_LIBRARY: SymbolDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const STATISTICS_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare const TRIGONOMETRY_LIBRARY: SymbolDefinitions[];

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

@@ -1,4 +1,20 @@
-/* 0.32.1 */
+/* 0.33.0 */
+/**
+ * EL-4: Convert known infinite integer sets to their equivalent Limits bounds.
+ * Returns undefined if the set cannot be converted to a Limits form.
+ *
+ * Mappings:
+ * - NonNegativeIntegers (ℕ₀) → [0, ∞)
+ * - PositiveIntegers (ℤ⁺) → [1, ∞)
+ * - NegativeIntegers (ℤ⁻) → Not supported (would need negative direction)
+ * - Integers (ℤ) → Not supported (bidirectional)
+ * - Other sets (Reals, Complexes, etc.) → Not supported (non-integer)
+ */
+export declare function convertInfiniteSetToLimits(domainSymbol: string): {
+    lower: number;
+    upper: number;
+    isFinite: false;
+} | undefined;
 export type IndexingSet = {
     index: string | undefined;
     lower: number;
@@ -58,20 +74,62 @@ export declare function canonicalLimits(ops: ReadonlyArray<BoxedExpression>, { e
  * - `lower` (a number), `Nothing` if none is present
  * - `upper` (a number), `Nothing` if none is present
  *
+ * Or, for Element expressions, preserve them in canonical form.
+ *
  * 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(bigOp: string, body: BoxedExpression, indexingSets: BoxedExpression[], scope: Scope | undefined): BoxedExpression | null;
+/**
+ * A special symbol used to signal that a BigOp could not be evaluated
+ * because the domain is non-enumerable (e.g., infinite set, unknown symbol).
+ * When this is returned, the Sum/Product should keep the expression symbolic
+ * rather than returning NaN.
+ */
+export declare const NON_ENUMERABLE_DOMAIN: unique symbol;
+/**
+ * Result type for reduceBigOp that includes reason for failure
+ */
+export type BigOpResult<T> = {
+    status: 'success';
+    value: T;
+} | {
+    status: 'non-enumerable';
+    reason: string;
+    domain?: BoxedExpression;
+} | {
+    status: 'error';
+    reason: string;
+};
 /**
  * Process an expression of the form
  * - ['Operator', body, ['Tuple', index1, lower, upper]]
  * - ['Operator', body, ['Tuple', index1, lower, upper], ['Tuple', index2, lower, upper], ...]
+ * - ['Operator', body, ['Element', index, collection]]
  * - ['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.
+ *
+ * Returns either the reduced value, or `typeof NON_ENUMERABLE_DOMAIN` if the
+ * domain cannot be enumerated (in which case the expression should remain symbolic).
  */
-export declare function reduceBigOp<T>(body: BoxedExpression, indexes: ReadonlyArray<BoxedExpression>, fn: (acc: T, x: BoxedExpression) => T | null, initial: T): Generator<T | undefined>;
+export declare function reduceBigOp<T>(body: BoxedExpression, indexes: ReadonlyArray<BoxedExpression>, fn: (acc: T, x: BoxedExpression) => T | null, initial: T): Generator<T | typeof NON_ENUMERABLE_DOMAIN | undefined>;
+/**
+ * Result type for reduceElementIndexingSets to distinguish between
+ * successful evaluation, non-enumerable domains (keep symbolic), and errors.
+ */
+export type ReduceElementResult<T> = {
+    status: 'success';
+    value: T;
+} | {
+    status: 'non-enumerable';
+    reason: string;
+    domain?: BoxedExpression;
+} | {
+    status: 'error';
+    reason: string;
+};

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 import { BigNumFactory, NumericValue, NumericValueData } from './types';
 import { ExactNumericValue } from './exact-numeric-value';
 import { Expression } from '../../math-json/types';

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 import { Rational, SmallInteger } from '../numerics/types';
 import { BigNumFactory, ExactNumericValueData, NumericValue, NumericValueFactory } from './types';
 import { Expression } from '../../math-json/types';

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 import { BigNumFactory, NumericValue, NumericValueData } from './types';
 import type { Expression } from '../../math-json/types';
 import type { SmallInteger } from '../numerics/types';

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
  *
  * ## THEORY OF OPERATIONS
  *

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

@@ -1,2 +1,2 @@
-/* 0.32.1 */
+/* 0.33.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.32.1 */
+/* 0.33.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.32.1 */
+/* 0.33.0 */
 /** An interval is a continuous set of real numbers */
 export type Interval = {
     start: number;

package/dist/types/compute-engine/numerics/monte-carlo.d.ts

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
     estimate: number;
     error: number;
 };

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

@@ -1,4 +1,4 @@
-/* 0.32.1 */
+/* 0.33.0 */
 export declare function lcm(a: bigint, b: bigint): bigint;
 /** Return `[factor, root]` such that
  * pow(n, 1/exponent) = factor * pow(root, 1/exponent)