@cortex-js/compute-engine 0.50.1 → 0.50.2

package/dist/compute-engine.umd.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.50.1 */
+/** Compute Engine 0.50.2 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngine = (() => {
   var __defProp = Object.defineProperty;
@@ -6619,14 +6619,15 @@ var ComputeEngine = (() => {
       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;
@@ -6637,7 +6638,9 @@ var ComputeEngine = (() => {
     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;
@@ -11104,11 +11107,25 @@ var ComputeEngine = (() => {
       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],
@@ -14789,8 +14806,7 @@ ${lines.join("\n")}`;
       }
       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);
@@ -14841,7 +14857,10 @@ ${lines.join("\n")}`;
       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
       });
     }
@@ -14850,10 +14869,7 @@ ${lines.join("\n")}`;
         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);
       }
@@ -14882,7 +14898,7 @@ ${lines.join("\n")}`;
       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);
@@ -14905,9 +14921,12 @@ ${lines.join("\n")}`;
       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) {
@@ -14916,7 +14935,7 @@ ${lines.join("\n")}`;
         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
         });
       }
@@ -14931,18 +14950,14 @@ ${lines.join("\n")}`;
       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));
@@ -14988,26 +15003,31 @@ ${lines.join("\n")}`;
       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)
           });
         }
       }
@@ -21985,11 +22005,15 @@ ${lines.join("\n")}`;
   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]);
@@ -22291,7 +22315,11 @@ ${lines.join("\n")}`;
           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",
@@ -23474,11 +23502,12 @@ ${lines.join("\n")}`;
         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
@@ -23486,15 +23515,16 @@ ${lines.join("\n")}`;
           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,
@@ -23503,7 +23533,7 @@ ${lines.join("\n")}`;
           if (result === NON_ENUMERABLE_DOMAIN) {
             return void 0;
           }
-          return result?.evaluate() ?? ce.NaN;
+          return result?.evaluate({ numericApproximation: numericApproximation2 }) ?? ce.NaN;
         }
       },
       Sum: {
@@ -23515,12 +23545,12 @@ ${lines.join("\n")}`;
         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
@@ -23528,14 +23558,14 @@ ${lines.join("\n")}`;
           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,
@@ -23544,7 +23574,7 @@ ${lines.join("\n")}`;
           if (result === NON_ENUMERABLE_DOMAIN) {
             return void 0;
           }
-          return result?.evaluate() ?? engine.NaN;
+          return result?.evaluate({ numericApproximation: numericApproximation2 }) ?? engine.NaN;
         }
       }
     }
@@ -24254,60 +24284,62 @@ ${lines.join("\n")}`;
     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)
@@ -24361,12 +24393,17 @@ ${lines.join("\n")}`;
     } 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);
@@ -24387,7 +24424,7 @@ ${lines.join("\n")}`;
 |   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()}`
@@ -24430,6 +24467,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) {
@@ -25453,8 +25491,12 @@ ${e.message}`);
     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) {
@@ -25491,40 +25533,44 @@ ${e.message}`);
     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,
@@ -34649,9 +34695,12 @@ ${e.message}`);
         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,
@@ -34660,30 +34709,39 @@ ${e.message}`);
         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,
@@ -34691,12 +34749,15 @@ ${e.message}`);
         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,
@@ -34704,47 +34765,60 @@ ${e.message}`);
         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);
         }
       },
@@ -34753,9 +34827,12 @@ ${e.message}`);
         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.",
@@ -42379,12 +42456,16 @@ Error in definition of "${name}"`,
               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);
       };
     }
@@ -47507,9 +47588,13 @@ Error in definition of "${name}"`,
     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;
     }
@@ -61094,10 +61179,10 @@ ${code}`;
   _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"
   };
   return __toCommonJS(compute_engine_exports);
 })();