@cortex-js/compute-engine 0.54.0 → 0.55.0

package/dist/types/big-decimal/big-decimal.d.ts

@@ -0,0 +1,191 @@
+/* 0.55.0 */
+ * BigDecimal: an arbitrary-precision decimal type.
+ *
+ * Value = significand * 10^exponent
+ *
+ * The representation is always normalized: trailing zeros in the significand
+ * are stripped and the exponent adjusted accordingly.
+ *
+ * Special values:
+ *  - NaN:       { significand: 0n, exponent: NaN }
+ *  - +Infinity: { significand: 1n, exponent: Infinity }
+ *  - -Infinity: { significand: -1n, exponent: Infinity }
+ */
+import { PI_DIGITS } from './utils';
+export { PI_DIGITS };
+export declare class BigDecimal {
+    /** Working precision (significant digits) for inexact operations like division. */
+    static precision: number;
+    static readonly ZERO: BigDecimal;
+    static readonly ONE: BigDecimal;
+    static readonly TWO: BigDecimal;
+    static readonly NEGATIVE_ONE: BigDecimal;
+    static readonly HALF: BigDecimal;
+    static readonly NAN: BigDecimal;
+    static readonly POSITIVE_INFINITY: BigDecimal;
+    static readonly NEGATIVE_INFINITY: BigDecimal;
+    /** Full-precision PI (1100+ digits) */
+    private static _piFullPrecision;
+    /** PI rounded to working precision */
+    private static _piCache;
+    private static _piCachePrecision;
+    /** PI to current working precision. */
+    static get PI(): BigDecimal;
+    readonly significand: bigint;
+    readonly exponent: number;
+    constructor(value: string | number | bigint | BigDecimal);
+    /** True when this value represents NaN. */
+    isNaN(): boolean;
+    /** True when significand is 0 and the value is not NaN. */
+    isZero(): boolean;
+    /** True when the exponent is finite (not NaN, not +/-Infinity). */
+    isFinite(): boolean;
+    /** True when the value represents a mathematical integer (exponent >= 0) and is finite. */
+    isInteger(): boolean;
+    /** True when significand > 0 (including positive infinity). */
+    isPositive(): boolean;
+    /** True when significand < 0 (including negative infinity). */
+    isNegative(): boolean;
+    /**
+     * Compare this value with another.
+     * Returns -1 if this < other, 0 if equal, 1 if this > other, NaN if either is NaN.
+     */
+    cmp(other: BigDecimal | number): -1 | 0 | 1;
+    /**
+     * Returns true if this value equals other.
+     * NaN === NaN → false (standard NaN semantics).
+     */
+    eq(other: BigDecimal | number): boolean;
+    /** Returns true if this value is strictly less than other. */
+    lt(other: BigDecimal | number): boolean;
+    /** Returns true if this value is less than or equal to other. */
+    lte(other: BigDecimal | number): boolean;
+    /** Returns true if this value is strictly greater than other. */
+    gt(other: BigDecimal | number): boolean;
+    /** Returns true if this value is greater than or equal to other. */
+    gte(other: BigDecimal | number): boolean;
+    /**
+     * Add this value to another.
+     * Aligns exponents, adds significands. The result is exact.
+     */
+    add(other: BigDecimal | number): BigDecimal;
+    /**
+     * Subtract other from this.
+     * Aligns exponents, subtracts significands. The result is exact.
+     */
+    sub(other: BigDecimal | number): BigDecimal;
+    /**
+     * Multiply this value by another.
+     * Multiplies significands, adds exponents. The result is exact.
+     */
+    mul(other: BigDecimal | number): BigDecimal;
+    /**
+     * Negate this value. Zero.neg() → Zero.
+     */
+    neg(): BigDecimal;
+    /**
+     * Absolute value. If already non-negative, returns this.
+     */
+    abs(): BigDecimal;
+    /**
+     * Round toward -Infinity.
+     * `3.7` → `3`, `-3.7` → `-4`.
+     * For integers returns this. NaN/Infinity → return this.
+     */
+    floor(): BigDecimal;
+    /**
+     * Round toward +Infinity.
+     * `3.2` → `4`, `-3.2` → `-3`.
+     * For integers returns this. NaN/Infinity → return this.
+     */
+    ceil(): BigDecimal;
+    /**
+     * Round half away from zero (standard math rounding).
+     * `3.5` → `4`, `-3.5` → `-4`, `3.4` → `3`, `3.6` → `4`.
+     * For integers returns this. NaN/Infinity → return this.
+     */
+    round(): BigDecimal;
+    /**
+     * Truncate toward zero, removing the fractional part.
+     * For integers (exponent >= 0) returns this.
+     * NaN → NaN, +/-Infinity → +/-Infinity.
+     */
+    trunc(): BigDecimal;
+    /**
+     * Divide this value by another.
+     * Uses `BigDecimal.precision` to determine significant digits for inexact results.
+     *
+     * Special cases:
+     *  - NaN / x → NaN, x / NaN → NaN
+     *  - nonzero / 0 → +/-Infinity (matching Decimal.js behavior)
+     *  - 0 / 0 → NaN
+     *  - Inf / finite → Inf (correct sign)
+     *  - finite / Inf → 0
+     *  - Inf / Inf → NaN
+     */
+    div(other: BigDecimal | number): BigDecimal;
+    /**
+     * Multiplicative inverse: 1 / this.
+     * Uses `BigDecimal.precision` for the division.
+     */
+    inv(): BigDecimal;
+    /**
+     * Modulo (remainder after truncating division).
+     * Defined as: this - trunc(this / other) * other
+     *
+     * The sign of the result matches the sign of the dividend (this),
+     * consistent with JavaScript's % operator and Decimal.js.
+     */
+    mod(other: BigDecimal | number): BigDecimal;
+    /**
+     * Raise to a power.
+     *
+     * - Integer exponent: exact result via repeated squaring
+     * - Zero exponent: 1 (for any non-NaN base)
+     * - Negative integer exponent: pow(abs(n)).inv() (uses precision)
+     * - Non-integer exponent on positive base: exp(n * ln(this))
+     * - Non-integer exponent on negative base: NaN (real-valued result doesn't exist)
+     *
+     * Special cases:
+     *  - NaN base or exponent → NaN
+     *  - Infinite exponent → NaN
+     *  - 0^0 → 1 (mathematical convention)
+     *  - 0^positive → 0
+     *  - 0^negative → Infinity
+     */
+    pow(n: BigDecimal | number): BigDecimal;
+    /** Convert to a JavaScript number. May lose precision for large values. */
+    toNumber(): number;
+    /**
+     * Reconstruct a decimal string from significand and exponent.
+     *
+     * For normal-range exponents, produces a clean decimal string.
+     * For very large (> 20) or very small (< -6) adjusted exponents,
+     * uses scientific notation like `'1.5e+25'`.
+     */
+    toString(): string;
+    /**
+     * Format with a fixed number of decimal places.
+     *
+     * Rounds to the specified number of digits after the decimal point
+     * using round-half-to-even (banker's rounding) for the tie-breaking case.
+     * If `digits` is undefined, behaves like toFixed(0).
+     */
+    toFixed(digits?: number): string;
+    /**
+     * Round to n significant digits, returning a new BigDecimal.
+     * Uses round-half-to-even for tie-breaking.
+     * If the value already has n or fewer significant digits, returns this.
+     */
+    toPrecision(n: number): BigDecimal;
+    /**
+     * Truncate fractional part and return a bigint.
+     * Throws if the value is NaN or Infinity.
+     */
+    toBigInt(): bigint;
+}
+/**
+ * Create a BigDecimal directly from significand + exponent, normalizing.
+ * Avoids the constructor's string/number parsing overhead.
+ */
+export declare function fromRaw(sig: bigint, exp: number): BigDecimal;

