@cortex-js/compute-engine 0.63.0 → 0.64.0

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.63.0 */
+/** Compute Engine 0.64.0 */
 
 // node_modules/complex-esm/dist/src/complex.js
 var cosh = Math.cosh || function(x) {
@@ -5277,7 +5277,6 @@ function bigint(a) {
 }
 
 // src/compute-engine/numerics/primes.ts
-var LARGE_PRIME = 1125899906842597;
 var SMALL_PRIMES = /* @__PURE__ */ new Set([
   2,
   3,
@@ -6324,102 +6323,60 @@ function primeFactors(n) {
   else result[n] = 1;
   return result;
 }
-function isPrime(n) {
-  if (!Number.isInteger(n) || !Number.isFinite(n) || Number.isNaN(n) || n <= 1) {
-    return false;
-  }
-  if (n <= LARGEST_SMALL_PRIME) return SMALL_PRIMES.has(n);
-  for (const smallPrime of SMALL_PRIMES) {
-    if (n % smallPrime === 0) return false;
-  }
-  if (n < LARGE_PRIME) return n === leastFactor(n) || void 0;
-  return probablyPrime(n, 30) ? void 0 : false;
-}
-function leastFactor(n) {
-  if (n === 1) return 1;
-  if (n % 2 === 0) return 2;
-  if (n % 3 === 0) return 3;
-  if (n % 5 === 0) return 5;
-  const m = Math.floor(Math.sqrt(n));
-  let i = 7;
-  while (i <= m) {
-    if (n % i === 0) return i;
-    if (n % (i + 4) === 0) return i + 4;
-    if (n % (i + 6) === 0) return i + 6;
-    if (n % (i + 10) === 0) return i + 10;
-    if (n % (i + 12) === 0) return i + 12;
-    if (n % (i + 16) === 0) return i + 16;
-    if (n % (i + 22) === 0) return i + 22;
-    if (n % (i + 24) === 0) return i + 24;
-    i += 30;
-  }
-  return n;
-}
+var MILLER_RABIN_THRESHOLD = 1n << 32n;
+var MILLER_RABIN_BASES = [
+  2n,
+  3n,
+  5n,
+  7n,
+  11n,
+  13n,
+  17n,
+  19n,
+  23n,
+  29n,
+  31n,
+  37n
+];
 function isPrimeBigint(n) {
-  if (n <= 1) return false;
-  if (n <= LARGEST_SMALL_PRIME) return isPrime(Number(n));
-  for (const smallPrime of SMALL_PRIMES) {
-    if (n % BigInt(smallPrime) === BigInt(0)) return false;
-  }
-  if (n < LARGE_PRIME) n = leastBigFactor(n);
-  return probablyPrimeBigint(n, 30) ? void 0 : false;
-}
-function leastBigFactor(n) {
-  if (n === BigInt(1)) return BigInt(1);
-  if (n % BigInt(2) === BigInt(0)) return BigInt(2);
-  if (n % BigInt(3) === BigInt(0)) return BigInt(3);
-  if (n % BigInt(5) === BigInt(0)) return BigInt(5);
-  const m = BigInt(Math.floor(Math.sqrt(Number(n))));
-  let i = BigInt(7);
-  while (i <= m) {
-    if (n % i === BigInt(0)) return i;
-    if (n % (i + BigInt(4)) === BigInt(0)) return i + BigInt(4);
-    if (n % (i + BigInt(6)) === BigInt(0)) return i + BigInt(6);
-    if (n % (i + BigInt(10)) === BigInt(0)) return i + BigInt(10);
-    if (n % (i + BigInt(12)) === BigInt(0)) return i + BigInt(12);
-    if (n % (i + BigInt(16)) === BigInt(0)) return i + BigInt(16);
-    if (n % (i + BigInt(22)) === BigInt(0)) return i + BigInt(22);
-    if (n % (i + BigInt(24)) === BigInt(0)) return i + BigInt(24);
-    i += BigInt(30);
+  if (n < 2n) return false;
+  if (n <= LARGEST_SMALL_PRIME) return SMALL_PRIMES.has(Number(n));
+  if (n < MILLER_RABIN_THRESHOLD) {
+    if (n % 2n === 0n || n % 3n === 0n) return false;
+    for (let i = 5n; i * i <= n; i += 6n)
+      if (n % i === 0n || n % (i + 2n) === 0n) return false;
+    return true;
   }
-  return n;
+  return millerRabin(n);
 }
-function probablyPrime(n, k) {
-  let s = 0;
-  let d = n - 1;
-  while (d % 2 === 0) {
-    d /= 2;
-    ++s;
-  }
-  WitnessLoop: do {
-    let x = Math.pow(2 + Math.floor(Math.random() * (n - 3)), d) % n;
-    if (x === 1 || x === n - 1) continue;
-    for (let i = s - 1; i--; ) {
-      x = x * x % n;
-      if (x === 1) return false;
-      if (x === n - 1) continue WitnessLoop;
-    }
-    return false;
-  } while (--k);
-  return true;
+function modPow(base, exp3, mod3) {
+  if (mod3 === 1n) return 0n;
+  let result = 1n;
+  base = (base % mod3 + mod3) % mod3;
+  while (exp3 > 0n) {
+    if (exp3 & 1n) result = result * base % mod3;
+    base = base * base % mod3;
+    exp3 >>= 1n;
+  }
+  return result;
 }
-function probablyPrimeBigint(n, k) {
-  let s = 0;
-  let d = n - BigInt(1);
-  while (d % BigInt(2) === BigInt(0)) {
-    d = d / BigInt(2);
-    ++s;
-  }
-  WitnessLoop: do {
-    let x = BigInt(2 + Math.floor(Math.random() * (Number(n) - 3))) ** d % n;
-    if (x === BigInt(1) || x === n - BigInt(1)) continue;
-    for (let i = s - 1; i--; ) {
+function millerRabin(n) {
+  for (const p of MILLER_RABIN_BASES) if (n % p === 0n) return n === p;
+  let d = n - 1n;
+  let s = 0n;
+  while (d % 2n === 0n) {
+    d /= 2n;
+    s += 1n;
+  }
+  WitnessLoop: for (const a of MILLER_RABIN_BASES) {
+    let x = modPow(a, d, n);
+    if (x === 1n || x === n - 1n) continue;
+    for (let r = 1n; r < s; r++) {
       x = x * x % n;
-      if (x === BigInt(1)) return false;
-      if (x === n - BigInt(1)) continue WitnessLoop;
+      if (x === n - 1n) continue WitnessLoop;
     }
     return false;
-  } while (--k);
+  }
   return true;
 }
 var PRIME_WHEEL_INC = [
@@ -6432,6 +6389,63 @@ var PRIME_WHEEL_INC = [
   BigInt(2),
   BigInt(6)
 ];
+function bigPrimeFactors(d) {
+  if (d < Number.MAX_SAFE_INTEGER) {
+    const factors = primeFactors(Number(d));
+    const result2 = /* @__PURE__ */ new Map();
+    for (const f of Object.keys(factors))
+      result2.set(bigint(f), factors[Number(f)]);
+    return result2;
+  }
+  let n = d;
+  const result = /* @__PURE__ */ new Map();
+  let count2 = 0;
+  let count3 = 0;
+  let count5 = 0;
+  let k = BigInt(10);
+  while (n % k === BigInt(0)) {
+    count2 += 1;
+    count5 += 1;
+    n = n / k;
+  }
+  k = BigInt(5);
+  while (n % k === BigInt(0)) {
+    count5 += 1;
+    n = n / k;
+  }
+  k = BigInt(3);
+  while (n % k === BigInt(0)) {
+    count3 += 1;
+    n = n / k;
+  }
+  k = BigInt(2);
+  while (n % k === BigInt(0)) {
+    count2 += 1;
+    n = n / k;
+  }
+  if (count2 > 0) result.set("2", count2);
+  if (count3 > 0) result.set("3", count3);
+  if (count5 > 0) result.set("5", count5);
+  k = BigInt(7);
+  let kIndex = "";
+  let i = 0;
+  while (k * k < n) {
+    if (n % k === BigInt(0)) {
+      if (!kIndex) kIndex = k.toString();
+      result.set(kIndex, (result.get(kIndex) ?? 0) + 1);
+      n = n / k;
+    } else {
+      k = k + PRIME_WHEEL_INC[i];
+      kIndex = "";
+      i = i < 7 ? i + 1 : 0;
+    }
+  }
+  if (n !== BigInt(1))
+    result.set(n.toString(), (result.get(n.toString()) ?? 0) + 1);
+  const r = /* @__PURE__ */ new Map();
+  for (const [k2, v] of result) r.set(bigint(k2), v);
+  return r;
+}
 
 // src/compute-engine/numerics/numeric.ts
 var DEFAULT_PRECISION = 21;
@@ -25273,7 +25287,11 @@ function asSmallInteger(expr2) {
 function toInteger(expr2) {
   if (!isNumber(expr2)) return null;
   const num = expr2.numericValue;
-  return Math.round(typeof num === "number" ? num : num.re);
+  const re = typeof num === "number" ? num : num.re;
+  if (!Number.isFinite(re)) return null;
+  const n = Math.round(re);
+  if (!Number.isSafeInteger(n)) return null;
+  return n;
 }
 function toBigint(expr2) {
   if (expr2 === void 0 || expr2 === null) return null;
@@ -31892,12 +31910,10 @@ function bigHypergeometric1F1(ce, a, b, z) {
 }
 
 // src/compute-engine/boxed-expression/predicates.ts
-function isPrime2(expr2) {
+function isPrime(expr2) {
   if (!expr2.isInteger) return void 0;
   if (expr2.isNegative) return void 0;
   if (!isNumber(expr2)) return void 0;
-  const n = toInteger(expr2);
-  if (n !== null) return isPrime(n);
   const b = asBigint(expr2);
   if (b !== null) return isPrimeBigint(b);
   return void 0;
@@ -37869,6 +37885,7 @@ var ARITHMETIC_LIBRARY = [
       sgn: ([x]) => x.isNonNegative ? "positive" : x.isNegative || x.isReal === false ? "unsigned" : void 0,
       evaluate: (ops) => {
         const x = ops[0];
+        if (x.isInteger !== true) return void 0;
         const n = toInteger(x);
         if (n === null) return void 0;
         const ce = x.engine;
@@ -38822,7 +38839,7 @@ var ARITHMETIC_LIBRARY = [
       broadcastable: true,
       signature: "(number) -> boolean",
       evaluate: ([n], { engine }) => {
-        const result = isPrime2(n);
+        const result = isPrime(n);
         if (result === void 0) return void 0;
         return engine.symbol(result ? "True" : "False");
       }
@@ -39504,8 +39521,8 @@ var CONDITIONS = {
   nonpositive: (x) => x.isNonPositive,
   even: (x) => x.isEven,
   odd: (x) => x.isOdd,
-  prime: (x) => isPrime2(x) === true,
-  composite: (x) => isPrime2(x) === false,
+  prime: (x) => isPrime(x) === true,
+  composite: (x) => isPrime(x) === false,
   notzero: (x) => x.isSame(0) === false,
   notone: (x) => x.isSame(1) === false,
   finite: (x) => x.isFinite,
@@ -56524,6 +56541,7 @@ var COMBINATORICS_LIBRARY = [
       signature: "(integer) -> integer",
       type: () => "finite_integer",
       evaluate: ([n], { engine: ce }) => {
+        if (n.isInteger !== true) return void 0;
         const k = toInteger(n);
         if (k === null || k < 0) return void 0;
         let result = 1n;
@@ -56541,6 +56559,7 @@ var COMBINATORICS_LIBRARY = [
       signature: "(integer) -> integer",
       type: () => "finite_integer",
       evaluate: ([n], { engine: ce }) => {
+        if (n.isInteger !== true) return void 0;
         const k = toInteger(n);
         if (k === null || k < 0) return void 0;
         let row = [1n];
@@ -58120,17 +58139,35 @@ var CORE_LIBRARY = [
       }
     },
     N: {
-      description: "Numerically evaluate an expression",
+      description: [
+        "N(expr): numerically evaluate an expression",
+        "N(expr, precision): evaluate to `precision` significant digits"
+      ],
       lazy: true,
-      signature: "(any) -> unknown",
+      signature: "(any, integer?) -> unknown",
       type: ([x]) => x.type,
       canonical: (ops, { engine: ce }) => {
-        if (ops.length !== 1) return ce._fn("N", checkArity(ce, ops, 1));
-        const h = ops[0].operator;
-        if (h === "N" || h === "Evaluate") return ops[0].canonical;
+        if (ops.length === 0) return ce._fn("N", checkArity(ce, ops, 1));
+        if (ops.length > 2) return ce._fn("N", checkArity(ce, ops, 2));
+        if (ops.length === 1) {
+          const h = ops[0].operator;
+          if (h === "N" || h === "Evaluate") return ops[0].canonical;
+        }
         return ce._fn("N", ops);
       },
-      evaluate: ([x]) => x.N()
+      evaluate: (ops, { engine: ce }) => {
+        const x = ops[0];
+        if (ops.length < 2) return x.canonical.N();
+        let p = ops[1].canonical.N().re;
+        if (!Number.isFinite(p) || p < 1) return x.canonical.N();
+        p = Math.min(Math.trunc(p), 1e3);
+        const global = ce.precision;
+        if (p > global) {
+          ce.precision = p;
+          return x.canonical.N();
+        }
+        return roundToSignificantDigits(x.canonical.N(), p);
+      }
     },
     Random: {
       description: [
@@ -58635,6 +58672,20 @@ var CORE_LIBRARY = [
     }
   }
 ];
+function roundToSignificantDigits(value, p) {
+  const ce = value.engine;
+  const re = value.re;
+  const im = value.im;
+  if (!Number.isFinite(re) || !Number.isFinite(im)) return value;
+  if (im !== 0) {
+    const clamp2 = Math.min(p, 100);
+    return ce.number(
+      ce.complex(Number(re.toPrecision(clamp2)), Number(im.toPrecision(clamp2)))
+    );
+  }
+  const bd = value.bignumRe ?? ce.bignum(re);
+  return ce.number(bd.toPrecision(p));
+}
 
 // src/compute-engine/library/linear-algebra.ts
 var LINEAR_ALGEBRA_LIBRARY = [
@@ -59093,6 +59144,165 @@ var LINEAR_ALGEBRA_LIBRARY = [
         return void 0;
       }
     },
+    Dot: {
+      description: "Dot product (vector inner product) or matrix product.",
+      complexity: 8300,
+      signature: "(matrix|vector, matrix|vector) -> value",
+      // `Dot` is Mathematica's `.`: it reduces to the inner product for two
+      // vectors and to the matrix product otherwise — exactly what
+      // `MatrixMultiply` already computes.
+      evaluate: (ops, { engine: ce }) => ce.function("MatrixMultiply", ops).evaluate()
+    },
+    MatrixRank: {
+      description: "Rank of a matrix (number of linearly independent rows/columns).",
+      complexity: 8200,
+      signature: "(value) -> integer",
+      sgn: () => "non-negative",
+      evaluate: ([map], { engine: ce }) => {
+        const op = map.evaluate();
+        if (op.isNumber) return ce.number(op.isSame(0) ? 0 : 1);
+        if (!isTensor2(op)) return void 0;
+        const shape = op.shape;
+        if (shape.length > 2) return ce.error("expected-matrix", op.toString());
+        const rowCount = shape.length === 1 ? 1 : shape[0];
+        const columnCount = shape.length === 1 ? shape[0] : shape[1];
+        const matrix = tensorToNumericMatrix(op, rowCount, columnCount);
+        if (!matrix) return void 0;
+        const nullity = computeNullSpaceBasis(matrix).length;
+        return ce.number(columnCount - nullity);
+      }
+    },
+    IsSquareMatrix: {
+      description: "Whether the value is a square matrix.",
+      complexity: 8200,
+      signature: "(value) -> boolean",
+      evaluate: ([m], { engine: ce }) => {
+        const op = m.evaluate();
+        if (!isTensor2(op)) return ce.False;
+        return op.tensor.isSquare ? ce.True : ce.False;
+      }
+    },
+    IsSymmetric: {
+      description: "Whether the matrix is symmetric (A equals its transpose).",
+      complexity: 8200,
+      signature: "(value) -> boolean",
+      evaluate: ([m], { engine: ce }) => {
+        const op = m.evaluate();
+        if (!isTensor2(op)) return ce.False;
+        return op.tensor.isSymmetric ? ce.True : ce.False;
+      }
+    },
+    IsDiagonal: {
+      description: "Whether the matrix is diagonal (all off-diagonal entries are zero).",
+      complexity: 8200,
+      signature: "(value) -> boolean",
+      evaluate: ([m], { engine: ce }) => {
+        const op = m.evaluate();
+        if (!isTensor2(op)) return ce.False;
+        return op.tensor.isDiagonal ? ce.True : ce.False;
+      }
+    },
+    Cross: {
+      description: "Cross product of two 3-vectors.",
+      complexity: 8300,
+      signature: "(vector, vector) -> vector",
+      evaluate: ([a, b], { engine: ce }) => {
+        const A = a.evaluate();
+        const B = b.evaluate();
+        if (!isTensor2(A) || !isTensor2(B)) return void 0;
+        if (A.shape.length !== 1 || A.shape[0] !== 3 || B.shape.length !== 1 || B.shape[0] !== 3)
+          return ce.error(
+            "incompatible-dimensions",
+            "cross product requires two 3-vectors"
+          );
+        const a1 = ce.expr(A.tensor.at(1) ?? ce.Zero);
+        const a2 = ce.expr(A.tensor.at(2) ?? ce.Zero);
+        const a3 = ce.expr(A.tensor.at(3) ?? ce.Zero);
+        const b1 = ce.expr(B.tensor.at(1) ?? ce.Zero);
+        const b2 = ce.expr(B.tensor.at(2) ?? ce.Zero);
+        const b3 = ce.expr(B.tensor.at(3) ?? ce.Zero);
+        return ce.function("List", [
+          a2.mul(b3).sub(a3.mul(b2)),
+          a3.mul(b1).sub(a1.mul(b3)),
+          a1.mul(b2).sub(a2.mul(b1))
+        ]).evaluate();
+      }
+    },
+    MatrixPower: {
+      description: "Square matrix raised to an integer power (repeated matrix product).",
+      complexity: 8300,
+      signature: "(matrix, integer) -> matrix",
+      evaluate: ([mat, exponent], { engine: ce }) => {
+        const A = mat.evaluate();
+        if (!isTensor2(A)) return void 0;
+        if (!A.tensor.isSquare)
+          return ce.error("expected-square-matrix", A.toString());
+        const n = exponent.re;
+        if (n === void 0 || !Number.isInteger(n)) return void 0;
+        const size = A.shape[0];
+        if (n === 0)
+          return ce.function("IdentityMatrix", [ce.number(size)]).evaluate();
+        let base = A;
+        let k = n;
+        if (n < 0) {
+          const inv = ce.function("Inverse", [A]).evaluate();
+          if (!isTensor2(inv)) return inv;
+          base = inv;
+          k = -n;
+        }
+        let result = base;
+        for (let i = 1; i < k; i++)
+          result = ce.function("MatrixMultiply", [result, base]).evaluate();
+        return result;
+      }
+    },
+    CharacteristicPolynomial: {
+      description: "Characteristic polynomial det(x\xB7I \u2212 A) of a square matrix (monic).",
+      complexity: 8700,
+      // The variable is accepted as `any` (not `symbol`): an undeclared symbol
+      // is inferred to have a numeric type, which would fail a `symbol`
+      // signature check. The evaluate handler validates it with `isSymbol`.
+      signature: "(matrix, any?) -> expression",
+      evaluate: ([mat, variable], { engine: ce }) => {
+        const A = mat.evaluate();
+        if (!isTensor2(A)) return void 0;
+        if (!A.tensor.isSquare)
+          return ce.error("expected-square-matrix", A.toString());
+        const x = variable && isSymbol2(variable) ? variable : ce.symbol("x");
+        const n = A.shape[0];
+        const rows = [];
+        for (let i = 0; i < n; i++) {
+          const row = [];
+          for (let j = 0; j < n; j++) {
+            const entry = ce.expr(A.tensor.at(i + 1, j + 1) ?? ce.Zero);
+            row.push(i === j ? x.sub(entry) : entry.neg());
+          }
+          rows.push(ce.function("List", row));
+        }
+        return ce.function("Determinant", [ce.function("List", rows)]).evaluate();
+      }
+    },
+    RowReduce: {
+      description: "Reduced row echelon form (RREF) of a matrix.",
+      complexity: 8200,
+      signature: "(matrix) -> matrix",
+      evaluate: ([m], { engine: ce }) => {
+        const op = m.evaluate();
+        if (!isTensor2(op)) return void 0;
+        const shape = op.shape;
+        if (shape.length !== 2)
+          return ce.error("expected-matrix", op.toString());
+        const matrix = tensorToNumericMatrix(op, shape[0], shape[1]);
+        if (!matrix) return void 0;
+        const { matrix: reduced } = rref(matrix);
+        return ce.expr([
+          "List",
+          ...reduced.map(
+            (row) => ce.expr(["List", ...row.map((value) => ce.number(ce.chop(value)))])
+          )
+        ]);
+      }
+    },
     // Diagonal can be used to:
     // 1. Create a diagonal matrix from a vector
     // 2. Extract the diagonal from a matrix as a vector
@@ -60703,6 +60913,628 @@ var LOGIC_FUNCTION_LIBRARY = {
 // src/compute-engine/library/number-theory.ts
 var NUMBER_THEORY_LIBRARY = [
   {
+    FactorInteger: {
+      description: "Return the prime factorization of an integer `n` as a list of `[prime, exponent]` tuples, ordered by ascending prime. For a negative `n`, a leading `[-1, 1]` tuple carries the sign.",
+      signature: "(integer) -> list<tuple<integer, integer>>",
+      examples: ["FactorInteger(360)  // [(2, 3), (3, 2), (5, 1)]"],
+      evaluate: ([n], { engine: ce }) => {
+        const k = toBigint(n);
+        if (k === null) return void 0;
+        const tuple = (prime, exponent) => ce._fn("Tuple", [ce.number(prime), ce.number(exponent)]);
+        if (k === 0n) return ce.function("List", [tuple(0n, 1)]);
+        if (k === 1n) return ce.function("List", [tuple(1n, 1)]);
+        const result = [];
+        let m = k;
+        if (m < 0n) {
+          result.push(tuple(-1n, 1));
+          m = -m;
+        }
+        if (m > 1n) {
+          const factors = bigPrimeFactors(m);
+          const primes = [...factors.keys()].sort(
+            (a, b) => a < b ? -1 : a > b ? 1 : 0
+          );
+          for (const p of primes) result.push(tuple(p, factors.get(p)));
+        }
+        return ce.function("List", result);
+      }
+    },
+    Divisors: {
+      description: "Return the sorted list of positive divisors of an integer `n`. The sign of `n` is ignored.",
+      signature: "(integer) -> list<integer>",
+      examples: ["Divisors(12)  // [1, 2, 3, 4, 6, 12]"],
+      evaluate: ([n], { engine: ce }) => {
+        const k = toBigint(n);
+        if (k === null) return void 0;
+        const m = k < 0n ? -k : k;
+        if (m === 0n) return void 0;
+        return ce.function(
+          "List",
+          divisorsAscending(m, ce._deadline).map((d) => ce.number(d))
+        );
+      }
+    },
+    NthPrime: {
+      description: "Return the nth prime number (1-based): `NthPrime(1)` is 2, `NthPrime(2)` is 3, \u2026",
+      signature: "(integer) -> integer",
+      type: () => "finite_integer",
+      examples: ["NthPrime(10)  // 29"],
+      evaluate: ([n], { engine: ce }) => {
+        const k = toBigint(n);
+        if (k === null || k < 1n) return void 0;
+        if (k === 1n) return ce.number(2);
+        let count = 1n;
+        let candidate = 1n;
+        let steps = 0;
+        while (count < k) {
+          candidate += 2n;
+          if ((++steps & 1023) === 0) checkDeadline(ce._deadline);
+          if (isPrimeBigint(candidate)) count += 1n;
+        }
+        return ce.number(candidate);
+      }
+    },
+    NextPrime: {
+      description: "Return the smallest prime greater than `n`. With a second argument `k`, return the kth prime after `n` (`k < 0` returns the |k|th prime before `n`).",
+      signature: "(integer, integer?) -> integer",
+      type: () => "finite_integer",
+      examples: ["NextPrime(10)  // 11", "NextPrime(10, -1)  // 7"],
+      evaluate: ([n, kArg], { engine: ce }) => {
+        const start = toBigint(n);
+        if (start === null) return void 0;
+        const k = kArg === void 0 ? 1n : toBigint(kArg);
+        if (k === null || k === 0n) return void 0;
+        let p = start;
+        let steps = 0;
+        if (k > 0n) {
+          for (let i = 0n; i < k; i++) {
+            do {
+              p += 1n;
+              if ((++steps & 1023) === 0) checkDeadline(ce._deadline);
+            } while (!isPrimeBigint(p));
+          }
+        } else {
+          for (let i = 0n; i > k; i--) {
+            do {
+              p -= 1n;
+              if ((++steps & 1023) === 0) checkDeadline(ce._deadline);
+              if (p < 2n) return void 0;
+            } while (!isPrimeBigint(p));
+          }
+        }
+        return ce.number(p);
+      }
+    },
+    PrimeFactors: {
+      description: "Return the sorted list of distinct prime factors of an integer `n`. The sign of `n` is ignored; `PrimeFactors(1)` is the empty list.",
+      signature: "(integer) -> list<integer>",
+      examples: ["PrimeFactors(360)  // [2, 3, 5]"],
+      evaluate: ([n], { engine: ce }) => {
+        const k = toBigint(n);
+        if (k === null) return void 0;
+        const m = k < 0n ? -k : k;
+        if (m === 0n) return void 0;
+        const primes = [...bigPrimeFactors(m).keys()].filter((p) => p !== 1n).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+        return ce.function(
+          "List",
+          primes.map((p) => ce.number(p))
+        );
+      }
+    },
+    PrimeNu: {
+      description: "Return \u03C9(n), the number of distinct prime factors of `n`. The sign of `n` is ignored; `PrimeNu(1)` is 0.",
+      signature: "(integer) -> integer",
+      type: () => "finite_integer",
+      examples: ["PrimeNu(360)  // 3"],
+      evaluate: ([n], { engine: ce }) => {
+        const k = toBigint(n);
+        if (k === null) return void 0;
+        const m = k < 0n ? -k : k;
+        if (m === 0n) return void 0;
+        if (m === 1n) return ce.number(0);
+        return ce.number(bigPrimeFactors(m).size);
+      }
+    },
+    PrimeOmega: {
+      description: "Return \u03A9(n), the number of prime factors of `n` counted with multiplicity. The sign of `n` is ignored; `PrimeOmega(1)` is 0.",
+      signature: "(integer) -> integer",
+      type: () => "finite_integer",
+      examples: ["PrimeOmega(360)  // 6"],
+      evaluate: ([n], { engine: ce }) => {
+        const k = toBigint(n);
+        if (k === null) return void 0;
+        const m = k < 0n ? -k : k;
+        if (m === 0n) return void 0;
+        if (m === 1n) return ce.number(0);
+        let total = 0;
+        for (const e of bigPrimeFactors(m).values()) total += e;
+        return ce.number(total);
+      }
+    },
+    MoebiusMu: {
+      description: "Return the M\xF6bius function \u03BC(n): 0 if `n` is divisible by a perfect square > 1, otherwise (-1) raised to the number of distinct prime factors. The sign of `n` is ignored.",
+      signature: "(integer) -> integer",
+      type: () => "finite_integer",
+      examples: ["MoebiusMu(30)  // -1"],
+      evaluate: ([n], { engine: ce }) => {
+        const k = toBigint(n);
+        if (k === null) return void 0;
+        const m = k < 0n ? -k : k;
+        if (m === 0n) return void 0;
+        if (m === 1n) return ce.number(1);
+        const factors = bigPrimeFactors(m);
+        for (const e of factors.values()) if (e > 1) return ce.number(0);
+        return ce.number(factors.size % 2 === 0 ? 1 : -1);
+      }
+    },
+    IsSquareFree: {
+      description: 'Return `"True"` if `n` is square-free (not divisible by any perfect square > 1). The sign of `n` is ignored.',
+      signature: "(integer) -> boolean",
+      examples: ['IsSquareFree(30)  // "True"'],
+      evaluate: ([n], { engine: ce }) => {
+        const k = toBigint(n);
+        if (k === null) return void 0;
+        const m = k < 0n ? -k : k;
+        if (m === 0n) return ce.False;
+        if (m === 1n) return ce.True;
+        const factors = bigPrimeFactors(m);
+        for (const e of factors.values()) if (e > 1) return ce.False;
+        return ce.True;
+      }
+    },
+    Radical: {
+      description: "Return the radical of `n` (its square-free kernel): the product of its distinct prime factors. The sign of `n` is ignored; `Radical(1)` is 1.",
+      signature: "(integer) -> integer",
+      type: () => "finite_integer",
+      examples: ["Radical(360)  // 30"],
+      evaluate: ([n], { engine: ce }) => {
+        const k = toBigint(n);
+        if (k === null) return void 0;
+        const m = k < 0n ? -k : k;
+        if (m === 0n) return void 0;
+        if (m === 1n) return ce.number(1);
+        let product = 1n;
+        for (const p of bigPrimeFactors(m).keys()) product *= p;
+        return ce.number(product);
+      }
+    },
+    PowerMod: {
+      description: "Return `a^b mod m` (modular exponentiation). A negative `b` uses the modular inverse of `a`; the result is undefined when that inverse does not exist (i.e. when `a` and `m` are not coprime). The result is in the range [0, m).",
+      signature: "(integer, integer, integer) -> integer",
+      type: () => "finite_integer",
+      examples: ["PowerMod(2, 10, 1000)  // 24"],
+      evaluate: ([aOp, bOp, mOp], { engine: ce }) => {
+        const a = toBigint(aOp);
+        const b = toBigint(bOp);
+        const m = toBigint(mOp);
+        if (a === null || b === null || m === null) return void 0;
+        if (m <= 0n) return void 0;
+        if (m === 1n) return ce.number(0);
+        if (b >= 0n) return ce.number(modPow(a, b, m));
+        const base = (a % m + m) % m;
+        const [g, s] = extGcd(base, m);
+        if (g !== 1n) return void 0;
+        const inv = (s % m + m) % m;
+        return ce.number(modPow(inv, -b, m));
+      }
+    },
+    ExtendedGCD: {
+      description: "Return the extended GCD of `a` and `b` as a tuple `(g, x, y)` where `g = gcd(a, b)` is non-negative and `a\xB7x + b\xB7y = g` (B\xE9zout coefficients).",
+      signature: "(integer, integer) -> tuple<integer, integer, integer>",
+      examples: ["ExtendedGCD(12, 18)  // (6, -1, 1)"],
+      evaluate: ([aOp, bOp], { engine: ce }) => {
+        const a = toBigint(aOp);
+        const b = toBigint(bOp);
+        if (a === null || b === null) return void 0;
+        let [g, x, y] = extGcd(a, b);
+        if (g < 0n) {
+          g = -g;
+          x = -x;
+          y = -y;
+        }
+        return ce._fn("Tuple", [ce.number(g), ce.number(x), ce.number(y)]);
+      }
+    },
+    IntegerSqrt: {
+      description: "Return the integer square root of `n`, i.e. the largest integer `m` such that `m\xB2 \u2264 n`. Undefined for negative `n`.",
+      signature: "(integer) -> integer",
+      type: () => "finite_integer",
+      examples: ["IntegerSqrt(17)  // 4"],
+      evaluate: ([n], { engine: ce }) => {
+        const k = toBigint(n);
+        if (k === null || k < 0n) return void 0;
+        return ce.number(bigintSqrt2(k));
+      }
+    },
+    ChineseRemainder: {
+      description: "Solve a system of simultaneous congruences: return the smallest non-negative integer `x` such that `x \u2261 residues[i] (mod moduli[i])` for every `i`. Undefined if the system is inconsistent or the two lists differ in length.",
+      signature: "(collection, collection) -> integer",
+      examples: ["ChineseRemainder([2, 3, 2], [3, 5, 7])  // 23"],
+      evaluate: ([residuesOp, moduliOp], { engine: ce }) => {
+        const residues = Array.from(residuesOp?.each() ?? []).map(toBigint);
+        const moduli = Array.from(moduliOp?.each() ?? []).map(toBigint);
+        if (residues.length === 0 || residues.length !== moduli.length)
+          return void 0;
+        if (residues.includes(null) || moduli.includes(null)) return void 0;
+        const x = chineseRemainder(residues, moduli);
+        if (x === null) return void 0;
+        return ce.number(x);
+      }
+    },
+    CarmichaelLambda: {
+      description: "Return the Carmichael function \u03BB(n) (the reduced totient): the smallest positive integer `m` such that `a^m \u2261 1 (mod n)` for every `a` coprime to `n`. Defined for `n \u2265 1`.",
+      signature: "(integer) -> integer",
+      type: () => "finite_integer",
+      examples: ["CarmichaelLambda(15)  // 4"],
+      evaluate: ([n], { engine: ce }) => {
+        const k = toBigint(n);
+        if (k === null || k < 1n) return void 0;
+        return ce.number(carmichaelLambda(k));
+      }
+    },
+    LucasL: {
+      description: "Return the nth Lucas number: `LucasL(0)` is 2, `LucasL(1)` is 1, and `LucasL(n) = LucasL(n-1) + LucasL(n-2)`. Negative indices follow `LucasL(-n) = (-1)^n \xB7 LucasL(n)`.",
+      signature: "(integer) -> integer",
+      type: () => "finite_integer",
+      examples: ["LucasL(10)  // 123"],
+      evaluate: ([n], { engine: ce }) => {
+        const k = toBigint(n);
+        if (k === null) return void 0;
+        const neg2 = k < 0n;
+        const kk = neg2 ? -k : k;
+        let a = 2n;
+        let b = 1n;
+        let steps = 0;
+        for (let i = 0n; i < kk; i++) {
+          if ((++steps & 4095) === 0) checkDeadline(ce._deadline);
+          [a, b] = [b, a + b];
+        }
+        return ce.number(neg2 && kk % 2n === 1n ? -a : a);
+      }
+    },
+    CatalanNumber: {
+      description: "Return the nth Catalan number `C(n) = (2n)! / ((n+1)! \xB7 n!)`: 1, 1, 2, 5, 14, 42, \u2026 Defined for `n \u2265 0`.",
+      signature: "(integer) -> integer",
+      type: () => "finite_integer",
+      examples: ["CatalanNumber(5)  // 42"],
+      evaluate: ([n], { engine: ce }) => {
+        const k = toBigint(n);
+        if (k === null || k < 0n) return void 0;
+        let c = 1n;
+        let steps = 0;
+        for (let i = 0n; i < k; i++) {
+          if ((++steps & 4095) === 0) checkDeadline(ce._deadline);
+          c = c * 2n * (2n * i + 1n) / (i + 2n);
+        }
+        return ce.number(c);
+      }
+    },
+    IsPerfectPower: {
+      description: 'Return `"True"` if `n` is a perfect power `a^b` for integers `a` and `b \u2265 2` (a negative `n` requires an odd exponent). The smallest perfect power is 4.',
+      signature: "(integer) -> boolean",
+      examples: ['IsPerfectPower(64)  // "True"'],
+      evaluate: ([n], { engine: ce }) => {
+        const k = toBigint(n);
+        if (k === null) return void 0;
+        const m = k < 0n ? -k : k;
+        if (m < 4n) return ce.False;
+        return ce.symbol(
+          isPerfectPowerBigint(m, k < 0n, ce._deadline) ? "True" : "False"
+        );
+      }
+    },
+    ContinuedFraction: {
+      description: "Return the continued-fraction expansion of `x` as a list of integer terms `[a0, a1, \u2026]`. An exact rational is expanded fully; for an inexact value the expansion is truncated to the optional `n` terms (default 20).",
+      signature: "(number, integer?) -> list<integer>",
+      examples: ["ContinuedFraction(43/19)  // [2, 3, 1, 4]"],
+      evaluate: ([xOp, nOp], { engine: ce }) => {
+        if (xOp === void 0) return void 0;
+        const maxTerms = nOp === void 0 ? void 0 : Number(toBigint(nOp) ?? 0n);
+        if (maxTerms !== void 0 && maxTerms < 1) return void 0;
+        const terms = [];
+        if (xOp.isRational) {
+          let a = toBigint(xOp.numerator);
+          let b = toBigint(xOp.denominator);
+          if (a === null || b === null || b === 0n) return void 0;
+          if (b < 0n) {
+            a = -a;
+            b = -b;
+          }
+          while (b !== 0n) {
+            let q = a / b;
+            if (a % b !== 0n && a < 0n !== b < 0n) q -= 1n;
+            terms.push(q);
+            [a, b] = [b, a - q * b];
+            if (maxTerms !== void 0 && terms.length >= maxTerms) break;
+          }
+        } else {
+          let val = xOp.re;
+          if (!Number.isFinite(val)) return void 0;
+          const cap = maxTerms ?? 20;
+          for (let i = 0; i < cap; i++) {
+            const fl = Math.floor(val);
+            terms.push(BigInt(fl));
+            const frac = val - fl;
+            if (frac < 1e-12) break;
+            val = 1 / frac;
+            if (!Number.isFinite(val)) break;
+          }
+        }
+        return ce.function(
+          "List",
+          terms.map((t) => ce.number(t))
+        );
+      }
+    },
+    FromContinuedFraction: {
+      description: "Reconstruct the (rational) value of a continued fraction given its list of integer terms `[a0, a1, \u2026]`.",
+      signature: "(collection) -> number",
+      examples: ["FromContinuedFraction([2, 3, 1, 4])  // 43/19"],
+      evaluate: ([listOp], { engine: ce }) => {
+        const terms = Array.from(listOp?.each() ?? []).map(toBigint);
+        if (terms.length === 0 || terms.includes(null)) return void 0;
+        let p = 1n;
+        let q = 0n;
+        for (let i = terms.length - 1; i >= 0; i--)
+          [p, q] = [terms[i] * p + q, p];
+        if (q === 0n) return void 0;
+        return ce.number(p).div(ce.number(q));
+      }
+    },
+    IntegerDigits: {
+      description: "Return the digits of `n` in the given `base` (default 10), most-significant first. The sign of `n` is ignored. With a third argument `length`, the result is zero-padded on the left (or truncated to its least-significant digits) to that length.",
+      signature: "(integer, integer?, integer?) -> list<integer>",
+      examples: ["IntegerDigits(255, 16)  // [15, 15]"],
+      evaluate: ([nOp, baseOp, lenOp], { engine: ce }) => {
+        const k = toBigint(nOp);
+        if (k === null) return void 0;
+        const base = baseOp === void 0 ? 10n : toBigint(baseOp);
+        if (base === null || base < 2n) return void 0;
+        let m = k < 0n ? -k : k;
+        const digits = [];
+        if (m === 0n) digits.push(0n);
+        while (m > 0n) {
+          digits.push(m % base);
+          m = m / base;
+        }
+        digits.reverse();
+        if (lenOp !== void 0) {
+          const len = toBigint(lenOp);
+          if (len === null || len < 0n) return void 0;
+          const L = Number(len);
+          while (digits.length < L) digits.unshift(0n);
+          if (digits.length > L) digits.splice(0, digits.length - L);
+        }
+        return ce.function(
+          "List",
+          digits.map((d) => ce.number(d))
+        );
+      }
+    },
+    DigitCount: {
+      description: "Count digits of `n` in the given `base` (default 10); the sign of `n` is ignored. With a third argument `digit`, return how many times that digit occurs. Otherwise return a list `[count of 1, count of 2, \u2026, count of base-1, count of 0]`.",
+      signature: "(integer, integer?, integer?) -> integer | list<integer>",
+      type: ([, , digit]) => digit !== void 0 ? "finite_integer" : "list",
+      examples: ["DigitCount(122, 10, 2)  // 2"],
+      evaluate: ([nOp, baseOp, digitOp], { engine: ce }) => {
+        const k = toBigint(nOp);
+        if (k === null) return void 0;
+        const base = baseOp === void 0 ? 10n : toBigint(baseOp);
+        if (base === null || base < 2n) return void 0;
+        const counts = /* @__PURE__ */ new Map();
+        let m = k < 0n ? -k : k;
+        if (m === 0n) counts.set(0n, 1);
+        while (m > 0n) {
+          const d = m % base;
+          counts.set(d, (counts.get(d) ?? 0) + 1);
+          m = m / base;
+        }
+        if (digitOp !== void 0) {
+          const d = toBigint(digitOp);
+          if (d === null || d < 0n || d >= base) return void 0;
+          return ce.number(counts.get(d) ?? 0);
+        }
+        const list = [];
+        for (let d = 1n; d < base; d++)
+          list.push(ce.number(counts.get(d) ?? 0));
+        list.push(ce.number(counts.get(0n) ?? 0));
+        return ce.function("List", list);
+      }
+    },
+    RandomPrime: {
+      description: "Return a random prime. `RandomPrime(n)` draws a prime in [2, n]; `RandomPrime(m, n)` draws a prime in [m, n]. Undefined if the range contains no prime.",
+      pure: false,
+      signature: "(integer, integer?) -> integer",
+      type: () => "finite_integer",
+      examples: ["RandomPrime(100)  // e.g. 47"],
+      evaluate: ([aOp, bOp], { engine: ce }) => {
+        let lo;
+        let hi;
+        if (bOp === void 0) {
+          lo = 2n;
+          hi = toBigint(aOp);
+        } else {
+          lo = toBigint(aOp);
+          hi = toBigint(bOp);
+        }
+        if (lo === null || hi === null) return void 0;
+        if (lo < 2n) lo = 2n;
+        if (hi < lo) return void 0;
+        const range2 = hi - lo + 1n;
+        const attempts = 100 + 20 * hi.toString().length;
+        for (let i = 0; i < attempts; i++) {
+          const r = lo + randomBigintBelow(range2);
+          if (isPrimeBigint(r)) return ce.number(r);
+        }
+        for (let p = lo; p <= hi; p++) {
+          checkDeadline(ce._deadline);
+          if (isPrimeBigint(p)) return ce.number(p);
+        }
+        return void 0;
+      }
+    },
+    PrimePi: {
+      description: "Return \u03C0(n), the prime-counting function: the number of primes less than or equal to `n`.",
+      signature: "(real) -> integer",
+      type: () => "finite_integer",
+      examples: ["PrimePi(10)  // 4"],
+      evaluate: ([n], { engine: ce }) => {
+        const x = n?.re;
+        if (x === void 0 || !Number.isFinite(x)) return void 0;
+        const bound = BigInt(Math.floor(x));
+        if (bound < 2n) return ce.number(0);
+        let count = 1;
+        let steps = 0;
+        for (let k = 3n; k <= bound; k += 2n) {
+          if ((++steps & 1023) === 0) checkDeadline(ce._deadline);
+          if (isPrimeBigint(k)) count++;
+        }
+        return ce.number(count);
+      }
+    },
+    BernoulliB: {
+      description: "Return the nth Bernoulli number B\u2099 as an exact rational, using the convention B\u2081 = -1/2. Odd `n > 1` give 0.",
+      signature: "(integer) -> finite_rational",
+      type: () => "finite_rational",
+      examples: ["BernoulliB(2)  // 1/6"],
+      evaluate: ([n], { engine: ce }) => {
+        const k = toBigint(n);
+        if (k === null || k < 0n) return void 0;
+        if (k === 0n) return ce.number(1);
+        if (k === 1n) return ce.number(-1).div(ce.number(2));
+        if (k % 2n === 1n) return ce.number(0);
+        const [num, den] = bernoulliNumber(Number(k), ce._deadline);
+        return den === 1n ? ce.number(num) : ce.number(num).div(ce.number(den));
+      }
+    },
+    FromDigits: {
+      description: "Reconstruct an integer from its list of digits (most-significant first) in the given `base` (default 10). The inverse of `IntegerDigits`. Digits outside `[0, base)` are combined positionally (Horner evaluation).",
+      signature: "(collection, integer?) -> integer",
+      type: () => "finite_integer",
+      examples: ["FromDigits([1, 2, 3, 4])  // 1234"],
+      evaluate: ([digitsOp, baseOp], { engine: ce }) => {
+        const digits = Array.from(digitsOp?.each() ?? []).map(toBigint);
+        if (digits.length === 0 || digits.includes(null)) return void 0;
+        const base = baseOp === void 0 ? 10n : toBigint(baseOp);
+        if (base === null || base < 2n) return void 0;
+        let result = 0n;
+        for (const d of digits) result = result * base + d;
+        return ce.number(result);
+      }
+    },
+    DigitSum: {
+      description: "Return the sum of the digits of `n` in the given `base` (default 10). The sign of `n` is ignored.",
+      signature: "(integer, integer?) -> integer",
+      type: () => "finite_integer",
+      examples: ["DigitSum(1234)  // 10"],
+      evaluate: ([nOp, baseOp], { engine: ce }) => {
+        const k = toBigint(nOp);
+        if (k === null) return void 0;
+        const base = baseOp === void 0 ? 10n : toBigint(baseOp);
+        if (base === null || base < 2n) return void 0;
+        let m = k < 0n ? -k : k;
+        let sum = 0n;
+        while (m > 0n) {
+          sum += m % base;
+          m /= base;
+        }
+        return ce.number(sum);
+      }
+    },
+    DivisorSigma: {
+      description: "The divisor function \u03C3_k(n) = \u03A3_{d | n} d\u1D4F over the positive divisors of `n`. \u03C3\u2080 counts divisors, \u03C3\u2081 sums them. Defined for `n \u2265 1`.",
+      signature: "(integer, integer) -> integer",
+      type: () => "finite_integer",
+      examples: ["DivisorSigma(2, 6)  // 50"],
+      evaluate: ([kOp, nOp], { engine: ce }) => {
+        const k = toBigint(kOp);
+        const n = toBigint(nOp);
+        if (k === null || n === null || k < 0n || n < 1n) return void 0;
+        if (n === 1n) return ce.number(1);
+        let result = 1n;
+        for (const [p, e] of bigPrimeFactors(n)) {
+          if (k === 0n) result *= BigInt(e + 1);
+          else {
+            const pk = p ** k;
+            result *= (pk ** BigInt(e + 1) - 1n) / (pk - 1n);
+          }
+        }
+        return ce.number(result);
+      }
+    },
+    JacobiSymbol: {
+      description: "The Jacobi symbol (a/n) for an odd `n > 0`. Returns -1, 0, or 1. Undefined when `n` is even or non-positive.",
+      signature: "(integer, integer) -> integer",
+      type: () => "finite_integer",
+      examples: ["JacobiSymbol(5, 21)  // 1"],
+      evaluate: ([aOp, nOp], { engine: ce }) => {
+        const a = toBigint(aOp);
+        const n = toBigint(nOp);
+        if (a === null || n === null) return void 0;
+        if (n <= 0n || n % 2n === 0n) return void 0;
+        return ce.number(jacobiSymbol(a, n));
+      }
+    },
+    LegendreSymbol: {
+      description: "The Legendre symbol (a/p) for an odd prime `p`. Returns -1, 0, or 1. Undefined when `p` is not an odd prime.",
+      signature: "(integer, integer) -> integer",
+      type: () => "finite_integer",
+      examples: ["LegendreSymbol(3, 7)  // -1"],
+      evaluate: ([aOp, pOp], { engine: ce }) => {
+        const a = toBigint(aOp);
+        const p = toBigint(pOp);
+        if (a === null || p === null) return void 0;
+        if (p <= 2n || p % 2n === 0n || !isPrimeBigint(p)) return void 0;
+        return ce.number(jacobiSymbol(a, p));
+      }
+    },
+    MultiplicativeOrder: {
+      description: "The multiplicative order of `a` modulo `n`: the smallest `k > 0` such that `a^k \u2261 1 (mod n)`. Undefined unless `a` and `n` are coprime.",
+      signature: "(integer, integer) -> integer",
+      type: () => "finite_integer",
+      examples: ["MultiplicativeOrder(2, 7)  // 3"],
+      evaluate: ([aOp, nOp], { engine: ce }) => {
+        const a0 = toBigint(aOp);
+        const n = toBigint(nOp);
+        if (a0 === null || n === null || n < 1n) return void 0;
+        if (n === 1n) return ce.number(1);
+        const a = (a0 % n + n) % n;
+        if (gcd2(a, n) !== 1n) return void 0;
+        for (const d of divisorsAscending(carmichaelLambda(n), ce._deadline)) {
+          checkDeadline(ce._deadline);
+          if (modPow(a, d, n) === 1n) return ce.number(d);
+        }
+        return void 0;
+      }
+    },
+    PrimitiveRoot: {
+      description: "The smallest primitive root modulo `n` (a generator of the multiplicative group of integers mod `n`), or undefined if none exists (which happens unless `n` is 1, 2, 4, p\u1D4F, or 2p\u1D4F for an odd prime p).",
+      signature: "(integer) -> integer",
+      type: () => "finite_integer",
+      examples: ["PrimitiveRoot(7)  // 3"],
+      evaluate: ([nOp], { engine: ce }) => {
+        const n = toBigint(nOp);
+        if (n === null || n < 1n) return void 0;
+        if (n === 1n) return ce.number(0);
+        if (n === 2n) return ce.number(1);
+        if (n === 4n) return ce.number(3);
+        if (!hasPrimitiveRoot(n)) return void 0;
+        const phi = eulerPhi(n);
+        const phiFactors = [...bigPrimeFactors(phi).keys()];
+        for (let a = 2n; a < n; a++) {
+          checkDeadline(ce._deadline);
+          if (gcd2(a, n) !== 1n) continue;
+          if (phiFactors.every((q) => modPow(a, phi / q, n) !== 1n))
+            return ce.number(a);
+        }
+        return void 0;
+      }
+    },
+    PrimeNumber: {
+      description: "The nth prime number. `PrimeNumber` is an alias for `NthPrime`, which is the preferred name.",
+      signature: "(integer) -> integer",
+      canonical: ([n], { engine }) => engine._fn("NthPrime", [n])
+    },
     Totient: {
       wikidata: "Q190026",
       description: "Euler's totient function \u03C6(n): count of positive integers \u2264 n that are coprime to n.",
@@ -60939,6 +61771,165 @@ var NUMBER_THEORY_LIBRARY = [
     }
   }
 ];
+function extGcd(a, b) {
+  let [oldR, r] = [a, b];
+  let [oldS, s] = [1n, 0n];
+  let [oldT, t] = [0n, 1n];
+  while (r !== 0n) {
+    const q = oldR / r;
+    [oldR, r] = [r, oldR - q * r];
+    [oldS, s] = [s, oldS - q * s];
+    [oldT, t] = [t, oldT - q * t];
+  }
+  return [oldR, oldS, oldT];
+}
+function bigintSqrt2(n) {
+  if (n < 2n) return n;
+  let x = 1n << (BigInt(n.toString(2).length) + 1n) / 2n;
+  for (; ; ) {
+    const y = x + n / x >> 1n;
+    if (y >= x) break;
+    x = y;
+  }
+  while (x * x > n) x -= 1n;
+  return x;
+}
+function chineseRemainder(residues, moduli) {
+  let x = 0n;
+  let m = 1n;
+  for (let i = 0; i < residues.length; i++) {
+    const ni = moduli[i];
+    if (ni <= 0n) return null;
+    const ri = (residues[i] % ni + ni) % ni;
+    const [g, p] = extGcd(m, ni);
+    if ((ri - x) % g !== 0n) return null;
+    const lcmMN = m / g * ni;
+    const mod22 = ni / g;
+    const lambda = ((ri - x) / g * p % mod22 + mod22) % mod22;
+    x = ((x + m * lambda) % lcmMN + lcmMN) % lcmMN;
+    m = lcmMN;
+  }
+  return x;
+}
+function iroot(n, b) {
+  if (n < 2n) return n;
+  const bb = BigInt(b);
+  const approx = Math.pow(Number(n), 1 / b);
+  let x = Number.isFinite(approx) ? BigInt(Math.round(approx)) : 1n << BigInt(n.toString(2).length) / bb + 1n;
+  if (x < 1n) x = 1n;
+  while (x ** bb > n) x -= 1n;
+  while ((x + 1n) ** bb <= n) x += 1n;
+  return x;
+}
+function isPerfectPowerBigint(m, oddOnly, deadline) {
+  const bits = m.toString(2).length;
+  for (let b = oddOnly ? 3 : 2; b <= bits; b++) {
+    if (oddOnly && b % 2 === 0) continue;
+    checkDeadline(deadline);
+    const r = iroot(m, b);
+    if (r >= 2n && r ** BigInt(b) === m) return true;
+  }
+  return false;
+}
+function randomBigintBelow(n) {
+  if (n <= 1n) return 0n;
+  if (n <= BigInt(Number.MAX_SAFE_INTEGER))
+    return BigInt(Math.floor(Math.random() * Number(n)));
+  const bits = n.toString(2).length;
+  let r;
+  do {
+    r = 0n;
+    for (let i = 0; i < bits; i += 30)
+      r = r << 30n | BigInt(Math.floor(Math.random() * (1 << 30)));
+    r &= (1n << BigInt(bits)) - 1n;
+  } while (r >= n);
+  return r;
+}
+function divisorsAscending(m, deadline) {
+  const small = [];
+  const large = [];
+  let steps = 0;
+  for (let i = 1n; i * i <= m; i++) {
+    if ((++steps & 4095) === 0) checkDeadline(deadline);
+    if (m % i === 0n) {
+      small.push(i);
+      const j = m / i;
+      if (j !== i) large.push(j);
+    }
+  }
+  large.reverse();
+  return [...small, ...large];
+}
+function eulerPhi(n) {
+  if (n <= 1n) return 1n;
+  let result = n;
+  for (const p of bigPrimeFactors(n).keys()) result = result / p * (p - 1n);
+  return result;
+}
+function carmichaelLambda(n) {
+  if (n <= 1n) return 1n;
+  let result = 1n;
+  for (const [p, e] of bigPrimeFactors(n)) {
+    const lambda = p === 2n ? e === 1 ? 1n : e === 2 ? 2n : 1n << BigInt(e - 2) : p ** BigInt(e - 1) * (p - 1n);
+    result = lcm2(result, lambda);
+  }
+  return result;
+}
+function jacobiSymbol(a, n) {
+  a = (a % n + n) % n;
+  let result = 1;
+  while (a !== 0n) {
+    while (a % 2n === 0n) {
+      a /= 2n;
+      const r = n % 8n;
+      if (r === 3n || r === 5n) result = -result;
+    }
+    [a, n] = [n, a];
+    if (a % 4n === 3n && n % 4n === 3n) result = -result;
+    a %= n;
+  }
+  return n === 1n ? result : 0;
+}
+function hasPrimitiveRoot(n) {
+  if (n === 1n || n === 2n || n === 4n) return true;
+  let m = n;
+  let twos = 0;
+  while (m % 2n === 0n) {
+    m /= 2n;
+    twos++;
+  }
+  if (twos > 1) return false;
+  if (m === 1n) return false;
+  return bigPrimeFactors(m).size === 1;
+}
+function reduceRat(num, den) {
+  if (den < 0n) {
+    num = -num;
+    den = -den;
+  }
+  const g = gcd2(num < 0n ? -num : num, den);
+  return g > 1n ? [num / g, den / g] : [num, den];
+}
+function bernoulliNumber(n, deadline) {
+  const B = [[1n, 1n]];
+  for (let m = 1; m <= n; m++) {
+    checkDeadline(deadline);
+    let sNum = 0n;
+    let sDen = 1n;
+    let c = 1n;
+    for (let k = 0; k < m; k++) {
+      const tNum = c * B[k][0];
+      const tDen = B[k][1];
+      const g = gcd2(sDen, tDen);
+      sNum = sNum * (tDen / g) + tNum * (sDen / g);
+      sDen = sDen / g * tDen;
+      [sNum, sDen] = reduceRat(sNum, sDen);
+      c = c * BigInt(m + 1 - k) / BigInt(k + 1);
+    }
+    B.push(reduceRat(-sNum, sDen * BigInt(m + 1)));
+  }
+  return B[n];
+}
 function sumSquareDigits(k) {
   return k.toString().split("").map((d) => BigInt(d)).reduce((sum, d) => sum + d * d, 0n);
 }
@@ -84314,14 +85305,14 @@ var ComputeEngine = class _ComputeEngine {
 _setDefaultEngineFactory(() => new ComputeEngine());
 
 // src/compute-engine.ts
-var version = "0.63.0";
+var version = "0.64.0";
 ComputeEngine._latexSyntaxFactory = () => new LatexSyntax();
 _setDefaultEngineFactory(
   () => new ComputeEngine({ latexSyntax: new LatexSyntax() })
 );
 globalThis[/* @__PURE__ */ Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.63.0"
+  version: "0.64.0"
 };
 export {
   DEFINITIONS_ALGEBRA as ALGEBRA_DICTIONARY,