@danielsimonjr/mathts-functions 0.58.0 → 0.59.0

package/dist/index.js

@@ -454,7 +454,7 @@ __export(typed_exports, {
   studentTTest: () => studentTTest,
   studentTTestPaired: () => studentTTestPaired,
   subfactorial: () => subfactorial,
-  substitute: () => substitute,
+  substitute: () => substitute2,
   subtract: () => subtract,
   sum: () => sum,
   symbolicPartialDerivative: () => symbolicPartialDerivative,
@@ -3341,8 +3341,8 @@ function resetGpuFft() {
   resources = null;
 }
 function stageUniformsFor(res, n, inverse) {
-  const key = `${n}:${inverse ? 1 : 0}`;
-  const cached = res.stageUniforms.get(key);
+  const key2 = `${n}:${inverse ? 1 : 0}`;
+  const cached = res.stageUniforms.get(key2);
   if (cached) return cached;
   const stages = Math.log2(n);
   const bufs = [];
@@ -3355,7 +3355,7 @@ function stageUniformsFor(res, n, inverse) {
     res.device.queue.writeBuffer(u, 0, new Uint32Array([n, ns, inverse ? 1 : 0, 0]));
     bufs.push(u);
   }
-  res.stageUniforms.set(key, bufs);
+  res.stageUniforms.set(key2, bufs);
   return bufs;
 }
 var isPowerOf2 = (n) => n > 0 && (n & n - 1) === 0;
@@ -8957,14 +8957,14 @@ function voronoiDiagram(points, bounds) {
     const uy = ((a[0] * a[0] + a[1] * a[1]) * (c[0] - b[0]) + (b[0] * b[0] + b[1] * b[1]) * (a[0] - c[0]) + (c[0] * c[0] + c[1] * c[1]) * (b[0] - a[0])) / D;
     const cx = Math.max(bounds[0], Math.min(bounds[2], ux));
     const cy = Math.max(bounds[1], Math.min(bounds[3], uy));
-    const key = tri.slice().sort().join(",");
-    triCircumcenters.set(key, vertices.length);
+    const key2 = tri.slice().sort().join(",");
+    triCircumcenters.set(key2, vertices.length);
     vertices.push([cx, cy]);
   }
   const regions = Array.from({ length: points.length }, () => []);
   for (const tri of triangles) {
-    const key = tri.slice().sort().join(",");
-    const vIdx = triCircumcenters.get(key);
+    const key2 = tri.slice().sort().join(",");
+    const vIdx = triCircumcenters.get(key2);
     if (vIdx !== void 0) {
       for (const pIdx of tri) {
         if (!regions[pIdx].includes(vIdx)) {
@@ -9582,10 +9582,10 @@ function cmpPowers(a, b) {
 function normalize(p) {
   const byKey = /* @__PURE__ */ new Map();
   for (const t of p) {
-    const key = t.powers.join(",");
-    const existing = byKey.get(key);
+    const key2 = t.powers.join(",");
+    const existing = byKey.get(key2);
     if (existing) existing.coeff += t.coeff;
-    else byKey.set(key, { coeff: t.coeff, powers: [...t.powers] });
+    else byKey.set(key2, { coeff: t.coeff, powers: [...t.powers] });
   }
   return [...byKey.values()].filter((t) => Math.abs(t.coeff) > EPS).sort((a, b) => cmpPowers(b.powers, a.powers));
 }
@@ -10573,6 +10573,441 @@ function factorUnivariateZ(f) {
   return { constant, factors };
 }
 
+// src/typed/factorization/multi-poly.ts
+function key(exps) {
+  return exps.join(",");
+}
+function unkey(k) {
+  if (k === "") {
+    return [];
+  }
+  return k.split(",").map((s) => Number(s));
+}
+function fromTerms(vars, entries) {
+  const terms = /* @__PURE__ */ new Map();
+  for (const [exps, coeff] of entries) {
+    if (exps.length !== vars.length) {
+      throw new RangeError("fromTerms: exponent vector length must match vars.length");
+    }
+    const k = key(exps);
+    const prev = terms.get(k) ?? 0n;
+    const next = prev + coeff;
+    if (next === 0n) {
+      terms.delete(k);
+    } else {
+      terms.set(k, next);
+    }
+  }
+  return { vars: vars.slice(), terms };
+}
+function degreeIn(p, varIndex) {
+  let d = -1;
+  for (const k of p.terms.keys()) {
+    const exps = unkey(k);
+    if (exps[varIndex] > d) {
+      d = exps[varIndex];
+    }
+  }
+  return d;
+}
+function totalDegree(p) {
+  let d = -1;
+  for (const k of p.terms.keys()) {
+    const exps = unkey(k);
+    const s = exps.reduce((a, b) => a + b, 0);
+    if (s > d) {
+      d = s;
+    }
+  }
+  return d;
+}
+function isZero2(p) {
+  return p.terms.size === 0;
+}
+function equals(a, b) {
+  if (a.vars.length !== b.vars.length) return false;
+  for (let i = 0; i < a.vars.length; i += 1) {
+    if (a.vars[i] !== b.vars[i]) return false;
+  }
+  if (a.terms.size !== b.terms.size) return false;
+  for (const [k, v] of a.terms) {
+    if (b.terms.get(k) !== v) return false;
+  }
+  return true;
+}
+function addMP(a, b) {
+  const terms = new Map(a.terms);
+  for (const [k, v] of b.terms) {
+    const next = (terms.get(k) ?? 0n) + v;
+    if (next === 0n) {
+      terms.delete(k);
+    } else {
+      terms.set(k, next);
+    }
+  }
+  return { vars: a.vars.slice(), terms };
+}
+function subMP(a, b) {
+  return addMP(a, negMP(b));
+}
+function mulMP(a, b) {
+  const n = a.vars.length;
+  const terms = /* @__PURE__ */ new Map();
+  for (const [ka, ca] of a.terms) {
+    const ea = unkey(ka);
+    for (const [kb, cb] of b.terms) {
+      const eb = unkey(kb);
+      const exps = new Array(n);
+      for (let i = 0; i < n; i += 1) {
+        exps[i] = ea[i] + eb[i];
+      }
+      const k = key(exps);
+      const next = (terms.get(k) ?? 0n) + ca * cb;
+      if (next === 0n) {
+        terms.delete(k);
+      } else {
+        terms.set(k, next);
+      }
+    }
+  }
+  return { vars: a.vars.slice(), terms };
+}
+function negMP(p) {
+  const terms = /* @__PURE__ */ new Map();
+  for (const [k, v] of p.terms) {
+    terms.set(k, -v);
+  }
+  return { vars: p.vars.slice(), terms };
+}
+function canonicalCompare(expsA, expsB) {
+  const da = expsA.reduce((a, b) => a + b, 0);
+  const db = expsB.reduce((a, b) => a + b, 0);
+  if (da !== db) {
+    return db - da;
+  }
+  for (let i = 0; i < expsA.length; i += 1) {
+    if (expsA[i] !== expsB[i]) {
+      return expsB[i] - expsA[i];
+    }
+  }
+  return 0;
+}
+function leadingTerm(p) {
+  let best = null;
+  for (const [k, v] of p.terms) {
+    const exps = unkey(k);
+    if (best === null || canonicalCompare(exps, best.exps) < 0) {
+      best = { exps, coeff: v };
+    }
+  }
+  return best;
+}
+function integerContentMP(p) {
+  let g = 0n;
+  for (const v of p.terms.values()) {
+    g = bigintGcd(g, v);
+  }
+  return g;
+}
+function primitivePartMP(p) {
+  if (isZero2(p)) {
+    return { vars: p.vars.slice(), terms: /* @__PURE__ */ new Map() };
+  }
+  const g = integerContentMP(p);
+  const terms = /* @__PURE__ */ new Map();
+  for (const [k, v] of p.terms) {
+    terms.set(k, g === 0n ? v : v / g);
+  }
+  const divided = { vars: p.vars.slice(), terms };
+  const lead = leadingTerm(divided);
+  if (lead !== null && lead.coeff < 0n) {
+    return negMP(divided);
+  }
+  return divided;
+}
+function multiExactDivide(a, b) {
+  const bLead = leadingTerm(b);
+  if (bLead === null) {
+    return null;
+  }
+  const n = a.vars.length;
+  let remainder = a;
+  const quotientEntries = [];
+  while (!isZero2(remainder)) {
+    const rLead = leadingTerm(remainder);
+    if (rLead === null) {
+      break;
+    }
+    const qExps = new Array(n);
+    for (let i = 0; i < n; i += 1) {
+      const diff2 = rLead.exps[i] - bLead.exps[i];
+      if (diff2 < 0) {
+        return null;
+      }
+      qExps[i] = diff2;
+    }
+    if (rLead.coeff % bLead.coeff !== 0n) {
+      return null;
+    }
+    const qCoeff = rLead.coeff / bLead.coeff;
+    quotientEntries.push([qExps, qCoeff]);
+    const qTerm = fromTerms(a.vars, [[qExps, qCoeff]]);
+    remainder = subMP(remainder, mulMP(qTerm, b));
+  }
+  return fromTerms(a.vars, quotientEntries);
+}
+function fromAlgebraExpr(expr, vars) {
+  try {
+    const parsed = polyFromExpression(expr, vars);
+    const entries = [];
+    for (const term of parsed) {
+      if (!Number.isInteger(term.coeff)) {
+        return null;
+      }
+      entries.push([term.powers, BigInt(term.coeff)]);
+    }
+    return fromTerms(vars, entries);
+  } catch {
+    return null;
+  }
+}
+function toAlgebraString(p) {
+  if (p.terms.size === 0) return "0";
+  const fmt = (c) => c.toString();
+  const terms = [...p.terms].map(([k, v]) => ({ exps: unkey(k), coeff: v })).reverse().map(({ exps, coeff }) => {
+    const varPart = exps.map((e, i) => e === 0 ? "" : e === 1 ? p.vars[i] : `${p.vars[i]}^${e}`).filter(Boolean).join("*");
+    return varPart ? `${fmt(coeff)}*${varPart}` : fmt(coeff);
+  });
+  return terms.join(" + ").replace(/\+ -/g, "- ");
+}
+
+// src/typed/factorization/kronecker.ts
+function substitutionBases(p) {
+  const n = p.vars.length;
+  const bases = new Array(n);
+  let prod2 = 1n;
+  for (let k = 0; k < n; k += 1) {
+    bases[k] = prod2;
+    const d = degreeIn(p, k);
+    const radix = d < 0 ? 1n : BigInt(d) + 1n;
+    prod2 *= radix;
+  }
+  return bases;
+}
+function substitutedDegree(p, bases) {
+  let total = 0n;
+  for (let i = 0; i < bases.length; i += 1) {
+    const d = degreeIn(p, i);
+    const dd = d < 0 ? 0n : BigInt(d);
+    total += dd * bases[i];
+  }
+  return total;
+}
+function substitute(p, bases) {
+  const maxDeg = substitutedDegree(p, bases);
+  if (maxDeg > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new RangeError(
+      `substitute: substituted degree ${maxDeg.toString()} exceeds Number.MAX_SAFE_INTEGER`
+    );
+  }
+  const len = Number(maxDeg) + 1;
+  const out = new Array(len).fill(0n);
+  for (const [k, coeff] of p.terms) {
+    const exps = unkey(k);
+    let deg = 0n;
+    for (let i = 0; i < exps.length; i += 1) {
+      deg += BigInt(exps[i]) * bases[i];
+    }
+    const idx = Number(deg);
+    out[idx] += coeff;
+  }
+  return trim(out);
+}
+function backSubstitute(u, bases, degBounds, vars) {
+  const n = bases.length;
+  const trimmed = trim(u);
+  const entries = [];
+  for (let e = 0; e < trimmed.length; e += 1) {
+    const coeff = trimmed[e];
+    if (coeff === 0n) {
+      continue;
+    }
+    let remaining = BigInt(e);
+    const exps = new Array(n);
+    for (let i = 0; i < n; i += 1) {
+      const radix = BigInt(degBounds[i]) + 1n;
+      exps[i] = Number(remaining % radix);
+      remaining = remaining / radix;
+    }
+    if (remaining !== 0n) {
+      return null;
+    }
+    entries.push([exps, coeff]);
+  }
+  return fromTerms(vars, entries);
+}
+
+// src/typed/factorization/kronecker-factor.ts
+var KRONECKER_MAX_DEGREE = 2000n;
+var MAX_MODULAR_FACTORS2 = 24;
+function log4(message) {
+  console.warn(message);
+}
+function* subsetsOfSize(n, s) {
+  if (s === 0) {
+    yield [];
+    return;
+  }
+  if (s > n) {
+    return;
+  }
+  const idx = Array.from({ length: s }, (_, i) => i);
+  for (; ; ) {
+    yield idx.slice();
+    let i = s - 1;
+    while (i >= 0 && idx[i] === n - s + i) {
+      i -= 1;
+    }
+    if (i < 0) {
+      return;
+    }
+    idx[i] += 1;
+    for (let j = i + 1; j < s; j += 1) {
+      idx[j] = idx[j - 1] + 1;
+    }
+  }
+}
+function removeIndices(pool, indices) {
+  const sorted = [...indices].sort((a, b) => b - a);
+  for (const i of sorted) {
+    pool.splice(i, 1);
+  }
+}
+function subsetProduct(pool, indices) {
+  let prod2 = [1n];
+  for (const idx of indices) {
+    prod2 = mul(prod2, pool[idx]);
+  }
+  return prod2;
+}
+function candidateFor(pool, indices, bases, degBounds, vars) {
+  const back = backSubstitute(subsetProduct(pool, indices), bases, degBounds, vars);
+  if (back === null) {
+    return null;
+  }
+  const cand = primitivePartMP(back);
+  if (totalDegree(cand) < 1) {
+    return null;
+  }
+  return cand;
+}
+function findMatchingSubset(pool, s, cand, bases, degBounds, vars) {
+  for (const indices of subsetsOfSize(pool.length, s)) {
+    const c = candidateFor(pool, indices, bases, degBounds, vars);
+    if (c !== null && equals(c, cand)) {
+      return indices;
+    }
+  }
+  return null;
+}
+function factorMultivariateKronecker(p) {
+  if (p.vars.length < 2) {
+    return null;
+  }
+  if (isZero2(p) || totalDegree(p) < 1) {
+    return null;
+  }
+  const cont = integerContentMP(p);
+  const pLead = leadingTerm(p);
+  const sign3 = pLead !== null && pLead.coeff < 0n ? -1n : 1n;
+  let constant = cont * sign3;
+  const g = primitivePartMP(p);
+  const bases = substitutionBases(g);
+  if (substitutedDegree(g, bases) > KRONECKER_MAX_DEGREE) {
+    log4(
+      `factorMultivariateKronecker: substituted degree exceeds KRONECKER_MAX_DEGREE=${KRONECKER_MAX_DEGREE.toString()}; declining`
+    );
+    return null;
+  }
+  const image = substitute(g, bases);
+  const uf = factorUnivariateZ(image);
+  const totalCount = uf.factors.reduce((acc, f) => acc + f.mult, 0);
+  if (totalCount <= 1) {
+    return { constant, factors: [{ poly: g, mult: 1 }] };
+  }
+  const pool = [];
+  for (const { poly, mult } of uf.factors) {
+    for (let i = 0; i < mult; i += 1) {
+      pool.push(poly);
+    }
+  }
+  if (pool.length > MAX_MODULAR_FACTORS2) {
+    log4(
+      `factorMultivariateKronecker: ${pool.length} univariate factors exceeds MAX_MODULAR_FACTORS=${MAX_MODULAR_FACTORS2}; returning input whole`
+    );
+    return { constant, factors: [{ poly: g, mult: 1 }] };
+  }
+  const degBounds = g.vars.map((_, i) => degreeIn(g, i));
+  let gCur = g;
+  const found = [];
+  let s = 1;
+  while (pool.length > 0 && 2 * s <= pool.length) {
+    let extracted = false;
+    for (const indices of subsetsOfSize(pool.length, s)) {
+      const cand = candidateFor(pool, indices, bases, degBounds, g.vars);
+      if (cand === null) {
+        continue;
+      }
+      const quotient = multiExactDivide(gCur, cand);
+      if (quotient === null) {
+        continue;
+      }
+      gCur = quotient;
+      removeIndices(pool, indices);
+      let mult = 1;
+      for (; ; ) {
+        const next = multiExactDivide(gCur, cand);
+        if (next === null) {
+          break;
+        }
+        const copy = findMatchingSubset(pool, s, cand, bases, degBounds, g.vars);
+        if (copy === null) {
+          break;
+        }
+        removeIndices(pool, copy);
+        gCur = next;
+        mult += 1;
+      }
+      found.push({ poly: cand, mult });
+      extracted = true;
+      break;
+    }
+    if (extracted) {
+      s = 1;
+    } else {
+      s += 1;
+    }
+  }
+  if (!isZero2(gCur)) {
+    const c = integerContentMP(gCur);
+    const l = leadingTerm(gCur);
+    const sgn = l !== null && l.coeff < 0n ? -1n : 1n;
+    constant *= c * sgn;
+    if (totalDegree(gCur) >= 1) {
+      found.push({ poly: primitivePartMP(gCur), mult: 1 });
+    }
+  }
+  found.sort((a, b) => {
+    const la = leadingTerm(a.poly);
+    const lb = leadingTerm(b.poly);
+    if (la === null || lb === null) {
+      return 0;
+    }
+    return canonicalCompare(la.exps, lb.exps);
+  });
+  return { constant, factors: found };
+}
+
 // src/typed/factorization/index.ts
 var INT_TOLERANCE = 1e-7;
 function polyToDense(p) {
@@ -10659,6 +11094,24 @@ function factorPolynomialUnivariate(expr, v) {
   }
   return parts.join("*");
 }
+function renderMultiFactorization(fact) {
+  const parts = [];
+  if (fact.constant !== 1n) parts.push(String(fact.constant));
+  for (const { poly, mult } of fact.factors) {
+    const term = `(${toAlgebraString(poly)})`;
+    parts.push(mult > 1 ? `${term}^${mult}` : term);
+  }
+  return parts.join("*");
+}
+function factorMultivariateString(expr, vars, minFactors = 2) {
+  const p = fromAlgebraExpr(expr, vars);
+  if (p === null) return null;
+  const fact = factorMultivariateKronecker(p);
+  if (fact === null) return null;
+  const count2 = fact.factors.reduce((acc, f) => acc + f.mult, 0);
+  if (count2 < minFactors) return null;
+  return renderMultiFactorization(fact);
+}
 
 // src/typed/algebra.ts
 var MATH_KEYWORDS = /* @__PURE__ */ new Set([
@@ -10898,13 +11351,13 @@ function variables(expr) {
   }
   return [...vars].sort();
 }
-function substitute(expr, vars) {
+function substitute2(expr, vars) {
   let result = expr;
   const keys = Object.keys(vars).sort((a, b) => b.length - a.length);
-  for (const key of keys) {
-    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  for (const key2 of keys) {
+    const escaped = key2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const pattern = new RegExp("\\b" + escaped + "\\b", "g");
-    result = result.replace(pattern, vars[key]);
+    result = result.replace(pattern, vars[key2]);
   }
   return result;
 }
@@ -11121,13 +11574,22 @@ function factorMultivariate(expr, vars) {
   if (hasMonomial) parts.push(monomialString(monPow, vars));
   if (dsq) parts.push(dsq[0], dsq[1]);
   else parts.push(`(${polyToString(cofactor, vars)})`);
-  return parts.join("*");
+  const monomialFactors = monPow.reduce((acc, e) => acc + e, 0);
+  const count2 = monomialFactors + (dsq ? 2 : 1);
+  return { text: parts.join("*"), count: count2 };
 }
 function factor(expr) {
   const univariateVars = variables(expr);
   if (univariateVars.length >= 2) {
     const mv = factorMultivariate(expr, univariateVars);
-    if (mv !== null) return mv;
+    if (mv === null) {
+      const kron2 = factorMultivariateString(expr, univariateVars);
+      if (kron2 !== null) return kron2;
+    } else {
+      const refined = factorMultivariateString(expr, univariateVars, mv.count + 1);
+      if (refined !== null) return refined;
+      return mv.text;
+    }
   }
   if (univariateVars.length === 1) {
     try {
@@ -11618,7 +12080,7 @@ var typedAlgebra = {
   expand,
   factor,
   collect,
-  substitute,
+  substitute: substitute2,
   variables,
   cancel,
   together,
@@ -16655,19 +17117,19 @@ function minimumSpanningTree(adj) {
   const n = adj.length;
   if (n === 0) return [];
   const inMST = new Array(n).fill(false);
-  const key = new Array(n).fill(Infinity);
+  const key2 = new Array(n).fill(Infinity);
   const parent = new Array(n).fill(-1);
-  key[0] = 0;
+  key2[0] = 0;
   for (let count2 = 0; count2 < n; count2++) {
     let u = -1;
     for (let v = 0; v < n; v++) {
-      if (!inMST[v] && (u === -1 || key[v] < key[u])) u = v;
+      if (!inMST[v] && (u === -1 || key2[v] < key2[u])) u = v;
     }
-    if (u === -1 || key[u] === Infinity) break;
+    if (u === -1 || key2[u] === Infinity) break;
     inMST[u] = true;
     for (let v = 0; v < n; v++) {
-      if (adj[u][v] > 0 && !inMST[v] && adj[u][v] < key[v]) {
-        key[v] = adj[u][v];
+      if (adj[u][v] > 0 && !inMST[v] && adj[u][v] < key2[v]) {
+        key2[v] = adj[u][v];
         parent[v] = u;
       }
     }
@@ -20401,8 +20863,8 @@ function bigNumberToBase(bn, base, wordSize) {
   return numberToBase(n, base, wordSize);
 }
 function interpolate2(template, values, options) {
-  return template.replace(printTemplate, function(original, key) {
-    const keys = key.split(".");
+  return template.replace(printTemplate, function(original, key2) {
+    const keys = key2.split(".");
     let value = values[keys.shift()];
     if (value !== void 0 && value.isMatrix) {
       value = value.toArray();
@@ -21049,7 +21511,7 @@ __export(factories_exports, {
   isNumeric: () => isNumeric,
   isPositive: () => isPositive,
   isPrime: () => isPrime2,
-  isZero: () => isZero2,
+  isZero: () => isZero3,
   josephson: () => josephson,
   kldivergence: () => kldivergence,
   klitzing: () => klitzing,
@@ -23015,8 +23477,8 @@ var createPrint = /* @__PURE__ */ factory(
   }
 );
 function _print(template, values, options) {
-  return template.replace(printTemplate, function(original, key) {
-    const keys = key.split(".");
+  return template.replace(printTemplate, function(original, key2) {
+    const keys = key2.split(".");
     let value = values[keys.shift()];
     if (value !== void 0 && value.isMatrix) {
       value = value.toArray();
@@ -24928,7 +25390,7 @@ var createMatrixFromFunction = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     matrix: matrix2,
-    isZero: isZero3
+    isZero: isZero4
   }) => {
     return typed3(name91, {
       "Array | Matrix, function, string, string": function(size2, fn, format4, datatype) {
@@ -24960,7 +25422,7 @@ var createMatrixFromFunction = /* @__PURE__ */ factory(
       m.resize(size2);
       m.forEach(function(_, index) {
         const val = fn(index);
-        if (isZero3(val)) return;
+        if (isZero4(val)) return;
         m.set(index, val);
       });
       return m;
@@ -25226,7 +25688,7 @@ var dependencies96 = [
 var createDet = /* @__PURE__ */ factory(
   name96,
   dependencies96,
-  ({ typed: typed3, matrix: matrix2, subtractScalar: subtractScalar2, multiply: multiply2, divideScalar: divideScalar2, isZero: isZero3, unaryMinus: unaryMinus2 }) => {
+  ({ typed: typed3, matrix: matrix2, subtractScalar: subtractScalar2, multiply: multiply2, divideScalar: divideScalar2, isZero: isZero4, unaryMinus: unaryMinus2 }) => {
     return typed3(name96, {
       any: function(x) {
         return clone(x);
@@ -25321,10 +25783,10 @@ var createDet = /* @__PURE__ */ factory(
         }
         for (let k = 0; k < rows; k++) {
           let k_ = rowIndices[k];
-          if (isZero3(matrix3[k_][k])) {
+          if (isZero4(matrix3[k_][k])) {
             let _k;
             for (_k = k + 1; _k < rows; _k++) {
-              if (!isZero3(matrix3[rowIndices[_k]][k])) {
+              if (!isZero4(matrix3[rowIndices[_k]][k])) {
                 k_ = rowIndices[_k];
                 rowIndices[_k] = rowIndices[k];
                 rowIndices[k] = k_;
@@ -28349,11 +28811,11 @@ function _getObjectProperty(object, index) {
   if (index.size().length !== 1) {
     throw new DimensionError(index.size(), 1);
   }
-  const key = index.dimension(0);
-  if (typeof key !== "string") {
+  const key2 = index.dimension(0);
+  if (typeof key2 !== "string") {
     throw new TypeError("String expected as index to retrieve an object property");
   }
-  return getSafeProperty(object, key);
+  return getSafeProperty(object, key2);
 }
 function _setObjectProperty(object, index, replacement) {
   if (isEmptyIndex(index)) {
@@ -28362,12 +28824,12 @@ function _setObjectProperty(object, index, replacement) {
   if (index.size().length !== 1) {
     throw new DimensionError(index.size(), 1);
   }
-  const key = index.dimension(0);
-  if (typeof key !== "string") {
+  const key2 = index.dimension(0);
+  if (typeof key2 !== "string") {
     throw new TypeError("String expected as index to retrieve an object property");
   }
   const updated = clone(object);
-  setSafeProperty(updated, key, replacement);
+  setSafeProperty(updated, key2, replacement);
   return updated;
 }
 
@@ -30193,7 +30655,7 @@ var dependencies143 = ["typed", "config", "divideScalar", "log", "Complex"];
 var createLog1p = /* @__PURE__ */ factory(
   name143,
   dependencies143,
-  ({ typed: typed3, config: config2, divideScalar: divideScalar2, log: log4, Complex: Complex13 }) => {
+  ({ typed: typed3, config: config2, divideScalar: divideScalar2, log: log5, Complex: Complex13 }) => {
     return typed3(name143, {
       number: function(x) {
         if (x >= -1 || config2.predictable) {
@@ -30216,7 +30678,7 @@ var createLog1p = /* @__PURE__ */ factory(
       ),
       "any, any": typed3.referToSelf(
         (self) => (x, base) => {
-          return divideScalar2(self(x), log4(base));
+          return divideScalar2(self(x), log5(base));
         }
       )
     });
@@ -32237,7 +32699,7 @@ var createQr = /* @__PURE__ */ factory(
     matrix: matrix2,
     zeros: zeros4,
     identity: identity2,
-    isZero: isZero3,
+    isZero: isZero4,
     equal: equal2,
     sign: sign3,
     sqrt: sqrt2,
@@ -32323,7 +32785,7 @@ var createQr = /* @__PURE__ */ factory(
           alphaSquared = addScalar2(alphaSquared, multiplyScalar2(Rdata[i][k], conj3(Rdata[i][k])));
         }
         const alpha = multiplyScalar2(sgn, sqrt2(alphaSquared));
-        if (!isZero3(alpha)) {
+        if (!isZero4(alpha)) {
           const u1 = subtractScalar2(pivot, alpha);
           w[k] = 1;
           for (i = k + 1; i < rows; i++) {
@@ -32415,7 +32877,7 @@ var createRange = /* @__PURE__ */ factory(
     larger: larger2,
     largerEq: largerEq2,
     add: add5,
-    isZero: isZero3,
+    isZero: isZero4,
     isPositive: isPositive2
   }) => {
     return typed3(name174, {
@@ -32522,7 +32984,7 @@ var createRange = /* @__PURE__ */ factory(
     }
     function _range(start, end, step, includeEnd) {
       const array = [];
-      if (isZero3(step)) throw new Error("Step must be non-zero");
+      if (isZero4(step)) throw new Error("Step must be non-zero");
       const ongoing = isPositive2(step) ? includeEnd ? smallerEq2 : smaller2 : includeEnd ? largerEq2 : larger2;
       let x = start;
       while (ongoing(x, end)) {
@@ -32790,10 +33252,10 @@ var dependencies177 = ["typed", "compareText", "isZero"];
 var createEqualText = /* @__PURE__ */ factory(
   name177,
   dependencies177,
-  ({ typed: typed3, compareText: compareText4, isZero: isZero3 }) => {
+  ({ typed: typed3, compareText: compareText4, isZero: isZero4 }) => {
     return typed3(name177, {
       "any, any": function(x, y) {
-        return isZero3(compareText4(x, y));
+        return isZero4(compareText4(x, y));
       }
     });
   }
@@ -34359,9 +34821,9 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
         return obj;
       }
       if (isObjectNode(obj) && index.dimensions.length === 1 && isConstantNode(index.dimensions[0])) {
-        const key = index.dimensions[0].value;
-        if (key in obj.properties) {
-          return obj.properties[key];
+        const key2 = index.dimensions[0].value;
+        if (key2 in obj.properties) {
+          return obj.properties[key2];
         }
         return new ConstantNode();
       }
@@ -35464,9 +35926,9 @@ var createFibonacciHeapClass = /* @__PURE__ */ factory(
        * list of this heap. Running time: O(1) actual.
        * @memberof FibonacciHeap
        */
-      insert(key, value) {
+      insert(key2, value) {
         const node = {
-          key,
+          key: key2,
           value,
           degree: 0
         };
@@ -35476,7 +35938,7 @@ var createFibonacciHeapClass = /* @__PURE__ */ factory(
           node.right = minimum.right;
           minimum.right = node;
           node.right.left = node;
-          if (smaller2(key, minimum.key)) {
+          if (smaller2(key2, minimum.key)) {
             this._minimum = node;
           }
         } else {
@@ -35558,8 +36020,8 @@ var createFibonacciHeapClass = /* @__PURE__ */ factory(
         this.extractMinimum();
       }
     }
-    function _decreaseKey(minimum, node, key) {
-      node.key = key;
+    function _decreaseKey(minimum, node, key2) {
+      node.key = key2;
       const parent = node.parent;
       if (parent && smaller2(node.key, parent.key)) {
         _cut(minimum, node, parent);
@@ -37150,7 +37612,7 @@ var createIntersect = /* @__PURE__ */ factory(
     smaller: smaller2,
     equalScalar: equalScalar3,
     flatten: flatten5,
-    isZero: isZero3,
+    isZero: isZero4,
     isNumeric: isNumeric2
   }) => {
     return typed3("intersect", {
@@ -37265,7 +37727,7 @@ var createIntersect = /* @__PURE__ */ factory(
         multiplyScalar2(d1[0], d2[1]),
         multiplyScalar2(d2[0], d1[1])
       );
-      if (isZero3(det2)) return null;
+      if (isZero4(det2)) return null;
       if (smaller2(abs2(det2), config2.relTol)) {
         return null;
       }
@@ -37339,7 +37801,7 @@ var createIntersect = /* @__PURE__ */ factory(
         multiplyScalar2(d2121, d4343),
         multiplyScalar2(d4321, d4321)
       );
-      if (isZero3(denominator)) return null;
+      if (isZero4(denominator)) return null;
       const ta = divideScalar2(numerator, denominator);
       const tb = divideScalar2(addScalar2(d1343, multiplyScalar2(ta, d4321)), d4343);
       const pax = addScalar2(x1, multiplyScalar2(ta, subtract3(x2, x1)));
@@ -37811,7 +38273,7 @@ var createKldivergence = /* @__PURE__ */ factory(
     multiply: multiply2,
     map: map3,
     dotDivide: dotDivide2,
-    log: log4,
+    log: log5,
     isNumeric: isNumeric2
   }) => {
     return typed3(name223, {
@@ -37853,7 +38315,7 @@ var createKldivergence = /* @__PURE__ */ factory(
       const result = sum3(
         multiply2(
           qnorm,
-          map3(dotDivide2(qnorm, pnorm), (x) => log4(x))
+          map3(dotDivide2(qnorm, pnorm), (x) => log5(x))
         )
       );
       if (isNumeric2(result)) {
@@ -38561,7 +39023,7 @@ var createSimplifyCore = /* @__PURE__ */ factory(
     typed: typed3,
     parse: _parse2,
     equal: equal2,
-    isZero: isZero3,
+    isZero: isZero4,
     add: _add,
     subtract: _subtract,
     multiply: _multiply2,
@@ -38659,10 +39121,10 @@ var createSimplifyCore = /* @__PURE__ */ factory(
         const a0 = _simplifyCore(node.args[0], options);
         let a1 = _simplifyCore(node.args[1], options);
         if (node.op === "+") {
-          if (isConstantNode(a0) && isZero3(a0.value)) {
+          if (isConstantNode(a0) && isZero4(a0.value)) {
             return a1;
           }
-          if (isConstantNode(a1) && isZero3(a1.value)) {
+          if (isConstantNode(a1) && isZero4(a1.value)) {
             return a0;
           }
           if (isOperatorNode(a1) && a1.isUnary() && a1.op === "-") {
@@ -38674,24 +39136,24 @@ var createSimplifyCore = /* @__PURE__ */ factory(
           if (isOperatorNode(a1) && a1.isUnary() && a1.op === "-") {
             return _simplifyCore(new OperatorNode("+", "add", [a0, a1.args[0]]), options);
           }
-          if (isConstantNode(a0) && isZero3(a0.value)) {
+          if (isConstantNode(a0) && isZero4(a0.value)) {
             return _simplifyCore(new OperatorNode("-", "unaryMinus", [a1]));
           }
-          if (isConstantNode(a1) && isZero3(a1.value)) {
+          if (isConstantNode(a1) && isZero4(a1.value)) {
             return a0;
           }
           return new OperatorNode(node.op, node.fn, [a0, a1]);
         }
         if (node.op === "*") {
           if (isConstantNode(a0)) {
-            if (isZero3(a0.value)) {
+            if (isZero4(a0.value)) {
               return node0;
             } else if (equal2(a0.value, 1)) {
               return a1;
             }
           }
           if (isConstantNode(a1)) {
-            if (isZero3(a1.value)) {
+            if (isZero4(a1.value)) {
               return node0;
             } else if (equal2(a1.value, 1)) {
               return a0;
@@ -38703,7 +39165,7 @@ var createSimplifyCore = /* @__PURE__ */ factory(
           return new OperatorNode(node.op, node.fn, [a0, a1], node.implicit);
         }
         if (node.op === "/") {
-          if (isConstantNode(a0) && isZero3(a0.value)) {
+          if (isConstantNode(a0) && isZero4(a0.value)) {
             return node0;
           }
           if (isConstantNode(a1) && equal2(a1.value, 1)) {
@@ -38713,7 +39175,7 @@ var createSimplifyCore = /* @__PURE__ */ factory(
         }
         if (node.op === "^") {
           if (isConstantNode(a1)) {
-            if (isZero3(a1.value)) {
+            if (isZero4(a1.value)) {
               return node1;
             } else if (equal2(a1.value, 1)) {
               return a0;
@@ -38811,7 +39273,7 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
   dependencies234,
   ({
     typed: typed3,
-    isZero: isZero3,
+    isZero: isZero4,
     equalScalar: equalScalar3,
     add: add5,
     subtract: subtract3,
@@ -38827,7 +39289,7 @@ var createPolynomialRoot = /* @__PURE__ */ factory(
     return typed3(name234, {
       "number|Complex, ...number|Complex": (constant, restCoeffs) => {
         const coeffs = [constant, ...restCoeffs];
-        while (coeffs.length > 0 && isZero3(coeffs[coeffs.length - 1])) {
+        while (coeffs.length > 0 && isZero4(coeffs[coeffs.length - 1])) {
           coeffs.pop();
         }
         if (coeffs.length < 2) {
@@ -41002,10 +41464,10 @@ var createSimplify = /* @__PURE__ */ factory(
         const native = /* @__PURE__ */ new Map();
         const sm = scope;
         if (typeof sm.forEach === "function") {
-          sm.forEach((value, key) => native.set(key, value));
+          sm.forEach((value, key2) => native.set(key2, value));
         } else {
-          for (const [key, value] of Object.entries(scope)) {
-            native.set(key, value);
+          for (const [key2, value] of Object.entries(scope)) {
+            native.set(key2, value);
           }
         }
         scope = native;
@@ -41195,19 +41657,19 @@ var createSimplify = /* @__PURE__ */ factory(
       } else if (!match2.placeholders) {
         return match1;
       }
-      for (const key in match1.placeholders) {
-        if (hasOwnProperty(match1.placeholders, key)) {
-          res.placeholders[key] = match1.placeholders[key];
-          if (hasOwnProperty(match2.placeholders, key)) {
-            if (!_exactMatch(match1.placeholders[key], match2.placeholders[key])) {
+      for (const key2 in match1.placeholders) {
+        if (hasOwnProperty(match1.placeholders, key2)) {
+          res.placeholders[key2] = match1.placeholders[key2];
+          if (hasOwnProperty(match2.placeholders, key2)) {
+            if (!_exactMatch(match1.placeholders[key2], match2.placeholders[key2])) {
               return null;
             }
           }
         }
       }
-      for (const key in match2.placeholders) {
-        if (hasOwnProperty(match2.placeholders, key)) {
-          res.placeholders[key] = match2.placeholders[key];
+      for (const key2 in match2.placeholders) {
+        if (hasOwnProperty(match2.placeholders, key2)) {
+          res.placeholders[key2] = match2.placeholders[key2];
         }
       }
       return res;
@@ -41449,7 +41911,7 @@ var createDerivative = /* @__PURE__ */ factory(
     parse: parse3,
     simplify: simplify2,
     equal: equal2,
-    isZero: isZero3,
+    isZero: isZero4,
     numeric: numeric2,
     ConstantNode,
     FunctionNode,
@@ -41925,7 +42387,7 @@ var createDerivative = /* @__PURE__ */ factory(
           const arg0 = node.args[0];
           const arg1 = node.args[1];
           if (isConst2(arg0)) {
-            if (isConstantNode(arg0) && (isZero3(arg0.value) || equal2(arg0.value, 1))) {
+            if (isConstantNode(arg0) && (isZero4(arg0.value) || equal2(arg0.value, 1))) {
               return createConstantNode2(0);
             }
             return new OperatorNode("*", "multiply", [
@@ -41938,7 +42400,7 @@ var createDerivative = /* @__PURE__ */ factory(
           }
           if (isConst2(arg1)) {
             if (isConstantNode(arg1)) {
-              if (isZero3(arg1.value)) {
+              if (isZero4(arg1.value)) {
                 return createConstantNode2(0);
               }
               if (equal2(arg1.value, 1)) {
@@ -43515,7 +43977,7 @@ var hasNumericValue = createHasNumericValue(
   factoryScope
 );
 var isFinite2 = createIsFinite(factoryScope);
-var isZero2 = createIsZero(factoryScope);
+var isZero3 = createIsZero(factoryScope);
 var factory_unaryPlus = createUnaryPlus(
   factoryScope
 );
@@ -43527,7 +43989,7 @@ factoryScope.unaryPlus = factory_unaryPlus;
 factoryScope.flatten = flatten3;
 factoryScope.hasNumericValue = hasNumericValue;
 factoryScope.isFinite = isFinite2;
-factoryScope.isZero = isZero2;
+factoryScope.isZero = isZero3;
 factoryScope.prod = prod;
 factoryScope.dot = factory_dot;
 factoryScope.squeeze = squeeze2;
@@ -44220,7 +44682,7 @@ var mathScope = {
 };
 {
   const mwt = factoryScope.mathWithTransform;
-  for (const key of [
+  for (const key2 of [
     "and",
     "bitAnd",
     "bitOr",
@@ -44247,7 +44709,7 @@ var mathScope = {
     "sum",
     "variance"
   ]) {
-    if (typeof mwt[key] === "function") mathScope[key] = mwt[key];
+    if (typeof mwt[key2] === "function") mathScope[key2] = mwt[key2];
   }
 }
 var parse = factoryScope.parse;
@@ -44278,7 +44740,7 @@ function parser() {
     },
     /** Clear all retained variables. */
     clear() {
-      for (const key of Object.keys(scope)) delete scope[key];
+      for (const key2 of Object.keys(scope)) delete scope[key2];
     }
   };
 }
@@ -44916,9 +45378,9 @@ function numericRealRoots(expr, varName) {
   const addRoot = (r) => {
     const rounded = Math.round(r);
     const clean = Math.abs(r - rounded) < 1e-8 ? rounded : r;
-    const key = clean.toFixed(8);
-    if (!seen.has(key)) {
-      seen.add(key);
+    const key2 = clean.toFixed(8);
+    if (!seen.has(key2)) {
+      seen.add(key2);
       roots.push(clean);
     }
   };
@@ -44987,9 +45449,9 @@ function solve(equation, varName) {
       return Math.abs(x - rounded) < 1e-8 ? rounded : x;
     }, pushReal2 = function(x) {
       const clean = cleanComponent2(x);
-      const key = `r${clean.toFixed(8)}`;
-      if (!seen.has(key)) {
-        seen.add(key);
+      const key2 = `r${clean.toFixed(8)}`;
+      if (!seen.has(key2)) {
+        seen.add(key2);
         reals.push(clean);
       }
     };
@@ -45020,9 +45482,9 @@ function solve(equation, varName) {
         } else {
           const re3 = cleanComponent2(r.re);
           const im3 = cleanComponent2(r.im);
-          const key = `${re3.toFixed(8)}|${im3.toFixed(8)}`;
-          if (!seen.has(key)) {
-            seen.add(key);
+          const key2 = `${re3.toFixed(8)}|${im3.toFixed(8)}`;
+          if (!seen.has(key2)) {
+            seen.add(key2);
             complexRoots.push(new Complex10(re3, im3));
           }
         }
@@ -45103,15 +45565,15 @@ function asymptotic(expr, varName, towards = Infinity) {
     const avgOrder = (logRatio1 + logRatio2) / 2;
     const roundedOrder = Math.round(avgOrder * 2) / 2;
     const coefficient = f3 / Math.pow(x3, roundedOrder);
-    let leadingTerm;
+    let leadingTerm2;
     if (roundedOrder === 0) {
-      leadingTerm = formatCoeff(coefficient);
+      leadingTerm2 = formatCoeff(coefficient);
     } else if (roundedOrder === 1) {
-      leadingTerm = `${formatCoeff(coefficient)}*${varName}`;
+      leadingTerm2 = `${formatCoeff(coefficient)}*${varName}`;
     } else {
-      leadingTerm = `${formatCoeff(coefficient)}*${varName}^${roundedOrder}`;
+      leadingTerm2 = `${formatCoeff(coefficient)}*${varName}^${roundedOrder}`;
     }
-    return { leadingTerm, order: roundedOrder, coefficient };
+    return { leadingTerm: leadingTerm2, order: roundedOrder, coefficient };
   }
   const lim = limit(expr, varName, towards);
   return { leadingTerm: formatCoeff(lim), order: 0, coefficient: lim };
@@ -45716,8 +46178,8 @@ function _combineLikeTerms(expr) {
     const cvpMatch = t.match(/^(-?\d*\.?\d*)\s*\*?\s*(\w+)\^(\d+)$/);
     if (cvpMatch) {
       const c = cvpMatch[1] === "" || cvpMatch[1] === "+" ? 1 : cvpMatch[1] === "-" ? -1 : Number(cvpMatch[1]);
-      const key = cvpMatch[2] + "^" + cvpMatch[3];
-      termMap.set(key, (termMap.get(key) ?? 0) + c);
+      const key2 = cvpMatch[2] + "^" + cvpMatch[3];
+      termMap.set(key2, (termMap.get(key2) ?? 0) + c);
       continue;
     }
     const cvMatch = t.match(/^(-?\d*\.?\d*)\s*\*?\s*(\w+)$/);
@@ -45729,16 +46191,16 @@ function _combineLikeTerms(expr) {
     otherTerms.push(t);
   }
   const parts = [];
-  for (const [key, c] of termMap) {
+  for (const [key2, c] of termMap) {
     if (Math.abs(c) < 1e-12) continue;
-    if (key === "__const__") {
+    if (key2 === "__const__") {
       parts.push(String(c));
     } else if (Math.abs(c - 1) < 1e-12) {
-      parts.push(key);
+      parts.push(key2);
     } else if (Math.abs(c + 1) < 1e-12) {
-      parts.push("-" + key);
+      parts.push("-" + key2);
     } else {
-      parts.push(c + "*" + key);
+      parts.push(c + "*" + key2);
     }
   }
   parts.push(...otherTerms);
@@ -45892,8 +46354,8 @@ function casSimplify(input) {
         const cvpMatch = t.match(/^(-?\d*\.?\d*)\s*\*?\s*(\w+)\^(\d+)$/);
         if (cvpMatch) {
           const c = cvpMatch[1] === "" || cvpMatch[1] === "+" ? 1 : cvpMatch[1] === "-" ? -1 : Number(cvpMatch[1]);
-          const key = cvpMatch[2] + "^" + cvpMatch[3];
-          termMap.set(key, (termMap.get(key) ?? 0) + c);
+          const key2 = cvpMatch[2] + "^" + cvpMatch[3];
+          termMap.set(key2, (termMap.get(key2) ?? 0) + c);
           continue;
         }
         const cvMatch = t.match(/^(-?\d*\.?\d*)\s*\*?\s*(\w+)$/);
@@ -45905,16 +46367,16 @@ function casSimplify(input) {
         otherTerms.push(t);
       }
       const parts = [];
-      for (const [key, c] of termMap) {
+      for (const [key2, c] of termMap) {
         if (Math.abs(c) < 1e-12) continue;
-        if (key === "__const__") {
+        if (key2 === "__const__") {
           parts.push(String(c));
         } else if (Math.abs(c - 1) < 1e-12) {
-          parts.push(key);
+          parts.push(key2);
         } else if (Math.abs(c + 1) < 1e-12) {
-          parts.push("-" + key);
+          parts.push("-" + key2);
         } else {
-          parts.push(c + "*" + key);
+          parts.push(c + "*" + key2);
         }
       }
       parts.push(...otherTerms);
@@ -46140,16 +46602,16 @@ function discreteLog(g, h, p) {
   const table = /* @__PURE__ */ new Map();
   let cur = 1n;
   for (let j = 0n; j < m; j++) {
-    const key = cur.toString();
-    if (!table.has(key)) table.set(key, j);
+    const key2 = cur.toString();
+    if (!table.has(key2)) table.set(key2, j);
     cur = cur * G % P2;
   }
   const gm = modPowBig(G, m, P2);
   const gInvM = modInverseBig(gm, P2);
   let gamma2 = H;
   for (let i = 0n; i < m; i++) {
-    const key = gamma2.toString();
-    const j = table.get(key);
+    const key2 = gamma2.toString();
+    const j = table.get(key2);
     if (j !== void 0) {
       return Number(i * m + j);
     }
@@ -52808,14 +53270,14 @@ function alphaShape(points, alpha) {
       [t[2], t[0]]
     ];
     for (const [u, v] of es) {
-      const key = `${Math.min(u, v)},${Math.max(u, v)}`;
-      edgeCount.set(key, (edgeCount.get(key) ?? 0) + 1);
+      const key2 = `${Math.min(u, v)},${Math.max(u, v)}`;
+      edgeCount.set(key2, (edgeCount.get(key2) ?? 0) + 1);
     }
   }
   const edges = [];
-  for (const [key, count2] of edgeCount) {
+  for (const [key2, count2] of edgeCount) {
     if (count2 === 1) {
-      const [lo, hi] = key.split(",").map(Number);
+      const [lo, hi] = key2.split(",").map(Number);
       edges.push([lo, hi]);
     }
   }
@@ -53056,9 +53518,9 @@ function halfspaceIntersection(halfspaces, interiorPoint) {
   const vertices = [];
   const seen = /* @__PURE__ */ new Set();
   for (const v of candidates) {
-    const key = quantum > 0 ? v.map((x) => Math.round(x / quantum)).join(",") : v.join(",");
-    if (seen.has(key)) continue;
-    seen.add(key);
+    const key2 = quantum > 0 ? v.map((x) => Math.round(x / quantum)).join(",") : v.join(",");
+    if (seen.has(key2)) continue;
+    seen.add(key2);
     vertices.push(v);
   }
   if (dim === 2 && vertices.length > 2) {
@@ -53733,8 +54195,8 @@ function buildMatrix(cls, q) {
 }
 var modeCache = /* @__PURE__ */ new Map();
 function solveClass(cls, q) {
-  const key = `${cls}:${q}`;
-  const cached = modeCache.get(key);
+  const key2 = `${cls}:${q}`;
+  const cached = modeCache.get(key2);
   if (cached) return cached;
   const harmonics = harmonicsFor(cls);
   const { values, vectors } = eig4(buildMatrix(cls, q));
@@ -53758,7 +54220,7 @@ function solveClass(cls, q) {
     for (let k = 0; k < N; k++) coeffs[k] *= sign3;
     return { a: values[idx].re, coeffs, harmonics };
   });
-  modeCache.set(key, modes);
+  modeCache.set(key2, modes);
   return modes;
 }
 function checkOrder(n, min2, name254) {
@@ -55529,7 +55991,7 @@ export {
   isNumeric,
   isPositive,
   isPrime2 as isPrime,
-  isZero2 as isZero,
+  isZero3 as isZero,
   istft,
   jacobiCN,
   jacobiDN,
@@ -55966,7 +56428,7 @@ export {
   studentizedRangeQuantile,
   subfactorial,
   subset,
-  substitute,
+  substitute2 as substitute,
   subtract,
   subtractScalar,
   sum,