fixed #287

Author: arnog

CHANGELOG.md

@@ -1,3 +1,22 @@
+## [Unreleased]
+
+### Numerics
+
+- **\[#287\](https://github.com/cortex-js/compute-engine/issues/287) Improved
+  precision for large integer products**: Multiplications and additions of large
+  integers that would previously lose precision (exceeding
+  `Number.MAX_SAFE_INTEGER`) are now automatically promoted to `BigInt` to
+  maintain exact results.
+
+### Evaluation
+
+- **Fixed scope leak**: Ensured that evaluation contexts are correctly popped
+  even when an error or timeout occurs during function evaluation.
+- **Improved numerical evaluation performance**: `Sum`, `Product`, and `Divide`
+  now correctly propagate the `numericApproximation` option to their arguments,
+  significantly speeding up large numerical calculations by avoiding expensive
+  exact rational arithmetic.
+
 ## 0.50.1 _2026-02-11_
 
 ### Compilation

src/compute-engine/boxed-expression/boxed-function.ts

@@ -1139,12 +1139,16 @@ export class BoxedFunction
       //
       // 6/ Call the `evaluate` handler
       //
-      const evalResult = def.evaluate?.(tail, {
-        numericApproximation,
-        engine: this.engine,
-        materialization: materialization,
-      });
-      if (isScoped) this.engine._popEvalContext();
+      let evalResult: Expression | undefined;
+      try {
+        evalResult = def.evaluate?.(tail, {
+          numericApproximation,
+          engine: this.engine,
+          materialization: materialization,
+        });
+      } finally {
+        if (isScoped) this.engine._popEvalContext();
+      }
 
       // Fallback to a symbolic result if we could not evaluate
       return evalResult ?? this.engine.function(this._operator, tail);

src/compute-engine/library/arithmetic.ts

@@ -323,7 +323,11 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
 
         return result;
       },