package/dist/types/big-decimal/index.d.ts

@@ -0,0 +1,2 @@
+/* 0.55.0 */
+import './transcendentals';

package/dist/types/big-decimal/transcendentals.d.ts

@@ -0,0 +1,56 @@
+/* 0.55.0 */
+ * Transcendental / irrational operations for BigDecimal.
+ *
+ * This module attaches `sqrt()` and `cbrt()` to BigDecimal.prototype
+ * via declaration merging. It is imported for side effects in index.ts.
+ */
+declare module './big-decimal' {
+    interface BigDecimal {
+        /** Square root. Returns NaN for negative values. */
+        sqrt(): BigDecimal;
+        /** Cube root. Supports negative values. */
+        cbrt(): BigDecimal;
+        /** Exponential: e^this. */
+        exp(): BigDecimal;
+        /** Natural logarithm. Returns NaN for negative values, -Infinity for zero. */
+        ln(): BigDecimal;
+        /** Logarithm with specified base. */
+        log(base: BigDecimal | number): BigDecimal;
+        /** Sine. Returns NaN for NaN/Infinity inputs. */
+        sin(): BigDecimal;
+        /** Cosine. Returns NaN for NaN/Infinity inputs. */
+        cos(): BigDecimal;
+        /** Tangent. Returns NaN for NaN/Infinity inputs. */
+        tan(): BigDecimal;
+        /** Inverse sine (arcsine). Returns NaN for |x| > 1. */
+        asin(): BigDecimal;
+        /** Inverse cosine (arccosine). Returns NaN for |x| > 1. */
+        acos(): BigDecimal;
+        /** Inverse tangent (arctangent). */
+        atan(): BigDecimal;
+        /** Hyperbolic sine. */
+        sinh(): BigDecimal;
+        /** Hyperbolic cosine. */
+        cosh(): BigDecimal;
+        /** Hyperbolic tangent. */
+        tanh(): BigDecimal;
+    }
+    namespace BigDecimal {
+        function sqrt(x: BigDecimal): BigDecimal;
+        function cbrt(x: BigDecimal): BigDecimal;
+        function exp(x: BigDecimal): BigDecimal;
+        function ln(x: BigDecimal): BigDecimal;
+        function log10(x: BigDecimal): BigDecimal;
+        function sin(x: BigDecimal): BigDecimal;
+        function cos(x: BigDecimal): BigDecimal;
+        function tan(x: BigDecimal): BigDecimal;
+        function asin(x: BigDecimal): BigDecimal;
+        function acos(x: BigDecimal): BigDecimal;
+        function atan(x: BigDecimal): BigDecimal;
+        function atan2(y: BigDecimal | number, x: BigDecimal): BigDecimal;
+        function sinh(x: BigDecimal): BigDecimal;
+        function cosh(x: BigDecimal): BigDecimal;
+        function tanh(x: BigDecimal): BigDecimal;
+    }
+}
+export {};

