@cortex-js/compute-engine 0.50.1 → 0.50.2

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.50.1 */
+/** Compute Engine 0.50.2 */
 
 // node_modules/complex-esm/dist/src/complex.js
 var cosh = Math.cosh || function(x) {
@@ -6558,14 +6558,15 @@ function canonicalInteger(n, exponent) {
     if (result) return result;
   }
   const factors = primeFactors(n);
-  let f = 1;
-  let r = 1;
+  let f = BigInt(1);
+  let r = BigInt(1);
   for (const k of Object.keys(factors)) {
-    const v = parseInt(k);
-    f = f * Math.pow(v, Math.floor(factors[k] / exponent));
-    r = r * Math.pow(v, factors[k] % exponent);
+    const v = BigInt(parseInt(k));
+    const exponentBase = BigInt(exponent);
+    f = f * v ** (BigInt(factors[k]) / exponentBase);
+    r = r * v ** (BigInt(factors[k]) % exponentBase);
   }
-  return [f, r];
+  return [Number(f), Number(r)];
 }
 function gcd(a, b) {
   if (a === 0) return b;
@@ -6576,7 +6577,9 @@ function gcd(a, b) {
   return a < 0 ? -a : a;
 }
 function lcm(a, b) {
-  return a * b / gcd(a, b);
+  if (a === 0 || b === 0) return 0;
+  const res = BigInt(a) * BigInt(b) / BigInt(gcd(a, b));
+  return Number(res);
 }
 function factorial2(n) {
   if (!Number.isInteger(n) || n < 0) return NaN;
@@ -11043,11 +11046,25 @@ function add2(lhs, rhs) {
     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] * lhs[0] + rhsNum[0] * lhs[1];
+  const d = rhsNum[1] * lhs[1];
+  if (n <= 9007199254740991 && n >= -9007199254740991 && d <= 9007199254740991)
+    return [n, d];
+  if (!Number.isFinite(n) || !Number.isFinite(d)) return [NaN, 1];
+  return [
+    BigInt(rhsNum[1]) * BigInt(lhs[0]) + BigInt(rhsNum[0]) * BigInt(lhs[1]),
+    BigInt(rhsNum[1]) * BigInt(lhs[1])
+  ];
 }
 function mul2(lhs, rhs) {
-  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 [NaN, 1];
+    return [BigInt(lhs[0]) * BigInt(rhs[0]), BigInt(lhs[1]) * BigInt(rhs[1])];
+  }
   if (isMachineRational(lhs))
     return [
       BigInt(lhs[0]) * rhs[0],
@@ -14728,8 +14745,7 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
     }
     if (this.radical >= 4) {
       const [factor3, root2] = canonicalInteger(this.radical, 2);
-      if (typeof this.rational[0] === "number") this.rational[0] *= factor3;
-      else this.rational = mul2(this.rational, [factor3, 1]);
+      if (factor3 !== 1) this.rational = mul2(this.rational, [factor3, 1]);
       this.radical = root2;
     }
     this.rational = reducedRational(this.rational);
@@ -14780,7 +14796,10 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
     if (this.isOne) return this;
     if (this.isNegativeOne) return this;
     return this.clone({
-      rational: isMachineRational(this.rational) ? [this.rational[1], this.rational[0] * this.radical] : [this.rational[1], this.rational[0] * BigInt(this.radical)],
+      rational: mul2(
+        [BigInt(this.rational[1]), BigInt(1)],
+        inverse([BigInt(this.rational[0]) * BigInt(this.radical), BigInt(1)])
+      ),
       radical: this.radical
     });
   }
@@ -14789,10 +14808,7 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
       if (other === 0) return this;
       if (Number.isInteger(other) && this.radical === 1)
         return this.clone({
-          rational: isMachineRational(this.rational) ? [this.rational[0] + other * this.rational[1], this.rational[1]] : [
-            this.rational[0] + BigInt(other) * this.rational[1],
-            this.rational[1]
-          ]
+          rational: add2(this.rational, [other, 1])
         });
       return this.factory(this.bignumRe).add(other);
     }
