@cortex-js/compute-engine 0.54.1 → 0.55.0

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
     estimate: number;
     error: number;
 };

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

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

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

@@ -1,9 +1,9 @@
-/* 0.54.1 */
+/* 0.55.0 */
 export declare function gcd(a: BigNum, b: BigNum): BigNum;
 export declare function lcm(a: BigNum, b: BigNum): BigNum;
-export declare function factorial2(ce: IBigNum, n: BigNum): Generator<BigNum, BigNum>;
+export declare function factorial2(n: BigNum): Generator<BigNum, BigNum>;
 /**
- * If the exponent of the bignum is in the range of the exponents
- * for machine numbers,return true.
+ * If the BigDecimal can be faithfully represented as a machine number,
+ * return true.
  */
 export declare function isInMachineRange(d: BigNum): boolean;

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

@@ -1,3 +1,3 @@
-/* 0.54.1 */
+/* 0.55.0 */
 export declare function gamma(c: Complex): Complex;
 export declare function gammaln(c: Complex): Complex;

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 export declare const MACHINE_PRECISION_BITS = 53;
 export declare const MACHINE_PRECISION: number;
 export declare const DEFAULT_TOLERANCE = 1e-10;

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 export declare function primeFactors(n: number): {
     [factor: number]: number;
 };

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 export declare function isRational(x: unknown | null): x is Rational;
 export declare function isMachineRational(x: unknown | null): x is [SmallInteger, SmallInteger];
 export declare function isBigRational(x: unknown | null): x is [bigint, bigint];

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 
     Translated from https://github.com/JuliaMath/Richardson.jl/blob/master/src/Richardson.jl
 

package/dist/types/compute-engine/numerics/special-functions.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 import type { BigNum } from './types';
 export declare function gammaln(z: number): number;
 export declare function gamma(z: number): number;
@@ -24,8 +24,34 @@ export declare function erfc(x: number): number;
  * - NIST: https://dlmf.nist.gov/7.24#i
  */
 export declare function erf(x: number): number;
+/**
+ * Bignum log-Gamma via Stirling asymptotic series with runtime-computed
+ * Bernoulli numbers.  Precision scales with BigDecimal.precision.
+ *
+ * Uses reflection for z < 0.5, exact formulas for positive integers and
+ * half-integers, and for the general case shifts z upward so the asymptotic
+ * series converges rapidly.
+ */
 export declare function bigGammaln(ce: ComputeEngine, z: BigNum): BigNum;
+/**
+ * Bignum Gamma function.  Precision scales with BigDecimal.precision.
+ *
+ * Reflection for z < 0.5; general case delegates to exp(bigGammaln(z)).
+ * Note: integer fast paths are in bigGammaln (returning exact ln(n!)).
+ * bigGamma goes through exp(ln(...)) so the result is a full-precision float.
+ */
 export declare function bigGamma(ce: ComputeEngine, z: BigNum): BigNum;
+/**
+ * Compute even Bernoulli numbers B_2, B_4, ..., B_{2n} as exact rationals.
+ * Returns [numerator, denominator] bigint pairs reduced to lowest terms.
+ *
+ * Uses the identity: sum_{k=0}^{m-1} C(m,k) * B_k = 0  (for m >= 2)
+ * i.e. B_m = -1/(m+1) * sum_{k=0}^{m-1} C(m+1,k) * B_k
+ *
+ * Since all odd Bernoulli numbers except B_1 = -1/2 are zero, we compute
+ * all B_k (k=0,1,2,...,2n) but only return the even ones.
+ */
+export declare function computeBernoulliEven(n: number): [bigint, bigint][];
 /**
  * Bignum Digamma function ψ(z) = d/dz ln(Γ(z))
  * Same algorithm as machine `digamma`: reflection for negative z,

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

@@ -1,23 +1,23 @@
-/* 0.54.1 */
+/* 0.55.0 */
 export declare function mean(values: Iterable<number>): number;