-      evaluate: ([num, den]) => num.div(den),
+      evaluate: ([num, den], { numericApproximation }) => {
+        const res = num.div(den);
+        if (numericApproximation && res.operator !== 'Divide') return res.N();
+        return res;
+      },
     },
 
     Exp: {
@@ -1787,11 +1791,13 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
 
       evaluate: (ops, options) => {
         const ce = options.engine;
+        const numericApproximation = options.numericApproximation;
         const result = run(
           reduceBigOp(
             ops[0],
             ops.slice(1),
-            (acc: Expression, x) => acc.mul(x.evaluate(options)),
+            (acc: Expression, x) =>
+              acc.mul(x.evaluate({ numericApproximation })),
             ce.One
           ),
           ce._timeRemaining
@@ -1801,16 +1807,18 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
           return undefined; // Return undefined to keep expression symbolic
         }
         // Evaluate the accumulated result to combine numeric factors
-        return result?.evaluate() ?? ce.NaN;
+        return result?.evaluate({ numericApproximation }) ?? ce.NaN;
       },
 
       evaluateAsync: async (ops, options) => {
         const ce = options.engine;
+        const numericApproximation = options.numericApproximation;
         const result = await runAsync(
           reduceBigOp(
             ops[0],
             ops.slice(1),
-            (acc: Expression, x) => acc.mul(x.evaluate(options)),
+            (acc: Expression, x) =>
+              acc.mul(x.evaluate({ numericApproximation })),
             ce.One
           ),
           ce._timeRemaining,
@@ -1820,7 +1828,7 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
         if (result === NON_ENUMERABLE_DOMAIN) {
           return undefined; // Return undefined to keep expression symbolic
         }
-        return result?.evaluate() ?? ce.NaN;
+        return result?.evaluate({ numericApproximation }) ?? ce.NaN;
       },
     },
 
@@ -1837,12 +1845,13 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
       canonical: ([body, ...bounds], { scope }) =>
         canonicalBigop('Sum', body, bounds, scope),
 
-      evaluate: ([body, ...indexes], { engine }) => {
+      evaluate: ([body, ...indexes], { engine, numericApproximation }) => {
         const result = run(
           reduceBigOp(
             body,
             indexes,
-            (acc: Expression, x) => acc.add(x.evaluate()),
+            (acc: Expression, x) =>
+              acc.add(x.evaluate({ numericApproximation })),
             engine.Zero
           ),
           engine._timeRemaining
@@ -1853,15 +1862,16 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
         }
         // Evaluate the accumulated result to combine numeric terms
         // e.g., 3x + 1 + 2 + 3 → 3x + 6
-        return result?.evaluate() ?? engine.NaN;
+        return result?.evaluate({ numericApproximation }) ?? engine.NaN;
       },
 
-      evaluateAsync: async (xs, { engine, signal }) => {
+      evaluateAsync: async (xs, { engine, signal, numericApproximation }) => {
         const result = await runAsync(
           reduceBigOp(
             xs[0],
             xs.slice(1),
-            (acc: Expression, x) => acc.add(x.evaluate()),
+            (acc: Expression, x) =>
+              acc.add(x.evaluate({ numericApproximation })),
             engine.Zero
           ),
           engine._timeRemaining,
@@ -1871,7 +1881,7 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
         if (result === NON_ENUMERABLE_DOMAIN) {
           return undefined; // Return undefined to keep expression symbolic
         }
-        return result?.evaluate() ?? engine.NaN;
+        return result?.evaluate({ numericApproximation }) ?? engine.NaN;
       },
     },
   },

src/compute-engine/numerics/rationals.ts

@@ -87,12 +87,39 @@ export function add(lhs: Rational, rhs: Rational): Rational {
     const bigRhs = [BigInt(rhsNum[0]), BigInt(rhsNum[1])];
     return [bigRhs[1] * lhs[0] + bigRhs[0] * lhs[1], bigRhs[1] * lhs[1]];
   }
-  return [rhsNum[1] * lhs[0] + rhsNum[0] * lhs[1], rhsNum[1] * lhs[1]];
+
+  const n =
+    (rhsNum[1] as number) * (lhs[0] as number) +
+    (rhsNum[0] as number) * (lhs[1] as number);
+  const d = (rhsNum[1] as number) * (lhs[1] as number);
+
+  if (n <= 9007199254740991 && n >= -9007199254740991 && d <= 9007199254740991)
+    return [n, d];
+
+  if (!Number.isFinite(n) || !Number.isFinite(d)) return [n, d];
+
+  return [
+    BigInt(rhsNum[1]) * BigInt(lhs[0]) + BigInt(rhsNum[0]) * BigInt(lhs[1]),
+    BigInt(rhsNum[1]) * BigInt(lhs[1]),
+  ];
 }
 
 export function mul(lhs: Rational, rhs: Rational): Rational {
-  if (isMachineRational(lhs) && isMachineRational(rhs))
-    return [lhs[0] * rhs[0], lhs[1] * rhs[1]];
+  if (isMachineRational(lhs) && isMachineRational(rhs)) {
+    const n = lhs[0] * rhs[0];
+    const d = lhs[1] * rhs[1];
+    if (
+      n <= 9007199254740991 &&
+      n >= -9007199254740991 &&
+      d <= 9007199254740991
+    )
+      return [n, d];
+
+    if (!Number.isFinite(n) || !Number.isFinite(d)) return [n, d];
+
+    return [BigInt(lhs[0]) * BigInt(rhs[0]), BigInt(lhs[1]) * BigInt(rhs[1])];
+  }
+
   if (isMachineRational(lhs))
     return [
       BigInt(lhs[0]) * (rhs[0] as bigint),

test/compute-engine/arithmetic.test.ts

@@ -710,10 +710,17 @@ describe('SUM', () => {
   it('should compute the sum of a function over an open interval', () =>
     expect(
       ce
-        .box(['Sum', ['Divide', 1, 'x'], 'x'])
+        .box(['Sum', ['Divide', 1, 'x'], ['Tuple', 'x', 1, 100]])
         .evaluate()
         .toString()
-    ).toMatchInlineSnapshot(`5690887772881993/581432233225878`));
+    ).toMatchInlineSnapshot(
+      `14466636279520351160221518043104131447711/2788815009188499086581352357412492142272`
+    ));
+
+  it('should compute the sum of a function over an open interval numerically', () => {
+    const result = ce.box(['Sum', ['Divide', 1, 'x'], 'x']).N();
+    expect(result.re).toBeCloseTo(9.787606036044382);
+  });
 
   it('should compute the sum of a collection', () =>
     expect(

test/playground.ts

@@ -10,8 +10,11 @@ import { expand } from '../src/compute-engine/boxed-expression/expand';
 const ce = new ComputeEngine();
 const engine = ce;
 
-const cr = compile('sin(x)/x', { to: 'interval-wgsl' });
-console.log(cr.code);
+ce.declare('g', 'any');
+ce.assign('g', ce.parse('\\bot'));
+ce.assign('g', ce.parse('x \\mapsto x'));
+ce.assign('g', undefined);
+ce.assign('g', ce.parse('42')); // Error: Cannot change the operator "g" to a value
 
 // 1. sin(theta)**2 + cos(theta)**2 → 1 — Clean trig identity, but too simple.
 // 2. (alpha**2 - beta**2) / (alpha - beta) → didn't simplify. Engine doesn't cancel the