package/dist/types/big-decimal/utils.d.ts

@@ -0,0 +1,86 @@
+/* 0.55.0 */
+ * Fixed-point BigInt utilities for internal use by transcendental functions.
+ *
+ * A "fixed-point BigInt" represents a real number as `value = n / scale`,
+ * where `scale = 10^p` for some working precision p. All arithmetic
+ * stays in BigInt to preserve arbitrary precision.
+ */
+/** Return 10^n as a bigint, caching values for n <= 100. */
+export declare function pow10(n: number): bigint;
+/** Fixed-point multiply: (a * b) / scale */
+export declare function fpmul(a: bigint, b: bigint, scale: bigint): bigint;
+/** Fixed-point divide: (a * scale) / b */
+export declare function fpdiv(a: bigint, b: bigint, scale: bigint): bigint;
+/**
+ * Fixed-point square root via Newton/Heron iteration.
+ *
+ * Input:  `a` is a fixed-point value representing `a / scale`.
+ * Output: `sqrt(a / scale) * scale` as a bigint.
+ *
+ * Algorithm:
+ *   x_{n+1} = (x + a * scale / x) / 2
+ * Converge until |x_{n+1} - x_n| <= 1 (one ULP in the fixed-point representation).
+ */
+export declare function fpsqrt(a: bigint, scale: bigint): bigint;
+/** Absolute value of a bigint. */
+export declare function bigintAbs(n: bigint): bigint;
+/** Sign of a bigint: -1n, 0n, or 1n. */
+export declare function bigintSign(n: bigint): bigint;
+/** Count the number of decimal digits in a bigint (absolute value). */
+export declare function bigintDigits(n: bigint): number;
+/**
+ * Fixed-point exponential: compute exp(x/scale) * scale.
+ *
+ * Uses Taylor series with argument reduction (halving) and
+ * repeated squaring to reconstruct the full result.
+ *
+ * @param x  Fixed-point input (represents x/scale)
+ * @param scale  The fixed-point scale (10^precision)
+ * @returns  exp(x/scale) * scale as a bigint
+ */
+export declare function fpexp(x: bigint, scale: bigint): bigint;
+/**
+ * Fixed-point natural logarithm: compute ln(x/scale) * scale.
+ *
+ * Uses Newton's method on f(y) = exp(y) - x, where y = ln(x):
+ *   y_{n+1} = y + x/exp(y) - 1
+ *
+ * Converges quadratically from a double-precision seed.
+ *
+ * @param x  Fixed-point input (represents x/scale), must be positive
+ * @param scale  The fixed-point scale (10^precision)
+ * @returns  ln(x/scale) * scale as a bigint
+ */
+export declare function fpln(x: bigint, scale: bigint): bigint;
+/** PI digits without decimal point (2370 digits). */
+export declare const PI_DIGITS: string;
+/**
+ * Compute sin(x/scale) and cos(x/scale) simultaneously, returning
+ * [sin * scale, cos * scale] as fixed-point bigints.
+ *
+ * Algorithm:
+ * 1. Reduce x mod 2π
+ * 2. Quadrant reduction to [0, π/2]
+ * 3. Double-angle halving until |arg| < scale/2
+ * 4. Taylor series for small arg
+ * 5. Reconstruct via double-angle formulas
+ *
+ * @param x  Fixed-point input (represents x/scale)
+ * @param scale  The fixed-point scale (10^precision)
+ * @returns  [sin(x/scale)*scale, cos(x/scale)*scale]
+ */
+export declare function fpsincos(x: bigint, scale: bigint): [bigint, bigint];
+/**
+ * Compute atan(x/scale) * scale as a fixed-point bigint.
+ *
+ * Algorithm:
+ * 1. Handle sign: atan(-x) = -atan(x)
+ * 2. If |x| > scale (i.e., |x/scale| > 1): atan(x) = π/2 - atan(scale²/x)
+ * 3. Halving: if |x| > 0.4*scale, use atan(x) = 2·atan(x / (1 + sqrt(scale² + x²)))
+ * 4. Taylor series: atan(r) = r - r³/3 + r⁵/5 - ...
+ *
+ * @param x  Fixed-point input (represents x/scale)
+ * @param scale  The fixed-point scale (10^precision)
+ * @returns  atan(x/scale) * scale
+ */
+export declare function fpatan(x: bigint, scale: bigint): bigint;