-export declare function bigMean(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
+export declare function bigMean(values: Iterable<BigDecimal>): BigDecimal;
 export declare function median(values: Iterable<number>): number;
-export declare function bigMedian(values: Iterable<BigNum>): BigNum;
+export declare function bigMedian(values: Iterable<BigDecimal>): BigDecimal;
 export declare function variance(values: Iterable<number>): number;
-export declare function bigVariance(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
+export declare function bigVariance(values: Iterable<BigDecimal>): BigDecimal;
 export declare function populationVariance(values: Iterable<number>): number;
-export declare function bigPopulationVariance(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
+export declare function bigPopulationVariance(values: Iterable<BigDecimal>): BigDecimal;
 export declare function standardDeviation(values: Iterable<number>): number;
-export declare function bigStandardDeviation(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
+export declare function bigStandardDeviation(values: Iterable<BigDecimal>): BigDecimal;
 export declare function populationStandardDeviation(values: Iterable<number>): number;
-export declare function bigPopulationStandardDeviation(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
+export declare function bigPopulationStandardDeviation(values: Iterable<BigDecimal>): BigDecimal;
 export declare function kurtosis(values: Iterable<number>): number;
-export declare function bigKurtosis(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
+export declare function bigKurtosis(values: Iterable<BigDecimal>): BigDecimal;
 export declare function skewness(values: Iterable<number>): number;
-export declare function bigSkewness(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
+export declare function bigSkewness(values: Iterable<BigDecimal>): BigDecimal;
 export declare function mode(values: Iterable<number>): number;
-export declare function bigMode(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
+export declare function bigMode(values: Iterable<BigDecimal>): BigDecimal;
 export declare function quartiles(values: Iterable<number>): [number, number, number];
-export declare function bigQuartiles(values: Iterable<BigNum>): [BigNum, BigNum, BigNum];
+export declare function bigQuartiles(values: Iterable<BigDecimal>): [BigDecimal, BigDecimal, BigDecimal];
 export declare function interquartileRange(values: Iterable<number>): number;
-export declare function bigInterquartileRange(values: Iterable<BigNum>): BigNum;
+export declare function bigInterquartileRange(values: Iterable<BigDecimal>): BigDecimal;

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

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.0 */
 export declare function numberToString(num: number | bigint, fractionalDigits?: number | string): string;

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 /** @internal */
 type IsInteger<N extends number> = `${N}` extends `${string}.${string}` ? never : `${N}` extends `-${string}.${string}` ? never : number;
 /** A `SmallInteger` is an integer < 1e6
@@ -16,18 +16,5 @@ export type SmallInteger = IsInteger<number>;
  */
 export type Rational = [SmallInteger, SmallInteger] | [bigint, bigint];
 /** @category Numerics */
-export type BigNum = Decimal;
-/** @category Numerics */
-export type BigNumFactory = (value: Decimal.Value) => Decimal;
-/** @category Numerics */
-export interface IBigNum {
-    readonly _BIGNUM_NAN: BigNum;
-    readonly _BIGNUM_ZERO: BigNum;
-    readonly _BIGNUM_ONE: BigNum;
-    readonly _BIGNUM_TWO: BigNum;
-    readonly _BIGNUM_HALF: BigNum;
-    readonly _BIGNUM_PI: BigNum;
-    readonly _BIGNUM_NEGATIVE_ONE: BigNum;
-    bignum(value: string | number | bigint | BigNum): BigNum;
-}
+export type BigNum = BigDecimal;
 export {};

package/dist/types/compute-engine/numerics/unit-data.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
  * Unit registry: dimension vectors, SI base units, prefixes, and conversion.
  *
  * A DimensionVector encodes the exponents for each of the 7 SI base

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
  * OEIS (Online Encyclopedia of Integer Sequences) Integration
  *
  * This module provides functions to look up sequences in the OEIS database

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
  * Utilities for declarative sequence definitions.
  *
  * This module provides functions to create subscriptEvaluate handlers

package/dist/types/compute-engine/symbolic/antiderivative.d.ts

@@ -1,3 +1,3 @@
-/* 0.54.1 */
+/* 0.55.0 */
 /** Calculate the antiderivative of fn, as an expression (not a function) */
 export declare function antiderivative(fn: Expression, index: string): Expression;

package/dist/types/compute-engine/symbolic/derivative.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 /**
  *
  * @param fn The function to differentiate, a function literal.

package/dist/types/compute-engine/symbolic/distribute.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 /**
  *
  */

package/dist/types/compute-engine/symbolic/fu-cost.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
  * Cost functions for the Fu trigonometric simplification algorithm.
  *
  * The primary objective is to minimize the number of trigonometric functions,

package/dist/types/compute-engine/symbolic/fu-transforms.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
  * Fu Algorithm Transformation Rules
  *
  * Programmatic implementations of TR1-TR22 from the Fu trigonometric

package/dist/types/compute-engine/symbolic/fu.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
  * Fu Algorithm for Trigonometric Simplification
  *
  * Implementation of the algorithm by Fu, Zhong, and Zeng:

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 export declare function evaluateAnd(args: ReadonlyArray<Expression>, { engine: ce }: {
     engine: ComputeEngine;
 }): Expression | undefined;

package/dist/types/compute-engine/symbolic/simplify-abs.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 export declare function simplifyAbs(x: Expression): RuleStep | undefined;
 /**
  * Simplify expressions where Abs appears as the base of a power.

package/dist/types/compute-engine/symbolic/simplify-divide.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 /**
  * Division simplification rules consolidated from simplify-rules.ts.
  *

package/dist/types/compute-engine/symbolic/simplify-factorial.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 /**
  * Extracts base + integer offset from an expression.
  * - Symbol `n` → { base: n, offset: 0 }

package/dist/types/compute-engine/symbolic/simplify-hyperbolic.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.0 */
 export declare function simplifyHyperbolic(x: Expression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-infinity.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 /**
  * Infinity simplification rules consolidated from simplify-rules.ts.
  * Handles ~20 patterns for simplifying expressions involving infinity.

package/dist/types/compute-engine/symbolic/simplify-log.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 /**
  * Logarithm simplification rules consolidated from simplify-rules.ts.
  * Handles ~30 patterns for simplifying Ln and Log expressions.

package/dist/types/compute-engine/symbolic/simplify-logic.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 export declare function simplifyLogicFunction(x: Expression): {
     value: Expression;
     because: string;

package/dist/types/compute-engine/symbolic/simplify-power.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 /**
  * Power simplification rules consolidated from simplify-rules.ts.
  * Handles ~25 patterns for simplifying Power expressions.

package/dist/types/compute-engine/symbolic/simplify-product.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 /**
  * Product simplification rules extracted from simplify-rules.ts.
  * Handles 13 patterns for simplifying Product expressions.

package/dist/types/compute-engine/symbolic/simplify-rules.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 /**
  * # Performance Optimization Notes for Simplification Rules
  *

package/dist/types/compute-engine/symbolic/simplify-sum.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 /**
  * Sum simplification rules extracted from simplify-rules.ts.
  * Handles 16 patterns for simplifying Sum expressions.

package/dist/types/compute-engine/symbolic/simplify-trig.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.1 */
+/* 0.55.0 */
 export declare function simplifyTrig(x: Expression): RuleStep | undefined;

package/dist/types/compute-engine/tensor/tensor-fields.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 import { Expression, IComputeEngine as ComputeEngine, DataTypeMap, TensorDataType, TensorField } from '../global-types';
 /** @category Tensors */
 export declare function makeTensorField<DT extends keyof DataTypeMap>(ce: ComputeEngine, dtype: DT): TensorField<DataTypeMap[DT]>;

package/dist/types/compute-engine/tensor/tensors.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 /** @category Tensors */
 export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> implements Tensor<DT> {
     private ce;

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

@@ -1,7 +1,7 @@
-/* 0.54.1 */
+/* 0.55.0 */
 import type { Type, TypeString } from '../common/type/types';
 import type { BoxedType } from '../common/type/boxed-type';
-import type { LatexString, LatexDictionaryEntry } from './latex-syntax/types';
+import type { LatexString } from './latex-syntax/types';
 import type { Expression, ExpressionInput, CompiledExpression } from './types-expression';
 import type { EvaluateOptions as KernelEvaluateOptions, Rule as KernelRule, BoxedRule as KernelBoxedRule, BoxedRuleSet as KernelBoxedRuleSet, Scope as KernelScope } from './types-kernel-evaluation';
 /**
@@ -523,8 +523,6 @@ export interface LibraryDefinition {
     requires?: string[];
     /** Symbol and operator definitions */
     definitions?: SymbolDefinitions | SymbolDefinitions[];
-    /** LaTeX dictionary entries for parsing/serialization */
-    latexDictionary?: Readonly<Partial<LatexDictionaryEntry>[]>;
 }
 /**
  * When a unitless value is passed to or returned from a trigonometric function,

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

@@ -1,13 +1,12 @@
-/* 0.54.1 */
+/* 0.55.0 */
 import type { OneOf } from '../common/one-of';
 import type { MathJsonSymbol, MathJsonNumberObject } from '../math-json';
 import type { Type, TypeString, TypeResolver } from '../common/type/types';
 import type { BoxedType } from '../common/type/boxed-type';
 import type { ConfigurationChangeListener } from '../common/configuration-change';
+import type { ParseLatexOptions } from './latex-syntax/types';
 import type { ExactNumericValueData, NumericValue, NumericValueData } from './numeric-value/types';
-import type { BigNum, IBigNum, Rational } from './numerics/types';
-import type { LatexDictionaryEntry, LatexString, ParseLatexOptions } from './latex-syntax/types';
-import type { IndexedLatexDictionary } from './latex-syntax/dictionary/definitions';
+import type { BigNum, Rational } from './numerics/types';
 import type { Expression, ExpressionInput } from './types-expression';
 import type { Metadata, CanonicalOptions, FormOption, BoxedSubstitution } from './types-serialization';
 import type { AngularUnit, SymbolDefinition, OperatorDefinition, ValueDefinition, BoxedDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions } from './types-definitions';
@@ -20,12 +19,20 @@ type RuleStep = KernelRuleStep<Expression>;
 type AssignValue = KernelAssignValue<Expression, ExpressionInput, IComputeEngine>;
 type Scope = KernelScope<BoxedDefinition>;
 type EvalContext = KernelEvalContext<Expression, BoxedDefinition>;
+/** Minimal interface for a LaTeX parser/serializer.
+ *  Structurally compatible with `LatexSyntax` without importing it. */
+export interface ILatexSyntax {
+    parse(latex: string, options?: Partial<ParseLatexOptions>): import('../math-json/types').MathJsonExpression | null;
+    serialize(expr: import('../math-json/types').MathJsonExpression, options?: Record<string, unknown>): string;
+}
 /** @internal */
-export interface IComputeEngine extends IBigNum {
-    latexDictionary: readonly LatexDictionaryEntry[];
-    /** @private */
-    _indexedLatexDictionary: IndexedLatexDictionary;
-    decimalSeparator: LatexString;
+export interface IComputeEngine {
+    /** The LatexSyntax instance used for LaTeX parsing/serialization.
+     *  `undefined` when no LatexSyntax was provided to the constructor.
+     */
+    readonly latexSyntax: ILatexSyntax | undefined;
+    /** @internal Returns the LatexSyntax instance or throws if unavailable. */
+    _requireLatexSyntax(): ILatexSyntax;
     readonly True: Expression;
     readonly False: Expression;
     readonly Pi: Expression;
@@ -41,20 +48,6 @@ export interface IComputeEngine extends IBigNum {
     readonly PositiveInfinity: Expression;
     readonly NegativeInfinity: Expression;
     readonly ComplexInfinity: Expression;
-    /** @internal */
-    readonly _BIGNUM_NAN: BigNum;
-    /** @internal */
-    readonly _BIGNUM_ZERO: BigNum;
-    /** @internal */
-    readonly _BIGNUM_ONE: BigNum;
-    /** @internal */
-    readonly _BIGNUM_TWO: BigNum;
-    /** @internal */
-    readonly _BIGNUM_HALF: BigNum;
-    /** @internal */
-    readonly _BIGNUM_PI: BigNum;
-    /** @internal */
-    readonly _BIGNUM_NEGATIVE_ONE: BigNum;
     readonly context: EvalContext;
     contextStack: ReadonlyArray<EvalContext>;
     /** @internal */
@@ -95,10 +88,27 @@ export interface IComputeEngine extends IBigNum {
      *  Users can `push()` additional rules or replace the entire array. */
     simplificationRules: Rule[];
     strict: boolean;
+    expr(expr: NumericValue | ExpressionInput, options?: {
+        form?: FormOption;
+        scope?: Scope;
+    }): Expression;
+    /** @deprecated Use `expr()` instead. */
     box(expr: NumericValue | ExpressionInput, options?: {
         form?: FormOption;
         scope?: Scope;
     }): Expression;
+    /**
+     * Parse a LaTeX string and return a boxed expression.
+     *
+     * This is a convenience method equivalent to `ce.expr(parse(latex))`,
+     * but uses the engine's symbol definitions for better parsing accuracy.
+     */
+    parse(latex: string, options?: Partial<ParseLatexOptions> & {
+        form?: FormOption;
+    }): Expression;
+    parse(latex: string | null, options?: Partial<ParseLatexOptions> & {
+        form?: FormOption;
+    }): Expression | null;
     function(name: string, ops: ReadonlyArray<ExpressionInput>, options?: {
         metadata?: Metadata;
         form?: FormOption;
@@ -107,7 +117,7 @@ export interface IComputeEngine extends IBigNum {
     /**
      * This is a primitive to create a boxed function.
      *
-     * In general, consider using `ce.box()` or `ce.function()` or
+     * In general, consider using `ce.expr()` or `ce.function()` or
      * `canonicalXXX()` instead.
      *
      * The caller must ensure that the arguments are in canonical form:
@@ -124,13 +134,13 @@ export interface IComputeEngine extends IBigNum {
     }): Expression;
     /** @internal Compile a boxed expression. */
     _compile(expr: Expression, options?: Record<string, unknown>): CompilationResult;
-    /** Register a custom compilation target. */
-    registerCompilationTarget(name: string, target: LanguageTarget<Expression>): void;
-    /** Get a registered compilation target by name. */
+    /** @internal Get a registered compilation target by name. */
     getCompilationTarget(name: string): LanguageTarget<Expression> | undefined;
-    /** Return the names of all registered compilation targets. */
+    /** @internal Return the names of all registered compilation targets. */
     listCompilationTargets(): string[];
-    /** Remove a registered compilation target. */
+    /** @internal Register a compilation target. */
+    registerCompilationTarget(name: string, target: LanguageTarget<Expression>): void;
+    /** @internal Remove a registered compilation target. */
     unregisterCompilationTarget(name: string): void;
     /** @internal Fu trigonometric simplification algorithm */
     _fuAlgorithm(expr: Expression, options?: Record<string, unknown>): RuleStep | undefined;
@@ -153,15 +163,6 @@ export interface IComputeEngine extends IBigNum {
         canonical?: boolean;
     }): BoxedRuleSet;
     getRuleSet(id?: 'harmonization' | 'solve-univariate' | 'standard-simplification'): BoxedRuleSet | undefined;
-    parse(latex: null, options?: Partial<ParseLatexOptions> & {
-        form?: FormOption;
-    }): null;
-    parse(latex: LatexString, options?: Partial<ParseLatexOptions> & {
-        form?: FormOption;
-    }): Expression;
-    parse(latex: LatexString | null, options?: Partial<ParseLatexOptions> & {
-        form?: FormOption;
-    }): Expression | null;
     pushScope(scope?: Scope, name?: string): void;
     popScope(): void;
     /**
@@ -212,7 +213,7 @@ export interface IComputeEngine extends IBigNum {
      * @internal */
     _declareSymbolOperator(name: string, def: OperatorDefinition, scope?: Scope): BoxedDefinition;
     /**
-     * Use `ce.box(id)` instead
+     * Use `ce.expr(id)` instead
      * @internal */
     _getSymbolValue(id: MathJsonSymbol): Expression | undefined;
     /**

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

@@ -1,4 +1,4 @@
-/* 0.54.1 */
+/* 0.55.0 */
 import type { IComputeEngine as ComputeEngine } from './types-engine';
 import type { Expression, ExpressionInput } from './types-expression';
 import type { Assumption as KernelAssumption, AssumeResult, AssignValue as KernelAssignValue, BoxedRule as KernelBoxedRule, BoxedRuleSet as KernelBoxedRuleSet, EvaluateOptions as KernelEvaluateOptions, EvalContext as KernelEvalContext, ExpressionMapInterface as KernelExpressionMapInterface, Rule as KernelRule, RuleConditionFunction as KernelRuleConditionFunction, RuleFunction as KernelRuleFunction, RuleReplaceFunction as KernelRuleReplaceFunction, RuleStep as KernelRuleStep, RuleSteps as KernelRuleSteps, Scope as KernelScope } from './types-kernel-evaluation';