@@ -14821,7 +14837,7 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
     if (typeof other === "number") {
       if (Number.isInteger(other))
         return this.clone({
-          rational: isMachineRational(this.rational) ? [this.rational[0] * other, this.rational[1]] : [this.rational[0] * BigInt(other), this.rational[1]],
+          rational: mul2(this.rational, [other, 1]),
           radical: this.radical
         });
       return this.factory(this.bignumRe).mul(other);
@@ -14844,9 +14860,12 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
     if (this.isOne) return other;
     if (this.isNegativeOne) return other.neg();
     if (!(other instanceof _ExactNumericValue)) return other.mul(this);
+    const radical = BigInt(this.radical) * BigInt(other.radical);
+    if (radical > BigInt(SMALL_INTEGER))
+      return this.factory(this.bignumRe).mul(other);
     return this.clone({
       rational: mul2(this.rational, other.rational),
-      radical: this.radical * other.radical
+      radical: Number(radical)
     });
   }
   div(other) {
@@ -14855,7 +14874,7 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
       if (other === -1) return this.neg();
       if (other === 0) return this.clone(NaN);
       return this.clone({
-        rational: isMachineRational(this.rational) ? [this.rational[0], this.rational[1] * other] : [this.rational[0], this.rational[1] * BigInt(other)],
+        rational: mul2(this.rational, [1, other]),
         radical: this.radical
       });
     }
@@ -14870,18 +14889,14 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
     if (!(other instanceof _ExactNumericValue))
       return this.factory(this.bignumRe).div(other);
     if (other.im !== 0) return this.factory(this.bignumRe).div(other);