package/dist/types/common/ansi-codes.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 export declare const DEFAULT_COLOR = "\u001B[39m";
 export declare const DEFAULT_BG = "\u001B[49m";
 export declare const WHITE_BG = "\u001B[47m";

package/dist/types/common/configuration-change.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
     private _listeners;
     private _pending;
     private _version;

package/dist/types/common/fuzzy-string-match.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.0 */
+/* 0.55.0 */
 export declare function fuzzyStringMatch(invalidWord: string, validWords: string[]): string | null;

package/dist/types/common/grapheme-splitter.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 /**
  * Return a string or an array of graphemes.
  *

package/dist/types/common/interruptible.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
     cause: unknown;
     value: T;
     constructor({ message, value, cause, }?: {

package/dist/types/common/one-of.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
     infer Head,
     ...infer Rem
 ] ? MergeTypes<Rem, Res & Head> : Res;

package/dist/types/common/signals.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 export type RuntimeSignalCode = 'timeout' | 'out-of-memory' | 'recursion-depth-exceeded' | 'iteration-limit-exceeded';
 /** @category Error Handling */
 export type SignalCode = RuntimeSignalCode | ('invalid-name' | 'expected-predicate' | 'expected-symbol' | 'operator-requires-one-operand' | 'postfix-operator-requires-one-operand' | 'prefix-operator-requires-one-operand' | 'unbalanced-symbols' | 'expected-argument' | 'unexpected-command' | 'cyclic-definition' | 'invalid-supersets' | 'expected-supersets' | 'unknown-domain' | 'duplicate-wikidata' | 'invalid-dictionary-entry' | 'syntax-error');

package/dist/types/common/type/ast-nodes.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
     kind: string;
     position: number;
     line: number;

package/dist/types/common/type/boxed-type.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 /** @category Type */
 export declare class BoxedType {
     static unknown: BoxedType;

package/dist/types/common/type/lexer.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 export interface Token {
     type: TokenType;
     value: string;

package/dist/types/common/type/parse.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 /**
  * BNF grammar for the type parser:
  *

package/dist/types/common/type/parser.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 import { TypeNode } from './ast-nodes';
 import { TypeResolver } from './types';
 export declare class Parser {

package/dist/types/common/type/primitive.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 /** All the types representing numeric values */
 export declare const NUMERIC_TYPES: NumericPrimitiveType[];
 export declare const INDEXED_COLLECTION_TYPES: PrimitiveType[];

package/dist/types/common/type/reduce.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 /**
  * Reduce the input type
  *

package/dist/types/common/type/serialize.d.ts

@@ -1,2 +1,2 @@
-/* 0.54.0 */
+/* 0.55.0 */
 export declare function typeToString(type: Type, precedence?: number): string;

package/dist/types/common/type/subtype.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 /** Return true if lhs is a subtype of rhs */
 export declare function isPrimitiveSubtype(lhs: PrimitiveType, rhs: PrimitiveType): boolean;
 /** Return true if lhs is a subtype of rhs */

package/dist/types/common/type/type-builder.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 import { Type, TypeResolver } from './types';
 export declare class TypeBuilder implements ASTVisitor<Type> {
     private typeResolver;

package/dist/types/common/type/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
  * A primitive type is a simple type that represents a concrete value.
  *
  * - `any`: the top type

package/dist/types/common/type/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 export { isValidType };
 export { widen, narrow } from './subtype';
 import type { Type, FunctionSignature, TypeString } from './types';

package/dist/types/common/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
  *
  * <!--
  * !@consider?

package/dist/types/compile.d.ts

@@ -0,0 +1,10 @@
+/* 0.55.0 */
+export { compile } from './compute-engine/compilation/compile-expression';
+export { JavaScriptTarget } from './compute-engine/compilation/javascript-target';
+export { GPUShaderTarget } from './compute-engine/compilation/gpu-target';
+export { GLSLTarget } from './compute-engine/compilation/glsl-target';
+export { WGSLTarget } from './compute-engine/compilation/wgsl-target';
+export { PythonTarget } from './compute-engine/compilation/python-target';
+export { IntervalJavaScriptTarget } from './compute-engine/compilation/interval-javascript-target';
+export { BaseCompiler } from './compute-engine/compilation/base-compiler';
+export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompilationResult, ExecutableTarget, ComplexResult, CompiledRunner, ExpressionRunner, LambdaRunner, LanguageTarget, TargetSource, CompiledFunction, } from './compute-engine/compilation/types';

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

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 /**
  * Add an assumption, in the form of a predicate, for example:
  *

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

@@ -1,11 +1,10 @@
-/* 0.54.0 */
+/* 0.55.0 */
 import type { MathJsonExpression, MathJsonSymbol } from '../../math-json/types';
 import type { Type, TypeString } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';
 import type { BoxedSubstitution, Metadata, Substitution, CanonicalOptions, BoxedRuleSet, Rule, BoxedBaseDefinition, BoxedValueDefinition, BoxedOperatorDefinition, EvaluateOptions, ExpressionInput, Sign, Expression, JsonSerializationOptions, PatternMatchOptions, SimplifyOptions, IComputeEngine as ComputeEngine, Scope, Tensor, TensorDataType } from '../global-types';
 import type { NumericValue } from '../numeric-value/types';
 import type { SmallInteger } from '../numerics/types';
-import type { LatexString, SerializeLatexOptions } from '../latex-syntax/types';
 type SerializeJsonFn = (ce: ComputeEngine, expr: Expression, options: Readonly<JsonSerializationOptions>) => MathJsonExpression;
 /** @internal */
 export declare function _setSerializeJson(fn: SerializeJsonFn): void;
@@ -49,14 +48,54 @@ export declare abstract class _BoxedExpression implements Expression {
     [Symbol.toPrimitive](hint: 'number' | 'string' | 'default'): number | string | null;
     /** Object.toString() */
     toString(): string;
-    toLatex(options?: Partial<SerializeLatexOptions>): LatexString;
-    get latex(): LatexString;
+    /**
+     * Return a LaTeX representation of this expression.
+     *
+     * This is a convenience getter that delegates to the standalone
+     * `serialize()` function from the `latex-syntax` module.
+     *
+     * Uses `toMathJson()` (not `.json`) so that the serialized form
+     * reflects the canonical/simplified structure, matching the behavior
+     * of the engine-based serializer.
+     *
+     * Numeric values are rounded to `ce.precision` significant digits
+     * (via `fractionalDigits: 'auto'`). This ensures that noise digits
+     * from precision-bounded operations are not displayed.
+     */
+    get latex(): string;
+    /**
+     * Return a LaTeX representation of this expression with custom
+     * serialization options.
+     *
+     * This delegates to `LatexSyntax.serialize()` with the provided options.
+     * Uses `toMathJson()` to get the canonical/simplified form.
+     *
+     * Numeric values are rounded to `ce.precision` significant digits
+     * (via `fractionalDigits: 'auto'`).
+     */
+    toLatex(options?: Record<string, any>): string;
     /** Called by `JSON.stringify()` when serializing to json.
      *
      * Note: this is a standard method of JavaScript objects.
      *
+     * Returns the full raw value with no precision rounding, identical to
+     * `.json`. This preserves data fidelity for lossless round-tripping.
+     * For precision-rounded MathJSON, use
+     * `toMathJson({ fractionalDigits: 'auto' })`.
      */
     toJSON(): MathJsonExpression;
+    /**
+     * Serialize to MathJSON with configurable options.
+     *
+     * The `fractionalDigits` option controls how many digits are emitted
+     * for arbitrary-precision numbers:
+     * - `'max'` (default): all available digits, no rounding
+     * - `'auto'`: round to `ce.precision` significant digits
+     * - `n` (number >= 0): exactly `n` digits after the decimal point
+     *
+     * Internally, `'auto'` is converted to `-ce.precision` to signal
+     * total significant digits (negative value) to the serializer.
+     */
     toMathJson(options?: Readonly<Partial<JsonSerializationOptions>>): MathJsonExpression;
     print(): void;
     get isStructural(): boolean;
@@ -72,8 +111,8 @@ export declare abstract class _BoxedExpression implements Expression {
     get isOdd(): boolean | undefined;
     get re(): number;
     get im(): number;
-    get bignumRe(): Decimal | undefined;
-    get bignumIm(): Decimal | undefined;
+    get bignumRe(): BigDecimal | undefined;
+    get bignumIm(): BigDecimal | undefined;
     get sgn(): Sign | undefined;
     get isPositive(): boolean | undefined;
     get isNonNegative(): boolean | undefined;

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

@@ -1,5 +1,5 @@
-/* 0.54.0 */
-import { Decimal } from 'decimal.js';
+/* 0.55.0 */
+import { BigDecimal } from '../../big-decimal';
 import type { Expression } from '../global-types';
-export declare function apply(expr: Expression, fn: (x: number) => number | Complex, bigFn?: (x: Decimal) => Decimal | Complex | number, complexFn?: (x: Complex) => number | Complex): Expression | undefined;
-export declare function apply2(expr1: Expression, expr2: Expression, fn: (x1: number, x2: number) => number | Complex, bigFn?: (x1: Decimal, x2: Decimal) => Decimal | Complex | number, complexFn?: (x1: Complex, x2: number | Complex) => Complex | number): Expression | undefined;
+export declare function apply(expr: Expression, fn: (x: number) => number | Complex, bigFn?: (x: BigDecimal) => BigDecimal | Complex | number, complexFn?: (x: Complex) => number | Complex): Expression | undefined;
+export declare function apply2(expr1: Expression, expr2: Expression, fn: (x1: number, x2: number) => number | Complex, bigFn?: (x1: BigDecimal, x2: BigDecimal) => BigDecimal | Complex | number, complexFn?: (x1: Complex, x2: number | Complex) => Complex | number): Expression | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 import { BoxedType } from '../../common/type/boxed-type';
 import type { Expression, IComputeEngine as ComputeEngine } from '../global-types';
 /**

package/dist/types/compute-engine/boxed-expression/arithmetic-mul-div.d.ts

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 import { NumericValue } from '../numeric-value/types';
 import type { Rational } from '../numerics/types';
 /**

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

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 import type { Rational } from '../numerics/types';
 export declare function asRadical(expr: Expression): Rational | null;
 /**

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

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 export type AsciiMathSerializer = (expr: Expression, precedence?: number) => string;
 export type AsciiMathOptions = {
     symbols: Record<string, string>;

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

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 import type { FormOption } from '../types-serialization';
 import type { MathJsonSymbol } from '../../math-json/types';
 import { NumericValue } from '../numeric-value/types';
@@ -91,7 +91,7 @@ export declare function boxFunction(ce: ComputeEngine, name: MathJsonSymbol, ops
  *     Note that `Negate` is only distributed over addition. In practice, having
  * `Negate` factored on multiply/divide is more useful to detect patterns.
  *
- * Note that this function should only be called from `ce.box()`
+ * Note that this function should only be called from `ce.expr()`
  *
  */
 export declare function box(ce: ComputeEngine, expr: null | undefined | NumericValue | ExpressionInput, options?: {

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

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedType } from '../../common/type/boxed-type';
 import { DictionaryValue, MathJsonExpression } from '../../math-json/types';

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

@@ -1,4 +1,4 @@
-/* 0.54.0 */
+/* 0.55.0 */
 import type { SimplifyOptions, ReplaceOptions, PatternMatchOptions, Expression, BoxedBaseDefinition, BoxedOperatorDefinition, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, EvaluateOptions, IComputeEngine as ComputeEngine, Metadata, Rule, Sign, Substitution, Scope, BoxedValueDefinition, ExpressionInput, FunctionInterface } from '../global-types';
 import { Type } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';