-    let rational;
-    if (isMachineRational(this.rational) && isMachineRational(other.rational)) {
-      const [a, b] = this.rational;
-      const [d, e] = other.rational;
-      rational = [a * e, b * d * other.radical];
-    } else {
-      rational = mul2(this.rational, [
-        BigInt(other.rational[1]),
-        BigInt(other.rational[0]) * BigInt(other.radical)
-      ]);
-    }
-    return this.clone({ rational, radical: this.radical * other.radical });
+    const rational = mul2(this.rational, [
+      BigInt(other.rational[1]),
+      BigInt(other.rational[0]) * BigInt(other.radical)
+    ]);
+    const radical = BigInt(this.radical) * BigInt(other.radical);
+    if (radical > BigInt(SMALL_INTEGER))
+      return this.factory(this.bignumRe).div(other);
+    return this.clone({ rational, radical: Number(radical) });
   }
   pow(exponent) {
     console.assert(!Array.isArray(exponent));
@@ -14927,26 +14942,31 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
     if (this.sign < 0) {
       if (Number.isInteger(exponent)) {
         const sign3 = exponent % 2 === 0 ? 1 : -1;
+        const bigExp = BigInt(exponent);
+        const radical = BigInt(this.radical) ** bigExp;
+        if (radical > BigInt(SMALL_INTEGER))
+          return this.factory(this.bignumRe).pow(exponent);
         return this.clone({
-          rational: isMachineRational(this.rational) ? [
-            sign3 * (-this.rational[0]) ** exponent,
-            this.rational[1] ** exponent
-          ] : [
-            BigInt(sign3) * (-this.rational[0]) ** BigInt(exponent),
-            this.rational[1] ** BigInt(exponent)
+          rational: [
+            BigInt(sign3) * (-BigInt(this.rational[0])) ** bigExp,
+            BigInt(this.rational[1]) ** bigExp
           ],
-          radical: this.radical ** exponent
+          radical: Number(radical)
         });
       }
       return this.factory({ im: (-this.re) ** exponent });
     } else {
       if (Number.isInteger(exponent)) {
+        const bigExp = BigInt(exponent);
+        const radical = BigInt(this.radical) ** bigExp;
+        if (radical > BigInt(SMALL_INTEGER))
+          return this.factory(this.bignumRe).pow(exponent);
         return this.clone({
-          rational: isMachineRational(this.rational) ? [this.rational[0] ** exponent, this.rational[1] ** exponent] : [
-            BigInt(this.rational[0]) ** BigInt(exponent),
-            this.rational[1] ** BigInt(exponent)
+          rational: [
+            BigInt(this.rational[0]) ** bigExp,
+            BigInt(this.rational[1]) ** bigExp
           ],
-          radical: this.radical ** exponent
+          radical: Number(radical)
         });
       }
     }
@@ -21924,11 +21944,15 @@ function canonicalIndexingSet(expr) {
 function canonicalBigop(bigOp2, body, indexingSets, scope) {
   const ce = body.engine;
   ce.pushScope(scope);
-  const indexes = indexingSets.map(
-    (x) => canonicalIndexingSet(x) ?? ce.error("missing")
-  );
-  body = body?.canonical ?? ce.error("missing");
-  ce.popScope();
+  let indexes;
+  try {
+    indexes = indexingSets.map(
+      (x) => canonicalIndexingSet(x) ?? ce.error("missing")
+    );
+    body = body?.canonical ?? ce.error("missing");
+  } finally {
+    ce.popScope();
+  }
   if (body.isCollection) {
     if (bigOp2 === "Sum") return ce.box(["Reduce", body, "Add", 0]);
     return ce.box(["Reduce", body, "Multiply", 1]);
@@ -22230,7 +22254,11 @@ var ARITHMETIC_LIBRARY = [
         for (const x of rest) result = canonicalDivide(result, x);
         return result;
       },
-      evaluate: ([num, den]) => num.div(den)
+      evaluate: ([num, den], { numericApproximation: numericApproximation2 }) => {
+        const res = num.div(den);
+        if (numericApproximation2 && res.operator !== "Divide") return res.N();
+        return res;
+      }
     },
     Exp: {
       wikidata: "Q168698",
@@ -23413,11 +23441,12 @@ var ARITHMETIC_LIBRARY = [
       canonical: ([body, ...bounds], { scope }) => canonicalBigop("Product", body, bounds, scope),
       evaluate: (ops, options) => {
         const ce = options.engine;
+        const numericApproximation2 = options.numericApproximation;
         const result = run(
           reduceBigOp(
             ops[0],
             ops.slice(1),
-            (acc, x) => acc.mul(x.evaluate(options)),
+            (acc, x) => acc.mul(x.evaluate({ numericApproximation: numericApproximation2 })),
             ce.One
           ),
           ce._timeRemaining
@@ -23425,15 +23454,16 @@ var ARITHMETIC_LIBRARY = [
         if (result === NON_ENUMERABLE_DOMAIN) {
           return void 0;
         }
-        return result?.evaluate() ?? ce.NaN;
+        return result?.evaluate({ numericApproximation: numericApproximation2 }) ?? ce.NaN;
       },
       evaluateAsync: async (ops, options) => {
         const ce = options.engine;
+        const numericApproximation2 = options.numericApproximation;
         const result = await runAsync(
           reduceBigOp(
             ops[0],
             ops.slice(1),
-            (acc, x) => acc.mul(x.evaluate(options)),
+            (acc, x) => acc.mul(x.evaluate({ numericApproximation: numericApproximation2 })),
             ce.One
           ),
           ce._timeRemaining,
@@ -23442,7 +23472,7 @@ var ARITHMETIC_LIBRARY = [
         if (result === NON_ENUMERABLE_DOMAIN) {
           return void 0;
         }
-        return result?.evaluate() ?? ce.NaN;
+        return result?.evaluate({ numericApproximation: numericApproximation2 }) ?? ce.NaN;
       }
     },
     Sum: {
@@ -23454,12 +23484,12 @@ var ARITHMETIC_LIBRARY = [
       lazy: true,
       signature: "((number) -> number, bounds:tuple+) -> number",
       canonical: ([body, ...bounds], { scope }) => canonicalBigop("Sum", body, bounds, scope),
-      evaluate: ([body, ...indexes], { engine }) => {
+      evaluate: ([body, ...indexes], { engine, numericApproximation: numericApproximation2 }) => {
         const result = run(
           reduceBigOp(
             body,
             indexes,
-            (acc, x) => acc.add(x.evaluate()),
+            (acc, x) => acc.add(x.evaluate({ numericApproximation: numericApproximation2 })),
             engine.Zero
           ),
           engine._timeRemaining
@@ -23467,14 +23497,14 @@ var ARITHMETIC_LIBRARY = [
         if (result === NON_ENUMERABLE_DOMAIN) {
           return void 0;
         }
-        return result?.evaluate() ?? engine.NaN;
+        return result?.evaluate({ numericApproximation: numericApproximation2 }) ?? engine.NaN;
       },
-      evaluateAsync: async (xs, { engine, signal }) => {
+      evaluateAsync: async (xs, { engine, signal, numericApproximation: numericApproximation2 }) => {
         const result = await runAsync(
           reduceBigOp(
             xs[0],
             xs.slice(1),
-            (acc, x) => acc.add(x.evaluate()),
+            (acc, x) => acc.add(x.evaluate({ numericApproximation: numericApproximation2 })),
             engine.Zero
           ),
           engine._timeRemaining,
@@ -23483,7 +23513,7 @@ var ARITHMETIC_LIBRARY = [
         if (result === NON_ENUMERABLE_DOMAIN) {
           return void 0;
         }
-        return result?.evaluate() ?? engine.NaN;
+        return result?.evaluate({ numericApproximation: numericApproximation2 }) ?? engine.NaN;
       }
     }
   }
@@ -24193,60 +24223,62 @@ function parseRule(ce, rule, options) {
   if (systemScope) {
     ce.pushScope({ parent: systemScope, bindings: /* @__PURE__ */ new Map() });
   }
-  const expr = ce.parse(rule);
-  ce.latexDictionary = previousDictionary;
-  if (!expr.isValid || expr.operator !== "Rule") {
-    if (systemScope) {
-      ce.popScope();
-    }
-    throw new Error(
-      `Invalid rule "${rule}"
+  let expr;
+  try {
+    expr = ce.parse(rule);
+    ce.latexDictionary = previousDictionary;
+    if (!expr.isValid || expr.operator !== "Rule") {
+      throw new Error(
+        `Invalid rule "${rule}"
 |   ${dewildcard(expr).toString()}
 |   A rule should be of the form:
 |   <match> -> <replace>; <condition>`
-    );
-  }
-  if (!isFunction2(expr)) {
-    if (systemScope) {
-      ce.popScope();
+      );
     }
-    throw new Error(`Invalid rule "${rule}"`);
-  }
-  const [match_, replace_, condition] = expr.ops;
-  let match2 = match_;
-  let replace2 = replace_;
-  if (canonical2) {
-    match2 = match2.canonical;
-    replace2 = replace2.canonical;
-  }
-  if (systemScope) {
-    ce.popScope();
-  }
-  if (!includesWildcards(replace2, match2))
-    throw new Error(
-      `Invalid rule "${rule}"
+    if (!isFunction2(expr)) {
+      throw new Error(`Invalid rule "${rule}"`);
+    }
+    const [match_, replace_, condition] = expr.ops;
+    let match2 = match_;
+    let replace2 = replace_;
+    if (canonical2) {
+      match2 = match2.canonical;
+      replace2 = replace2.canonical;
+    }
+    if (!includesWildcards(replace2, match2))
+      throw new Error(
+        `Invalid rule "${rule}"
 |   The replace expression contains wildcards not present in the match expression`
-    );
-  if (match2.isSame(replace2)) {
-    throw new Error(
-      `Invalid rule "${rule}"
-|   The match and replace expressions are the same.
-|   This may be because the rule is not necessary due to canonical simplification`
-    );
-  }
-  let condFn = void 0;
-  if (condition !== void 0) {
-    if (!includesWildcards(condition, match2))
+      );
+    if (match2.isSame(replace2)) {
       throw new Error(
         `Invalid rule "${rule}"
-|   The condition expression contains wildcards not present in the match expression`
+|   The match and replace expressions are the same.
+|   This may be because the rule is not necessary due to canonical simplification`
       );
-    condFn = (sub3) => {
-      const evaluated = condition.subs(sub3).canonical.evaluate();
-      return isSymbol2(evaluated) && evaluated.symbol === "True";
-    };
+    }
+    let condFn = void 0;
+    if (condition !== void 0) {
+      if (!includesWildcards(condition, match2))
+        throw new Error(
+          `Invalid rule "${rule}"
+|   The condition expression contains wildcards not present in the match expression`
+        );
+      condFn = (sub3) => {
+        const evaluated = condition.subs(sub3).canonical.evaluate();
+        return isSymbol2(evaluated) && evaluated.symbol === "True";
+      };
+    }
+    return boxRule(
+      ce,
+      { match: match2, replace: replace2, condition: condFn, id: rule },
+      options
+    );
+  } finally {
+    if (systemScope) {
+      ce.popScope();
+    }
   }
-  return boxRule(ce, { match: match2, replace: replace2, condition: condFn, id: rule }, options);
 }
 function boxRule(ce, rule, options) {
   if (rule === void 0 || rule === null)
@@ -24300,12 +24332,17 @@ function boxRule(ce, rule, options) {
   } else {
     ce.pushScope();
   }
-  const matchExpr = parseRulePart(ce, match2, {
-    canonical: false,
-    autoWildcard: false
-  });
-  const replaceExpr = parseRulePart(ce, replace2, options);
-  ce.popScope();
+  let matchExpr;
+  let replaceExpr;
+  try {
+    matchExpr = parseRulePart(ce, match2, {
+      canonical: false,
+      autoWildcard: false
+    });
+    replaceExpr = typeof replace2 === "function" ? replace2 : parseRulePart(ce, replace2, options);
+  } finally {
+    ce.popScope();
+  }
   if (!id) {
     if (typeof match2 === "string") id = match2;
     else id = JSON.stringify(match2, void 0, 4);
@@ -24326,7 +24363,7 @@ function boxRule(ce, rule, options) {
 |   the match expression is not valid: ${matchExpr.toString()}`
     );
   }
-  if (replaceExpr && !replaceExpr.isValid) {
+  if (replaceExpr && typeof replaceExpr !== "function" && !replaceExpr.isValid) {
     throw new Error(
       `Invalid rule ${id ?? JSON.stringify(rule, void 0, 4)}
 |   The replace expression is not valid: ${replaceExpr?.toString()}`
@@ -24369,6 +24406,7 @@ ${e.message}
   return { rules };
 }
 function applyRule(rule, expr, substitution, options) {
+  if (!rule) return null;
   let canonical2 = options?.canonical ?? (expr.isCanonical || expr.isStructural);
   let operandsMatched = false;
   if (isFunction2(expr) && options?.recursive) {
@@ -25392,8 +25430,12 @@ function solveNestedSqrtEquation(expr, variable) {
   const uEquation = substitutedArg.sub(aSquared).simplify();
   ce.pushScope();
   ce.declare(uSymbolName, { type: "real" });
-  const uSolutions = findUnivariateRoots(uEquation, uSymbolName);
-  ce.popScope();
+  let uSolutions;
+  try {
+    uSolutions = findUnivariateRoots(uEquation, uSymbolName);
+  } finally {
+    ce.popScope();
+  }
   if (uSolutions.length === 0) return null;
   const xSolutions = [];
   for (const uVal of uSolutions) {
@@ -25430,40 +25472,44 @@ function findUnivariateRoots(expr, x) {
   const rules = ce.getRuleSet("solve-univariate");
   let exprs = [expr.subs({ [x]: "_x" }, { canonical: false })];
   ce.pushScope();
-  const varType = ce.symbol(x).type.type;
-  ce.declare("_x", typeof varType === "string" ? varType : "number");
-  let result = exprs.flatMap(
-    (expr2) => matchAnyRules(
-      expr2,
-      rules,
-      { _x: ce.symbol("_x") },
-      { useVariations: true, canonical: true }
-    )
-  );
-  if (result.length === 0) {
-    exprs = exprs.flatMap((expr2) => harmonize(expr2));
-    result = exprs.flatMap(
-      (expr2) => matchAnyRules(
-        expr2,
-        rules,
-        { _x: ce.symbol(x) },
-        { useVariations: true, canonical: true }
-      )
-    );
-  }
-  if (result.length === 0) {
-    exprs = exprs.flatMap((expr2) => expand2(expr2.canonical)).filter((x2) => x2 !== null);
-    exprs = exprs.flatMap((expr2) => harmonize(expr2));
+  let result = [];
+  try {
+    const varType = ce.symbol(x).type.type;
+    ce.declare("_x", typeof varType === "string" ? varType : "number");
     result = exprs.flatMap(
       (expr2) => matchAnyRules(
         expr2,
         rules,
-        { _x: ce.symbol(x) },
+        { _x: ce.symbol("_x") },
         { useVariations: true, canonical: true }
       )
     );
+    if (result.length === 0) {
+      exprs = exprs.flatMap((expr2) => harmonize(expr2));
+      result = exprs.flatMap(
+        (expr2) => matchAnyRules(
+          expr2,
+          rules,
+          { _x: ce.symbol(x) },
+          { useVariations: true, canonical: true }
+        )
+      );
+    }
+    if (result.length === 0) {
+      exprs = exprs.flatMap((expr2) => expand2(expr2.canonical)).filter((x2) => x2 !== null);
+      exprs = exprs.flatMap((expr2) => harmonize(expr2));
+      result = exprs.flatMap(
+        (expr2) => matchAnyRules(
+          expr2,
+          rules,
+          { _x: ce.symbol(x) },
+          { useVariations: true, canonical: true }
+        )
+      );
+    }
+  } finally {
+    ce.popScope();
   }
-  ce.popScope();
   const validatedRoots = validateRoots(
     originalExpr,
     x,
@@ -34588,9 +34634,12 @@ var STATISTICS_LIBRARY = [
       signature: "((collection|number)+) -> number",
       type: () => "finite_real",
       description: "The most frequently occurring value in the collection.",
-      evaluate: (ops, { engine }) => engine.number(
-        bignumPreferred(engine) ? bigMean(engine.bignum.bind(engine), flattenBigScalars(ops)) : mean(flattenScalars(ops))
-      )
+      evaluate: (ops, { engine, numericApproximation: numericApproximation2 }) => {
+        const xs = ops.map((x) => x.evaluate({ numericApproximation: numericApproximation2 }));
+        return engine.number(
+          bignumPreferred(engine) ? bigMean(engine.bignum.bind(engine), flattenBigScalars(xs)) : mean(flattenScalars(xs))
+        );
+      }
     },
     Median: {
       complexity: 1200,
@@ -34599,30 +34648,39 @@ var STATISTICS_LIBRARY = [
       type: () => "finite_real",
       description: "The most frequently occurring value in the collection.",
       examples: ["Mode([1, 2, 2, 3])  // Returns 2"],
-      evaluate: (ops, { engine }) => engine.number(
-        bignumPreferred(engine) ? bigMedian(flattenBigScalars(ops)) : median(flattenScalars(ops))
-      )
+      evaluate: (ops, { engine, numericApproximation: numericApproximation2 }) => {
+        const xs = ops.map((x) => x.evaluate({ numericApproximation: numericApproximation2 }));
+        return engine.number(
+          bignumPreferred(engine) ? bigMedian(flattenBigScalars(xs)) : median(flattenScalars(xs))
+        );
+      }
     },
     Variance: {
       complexity: 1200,
       broadcastable: false,
       signature: "((collection|number)+) -> number",
       type: () => "finite_real",
-      evaluate: (ops, { engine }) => engine.number(
-        bignumPreferred(engine) ? bigVariance(engine.bignum.bind(engine), flattenBigScalars(ops)) : variance(flattenScalars(ops))
-      )
+      evaluate: (ops, { engine, numericApproximation: numericApproximation2 }) => {
+        const xs = ops.map((x) => x.evaluate({ numericApproximation: numericApproximation2 }));
+        return engine.number(
+          bignumPreferred(engine) ? bigVariance(engine.bignum.bind(engine), flattenBigScalars(xs)) : variance(flattenScalars(xs))
+        );
+      }
     },
     PopulationVariance: {
       complexity: 1200,
       broadcastable: false,
       signature: "((collection|number)+) -> number",
       type: () => "finite_real",
-      evaluate: (ops, { engine }) => engine.number(
-        bignumPreferred(engine) ? bigPopulationVariance(
-          engine.bignum.bind(engine),
-          flattenBigScalars(ops)
-        ) : populationVariance(flattenScalars(ops))
-      )
+      evaluate: (ops, { engine, numericApproximation: numericApproximation2 }) => {
+        const xs = ops.map((x) => x.evaluate({ numericApproximation: numericApproximation2 }));
+        return engine.number(
+          bignumPreferred(engine) ? bigPopulationVariance(
+            engine.bignum.bind(engine),
+            flattenBigScalars(xs)
+          ) : populationVariance(flattenScalars(xs))
+        );
+      }
     },
     StandardDeviation: {
       complexity: 1200,
@@ -34630,12 +34688,15 @@ var STATISTICS_LIBRARY = [
       description: "Sample Standard Deviation of a collection of numbers.",
       signature: "((collection|number)+) -> number",
       type: () => "finite_real",
-      evaluate: (ops, { engine }) => engine.number(
-        bignumPreferred(engine) ? bigVariance(
-          engine.bignum.bind(engine),
-          flattenBigScalars(ops)
-        ).sqrt() : Math.sqrt(variance(flattenScalars(ops)))
-      )
+      evaluate: (ops, { engine, numericApproximation: numericApproximation2 }) => {
+        const xs = ops.map((x) => x.evaluate({ numericApproximation: numericApproximation2 }));
+        return engine.number(
+          bignumPreferred(engine) ? bigVariance(
+            engine.bignum.bind(engine),
+            flattenBigScalars(xs)
+          ).sqrt() : Math.sqrt(variance(flattenScalars(xs)))
+        );
+      }
     },
     PopulationStandardDeviation: {
       complexity: 1200,
@@ -34643,47 +34704,60 @@ var STATISTICS_LIBRARY = [
       description: "Population Standard Deviation of a collection of numbers.",
       signature: "((collection|number)+) -> number",
       type: () => "finite_real",
-      evaluate: (ops, { engine }) => engine.number(
-        bignumPreferred(engine) ? bigPopulationVariance(
-          engine.bignum.bind(engine),
-          flattenBigScalars(ops)
-        ).sqrt() : Math.sqrt(populationVariance(flattenScalars(ops)))
-      )
+      evaluate: (ops, { engine, numericApproximation: numericApproximation2 }) => {
+        const xs = ops.map((x) => x.evaluate({ numericApproximation: numericApproximation2 }));
+        return engine.number(
+          bignumPreferred(engine) ? bigPopulationVariance(
+            engine.bignum.bind(engine),
+            flattenBigScalars(xs)
+          ).sqrt() : Math.sqrt(populationVariance(flattenScalars(xs)))
+        );
+      }
     },
     Kurtosis: {
       complexity: 1200,
       broadcastable: false,
       signature: "((collection|number)+) -> number",
       type: () => "finite_real",
-      evaluate: (ops, { engine }) => engine.number(
-        bignumPreferred(engine) ? bigKurtosis(engine.bignum.bind(engine), flattenBigScalars(ops)) : kurtosis(flattenScalars(ops))
-      )
+      evaluate: (ops, { engine, numericApproximation: numericApproximation2 }) => {
+        const xs = ops.map((x) => x.evaluate({ numericApproximation: numericApproximation2 }));
+        return engine.number(
+          bignumPreferred(engine) ? bigKurtosis(engine.bignum.bind(engine), flattenBigScalars(xs)) : kurtosis(flattenScalars(xs))
+        );
+      }
     },
     Skewness: {
       complexity: 1200,
       broadcastable: false,
       signature: "((collection|number)+) -> number",
       type: () => "finite_real",
-      evaluate: (ops, { engine }) => engine.number(
-        bignumPreferred(engine) ? bigSkewness(engine.bignum.bind(engine), flattenBigScalars(ops)) : skewness(flattenScalars(ops))
-      )
+      evaluate: (ops, { engine, numericApproximation: numericApproximation2 }) => {
+        const xs = ops.map((x) => x.evaluate({ numericApproximation: numericApproximation2 }));
+        return engine.number(
+          bignumPreferred(engine) ? bigSkewness(engine.bignum.bind(engine), flattenBigScalars(xs)) : skewness(flattenScalars(xs))
+        );
+      }
     },
     Mode: {
       complexity: 1200,
       broadcastable: false,
       signature: "((collection|number)+) -> number",
       type: () => "finite_real",
-      evaluate: (ops, { engine }) => engine.number(
-        bignumPreferred(engine) ? bigMode(engine.bignum.bind(engine), flattenBigScalars(ops)) : mode(flattenScalars(ops))
-      )
+      evaluate: (ops, { engine, numericApproximation: numericApproximation2 }) => {
+        const xs = ops.map((x) => x.evaluate({ numericApproximation: numericApproximation2 }));
+        return engine.number(
+          bignumPreferred(engine) ? bigMode(engine.bignum.bind(engine), flattenBigScalars(xs)) : mode(flattenScalars(xs))
+        );
+      }
     },
     Quartiles: {
       complexity: 1200,
       broadcastable: false,
       signature: "((collection|number)+) -> tuple<mid:number, lower:number, upper:number>",
       examples: ["Quartiles([1, 2, 3, 4, 5])  // Returns (3, 2, 4)"],
-      evaluate: (ops, { engine }) => {
-        const [mid, lower, upper] = (bignumPreferred(engine) ? bigQuartiles(flattenBigScalars(ops)) : quartiles(flattenScalars(ops))).map((v) => engine.number(v));
+      evaluate: (ops, { engine, numericApproximation: numericApproximation2 }) => {
+        const xs = ops.map((x) => x.evaluate({ numericApproximation: numericApproximation2 }));
+        const [mid, lower, upper] = (bignumPreferred(engine) ? bigQuartiles(flattenBigScalars(xs)) : quartiles(flattenScalars(xs))).map((v) => engine.number(v));
         return engine.tuple(mid, lower, upper);
       }
     },
@@ -34692,9 +34766,12 @@ var STATISTICS_LIBRARY = [
       broadcastable: false,
       signature: "((collection|number)+) -> number",
       type: () => "finite_real",
-      evaluate: (ops, { engine }) => engine.number(
-        bignumPreferred(engine) ? bigInterquartileRange(flattenBigScalars(ops)) : interquartileRange(flattenScalars(ops))
-      )
+      evaluate: (ops, { engine, numericApproximation: numericApproximation2 }) => {
+        const xs = ops.map((x) => x.evaluate({ numericApproximation: numericApproximation2 }));
+        return engine.number(
+          bignumPreferred(engine) ? bigInterquartileRange(flattenBigScalars(xs)) : interquartileRange(flattenScalars(xs))
+        );
+      }
     },
     Histogram: {
       description: "Compute a histogram of the values in a collection. Returns a list of (bin start, count) tuples.",
@@ -42318,12 +42395,16 @@ var BoxedFunction = class extends _BoxedExpression {
             this.engine.context.values[k] = v;
         }
       }
-      const evalResult = def.evaluate?.(tail, {
-        numericApproximation: numericApproximation2,
-        engine: this.engine,
-        materialization
-      });
-      if (isScoped) this.engine._popEvalContext();
+      let evalResult;
+      try {
+        evalResult = def.evaluate?.(tail, {
+          numericApproximation: numericApproximation2,
+          engine: this.engine,
+          materialization
+        });
+      } finally {
+        if (isScoped) this.engine._popEvalContext();
+      }
       return evalResult ?? this.engine.function(this._operator, tail);
     };
   }
@@ -47446,9 +47527,13 @@ function assignFn(ce, arg1, arg2) {
   const def = ce.lookupDefinition(id);
   if (isOperatorDef(def)) {
     const value2 = assignValueAsValue(ce, arg2);
-    if (value2) throw Error(`Cannot change the operator "${id}" to a value`);
+    if (value2 !== void 0) {
+      updateDef(ce, id, def, { value: value2 });
+      ce._setSymbolValue(id, value2);
+      return ce;
+    }
     const fnDef2 = assignValueAsOperatorDef(ce, arg2);
-    if (!fnDef2) throw Error(`Cannot change the operator "${id}" to a value`);
+    if (!fnDef2) throw Error(`Invalid definition for symbol "${id}"`);
     updateDef(ce, id, def, fnDef2);
     return ce;
   }
@@ -61033,10 +61118,10 @@ var ComputeEngine = class _ComputeEngine {
 _setComputeEngineClass(ComputeEngine);
 
 // src/compute-engine.ts
-var version = "0.50.1";
+var version = "0.50.2";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.50.1"
+  version: "0.50.2"
 };
 export {
   BaseCompiler,