@optave/codegraph 3.8.0 → 3.9.0

package/src/graph/algorithms/leiden/partition.ts

@@ -56,6 +56,34 @@ function u8get(a: Uint8Array, i: number): number {
   return a[i] as number;
 }
 
+/* ------------------------------------------------------------------ */
+/*  Internal mutable state bucket shared by all extracted functions    */
+/* ------------------------------------------------------------------ */
+
+interface PartitionState {
+  graph: GraphAdapter;
+  n: number;
+  nodeCommunity: Int32Array;
+  communityCount: number;
+  communityTotalSize: Float64Array;
+  communityNodeCount: Int32Array;
+  communityInternalEdgeWeight: Float64Array;
+  communityTotalStrength: Float64Array;
+  communityTotalOutStrength: Float64Array;
+  communityTotalInStrength: Float64Array;
+  /* scratch arrays for neighbor accumulation */
+  candidateCommunities: Int32Array;
+  candidateCommunityCount: number;
+  neighborEdgeWeightToCommunity: Float64Array;
+  outEdgeWeightToCommunity: Float64Array;
+  inEdgeWeightFromCommunity: Float64Array;
+  isCandidateCommunity: Uint8Array;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Aggregate helpers (shared by initializeAggregates & compact)      */
+/* ------------------------------------------------------------------ */
+
 /**
  * Accumulate per-community node-level totals (size, count, strength) into the
  * provided aggregate arrays. Both `initializeAggregates` and `compactCommunityIds`
@@ -159,343 +187,380 @@ function buildSortedCommunityIds(
   }
 }
 
-export function makePartition(graph: GraphAdapter): Partition {
-  const n: number = graph.n;
-  const nodeCommunity = new Int32Array(n);
-  for (let i = 0; i < n; i++) nodeCommunity[i] = i;
-  let communityCount: number = n;
-
-  let communityTotalSize = new Float64Array(communityCount);
-  let communityNodeCount = new Int32Array(communityCount);
-  let communityInternalEdgeWeight = new Float64Array(communityCount);
-  let communityTotalStrength = new Float64Array(communityCount);
-  let communityTotalOutStrength = new Float64Array(communityCount);
-  let communityTotalInStrength = new Float64Array(communityCount);
-
-  const candidateCommunities = new Int32Array(n);
-  let candidateCommunityCount: number = 0;
-  const neighborEdgeWeightToCommunity = new Float64Array(n);
-  const outEdgeWeightToCommunity = new Float64Array(n);
-  const inEdgeWeightFromCommunity = new Float64Array(n);
-  const isCandidateCommunity = new Uint8Array(n);
-
-  function ensureCommCapacity(newCount: number): void {
-    if (newCount <= communityTotalSize.length) return;
-    const growTo: number = Math.max(newCount, Math.ceil(communityTotalSize.length * 1.5));
-    communityTotalSize = growFloat(communityTotalSize, growTo);
-    communityNodeCount = growInt(communityNodeCount, growTo);
-    communityInternalEdgeWeight = growFloat(communityInternalEdgeWeight, growTo);
-    communityTotalStrength = growFloat(communityTotalStrength, growTo);
-    communityTotalOutStrength = growFloat(communityTotalOutStrength, growTo);
-    communityTotalInStrength = growFloat(communityTotalInStrength, growTo);
-  }
+/* ------------------------------------------------------------------ */
+/*  Extracted: capacity management                                     */
+/* ------------------------------------------------------------------ */
 
-  function initializeAggregates(): void {
-    communityTotalSize.fill(0);
-    communityNodeCount.fill(0);
-    communityInternalEdgeWeight.fill(0);
-    communityTotalStrength.fill(0);
-    communityTotalOutStrength.fill(0);
-    communityTotalInStrength.fill(0);
-    accumulateNodeAggregates(
-      graph,
-      nodeCommunity,
-      n,
-      communityTotalSize,
-      communityNodeCount,
-      communityInternalEdgeWeight,
-      communityTotalStrength,
-      communityTotalOutStrength,
-      communityTotalInStrength,
-    );
-    accumulateInternalEdgeWeights(graph, nodeCommunity, n, communityInternalEdgeWeight);
+function ensureCommCapacity(s: PartitionState, newCount: number): void {
+  if (newCount <= s.communityTotalSize.length) return;
+  const growTo: number = Math.max(newCount, Math.ceil(s.communityTotalSize.length * 1.5));
+  s.communityTotalSize = growFloat(s.communityTotalSize, growTo);
+  s.communityNodeCount = growInt(s.communityNodeCount, growTo);
+  s.communityInternalEdgeWeight = growFloat(s.communityInternalEdgeWeight, growTo);
+  s.communityTotalStrength = growFloat(s.communityTotalStrength, growTo);
+  s.communityTotalOutStrength = growFloat(s.communityTotalOutStrength, growTo);
+  s.communityTotalInStrength = growFloat(s.communityTotalInStrength, growTo);
+}
+
+/* ------------------------------------------------------------------ */
+/*  Extracted: aggregate initialization                                */
+/* ------------------------------------------------------------------ */
+
+function initAggregates(s: PartitionState): void {
+  s.communityTotalSize.fill(0);
+  s.communityNodeCount.fill(0);
+  s.communityInternalEdgeWeight.fill(0);
+  s.communityTotalStrength.fill(0);
+  s.communityTotalOutStrength.fill(0);
+  s.communityTotalInStrength.fill(0);
+  accumulateNodeAggregates(
+    s.graph,
+    s.nodeCommunity,
+    s.n,
+    s.communityTotalSize,
+    s.communityNodeCount,
+    s.communityInternalEdgeWeight,
+    s.communityTotalStrength,
+    s.communityTotalOutStrength,
+    s.communityTotalInStrength,
+  );
+  accumulateInternalEdgeWeights(s.graph, s.nodeCommunity, s.n, s.communityInternalEdgeWeight);
+}
+
+/* ------------------------------------------------------------------ */
+/*  Extracted: neighbor accumulation                                   */
+/* ------------------------------------------------------------------ */
+
+function resetScratch(s: PartitionState): void {
+  for (let i = 0; i < s.candidateCommunityCount; i++) {
+    const c: number = iget(s.candidateCommunities, i);
+    s.isCandidateCommunity[c] = 0;
+    s.neighborEdgeWeightToCommunity[c] = 0;
+    s.outEdgeWeightToCommunity[c] = 0;
+    s.inEdgeWeightFromCommunity[c] = 0;
   }
+  s.candidateCommunityCount = 0;
+}
 
-  function resetScratch(): void {
-    for (let i = 0; i < candidateCommunityCount; i++) {
-      const c: number = iget(candidateCommunities, i);
-      isCandidateCommunity[c] = 0;
-      neighborEdgeWeightToCommunity[c] = 0;
-      outEdgeWeightToCommunity[c] = 0;
-      inEdgeWeightFromCommunity[c] = 0;
+function touchCandidate(s: PartitionState, c: number): void {
+  if (u8get(s.isCandidateCommunity, c)) return;
+  s.isCandidateCommunity[c] = 1;
+  s.candidateCommunities[s.candidateCommunityCount++] = c;
+}
+
+function accumulateNeighborWeights(s: PartitionState, v: number): number {
+  resetScratch(s);
+  const ci: number = iget(s.nodeCommunity, v);
+  touchCandidate(s, ci);
+  if (s.graph.directed) {
+    const outL = s.graph.outEdges[v]!;
+    for (let k = 0; k < outL.length; k++) {
+      const j: number = outL[k]!.to;
+      const w: number = outL[k]!.w;
+      const cj: number = iget(s.nodeCommunity, j);
+      touchCandidate(s, cj);
+      s.outEdgeWeightToCommunity[cj] = fget(s.outEdgeWeightToCommunity, cj) + w;
+    }
+    const inL = s.graph.inEdges[v]!;
+    for (let k = 0; k < inL.length; k++) {
+      const i2: number = inL[k]!.from;
+      const w: number = inL[k]!.w;
+      const ci2: number = iget(s.nodeCommunity, i2);
+      touchCandidate(s, ci2);
+      s.inEdgeWeightFromCommunity[ci2] = fget(s.inEdgeWeightFromCommunity, ci2) + w;
+    }
+  } else {
+    const list = s.graph.outEdges[v]!;
+    for (let k = 0; k < list.length; k++) {
+      const j: number = list[k]!.to;
+      const w: number = list[k]!.w;
+      const cj: number = iget(s.nodeCommunity, j);
+      touchCandidate(s, cj);
+      s.neighborEdgeWeightToCommunity[cj] = fget(s.neighborEdgeWeightToCommunity, cj) + w;
     }
-    candidateCommunityCount = 0;
   }
+  return s.candidateCommunityCount;
+}
+
+/* ------------------------------------------------------------------ */
+/*  Extracted: modularity delta computations                           */
+/* ------------------------------------------------------------------ */
 
-  function touch(c: number): void {
-    if (u8get(isCandidateCommunity, c)) return;
-    isCandidateCommunity[c] = 1;
-    candidateCommunities[candidateCommunityCount++] = c;
+function computeDeltaModularityUndirected(
+  s: PartitionState,
+  v: number,
+  newC: number,
+  gamma: number = 1.0,
+): number {
+  const oldC: number = iget(s.nodeCommunity, v);
+  if (newC === oldC) return 0;
+  const twoM: number = s.graph.totalWeight;
+  const strengthV: number = fget(s.graph.strengthOut, v);
+  const weightToNew: number =
+    newC < s.neighborEdgeWeightToCommunity.length
+      ? fget(s.neighborEdgeWeightToCommunity, newC) || 0
+      : 0;
+  const weightToOld: number = fget(s.neighborEdgeWeightToCommunity, oldC) || 0;
+  const totalStrengthNew: number =
+    newC < s.communityTotalStrength.length ? fget(s.communityTotalStrength, newC) : 0;
+  const totalStrengthOld: number = fget(s.communityTotalStrength, oldC);
+  const gain_remove: number = -(
+    weightToOld / twoM -
+    (gamma * (strengthV * totalStrengthOld)) / (twoM * twoM)
+  );
+  const gain_add: number =
+    weightToNew / twoM - (gamma * (strengthV * totalStrengthNew)) / (twoM * twoM);
+  return gain_remove + gain_add;
+}
+
+function computeDeltaModularityDirected(
+  s: PartitionState,
+  v: number,
+  newC: number,
+  gamma: number = 1.0,
+): number {
+  const oldC: number = iget(s.nodeCommunity, v);
+  if (newC === oldC) return 0;
+  const totalEdgeWeight: number = s.graph.totalWeight;
+  const strengthOutV: number = fget(s.graph.strengthOut, v);
+  const strengthInV: number = fget(s.graph.strengthIn, v);
+  const inFromNew: number =
+    newC < s.inEdgeWeightFromCommunity.length ? fget(s.inEdgeWeightFromCommunity, newC) || 0 : 0;
+  const outToNew: number =
+    newC < s.outEdgeWeightToCommunity.length ? fget(s.outEdgeWeightToCommunity, newC) || 0 : 0;
+  const inFromOld: number = fget(s.inEdgeWeightFromCommunity, oldC) || 0;
+  const outToOld: number = fget(s.outEdgeWeightToCommunity, oldC) || 0;
+  const totalInStrengthNew: number =
+    newC < s.communityTotalInStrength.length ? fget(s.communityTotalInStrength, newC) : 0;
+  const totalOutStrengthNew: number =
+    newC < s.communityTotalOutStrength.length ? fget(s.communityTotalOutStrength, newC) : 0;
+  const totalInStrengthOld: number = fget(s.communityTotalInStrength, oldC);
+  const totalOutStrengthOld: number = fget(s.communityTotalOutStrength, oldC);
+  // Self-loop correction + constant term (see modularity.ts diffModularityDirected)
+  const selfW: number = fget(s.graph.selfLoop, v) || 0;
+  const deltaInternal: number =
+    (inFromNew + outToNew - inFromOld - outToOld + 2 * selfW) / totalEdgeWeight;
+  const deltaExpected: number =
+    (gamma *
+      (strengthOutV * (totalInStrengthNew - totalInStrengthOld) +
+        strengthInV * (totalOutStrengthNew - totalOutStrengthOld) +
+        2 * strengthOutV * strengthInV)) /
+    (totalEdgeWeight * totalEdgeWeight);
+  return deltaInternal - deltaExpected;
+}
+
+function computeDeltaCPM(s: PartitionState, v: number, newC: number, gamma: number = 1.0): number {
+  const oldC: number = iget(s.nodeCommunity, v);
+  if (newC === oldC) return 0;
+  let w_old: number;
+  let w_new: number;
+  let selfCorrection: number = 0;
+  if (s.graph.directed) {
+    w_old =
+      (fget(s.outEdgeWeightToCommunity, oldC) || 0) +
+      (fget(s.inEdgeWeightFromCommunity, oldC) || 0);
+    w_new =
+      newC < s.outEdgeWeightToCommunity.length
+        ? (fget(s.outEdgeWeightToCommunity, newC) || 0) +
+          (fget(s.inEdgeWeightFromCommunity, newC) || 0)
+        : 0;
+    // Self-loop correction (see cpm.ts diffCPM)
+    selfCorrection = 2 * (fget(s.graph.selfLoop, v) || 0);
+  } else {
+    w_old = fget(s.neighborEdgeWeightToCommunity, oldC) || 0;
+    w_new =
+      newC < s.neighborEdgeWeightToCommunity.length
+        ? fget(s.neighborEdgeWeightToCommunity, newC) || 0
+        : 0;
   }
+  const nodeSz: number = fget(s.graph.size, v) || 1;
+  const sizeOld: number = fget(s.communityTotalSize, oldC) || 0;
+  const sizeNew: number = newC < s.communityTotalSize.length ? fget(s.communityTotalSize, newC) : 0;
+  return w_new - w_old + selfCorrection - gamma * nodeSz * (sizeNew - sizeOld + nodeSz);
+}
 
-  function accumulateNeighborCommunityEdgeWeights(v: number): number {
-    resetScratch();
-    const ci: number = iget(nodeCommunity, v);
-    touch(ci);
-    if (graph.directed) {
-      const outL = graph.outEdges[v]!;
-      for (let k = 0; k < outL.length; k++) {
-        const j: number = outL[k]!.to;
-        const w: number = outL[k]!.w;
-        const cj: number = iget(nodeCommunity, j);
-        touch(cj);
-        outEdgeWeightToCommunity[cj] = fget(outEdgeWeightToCommunity, cj) + w;
-      }
-      const inL = graph.inEdges[v]!;
-      for (let k = 0; k < inL.length; k++) {
-        const i2: number = inL[k]!.from;
-        const w: number = inL[k]!.w;
-        const ci2: number = iget(nodeCommunity, i2);
-        touch(ci2);
-        inEdgeWeightFromCommunity[ci2] = fget(inEdgeWeightFromCommunity, ci2) + w;
-      }
-    } else {
-      const list = graph.outEdges[v]!;
-      for (let k = 0; k < list.length; k++) {
-        const j: number = list[k]!.to;
-        const w: number = list[k]!.w;
-        const cj: number = iget(nodeCommunity, j);
-        touch(cj);
-        neighborEdgeWeightToCommunity[cj] = fget(neighborEdgeWeightToCommunity, cj) + w;
-      }
-    }
-    return candidateCommunityCount;
+/* ------------------------------------------------------------------ */
+/*  Extracted: node move                                               */
+/* ------------------------------------------------------------------ */
+
+function moveNode(s: PartitionState, v: number, newC: number): boolean {
+  const oldC: number = iget(s.nodeCommunity, v);
+  if (oldC === newC) return false;
+  if (newC >= s.communityCount) {
+    ensureCommCapacity(s, newC + 1);
+    s.communityCount = newC + 1;
   }
+  const strengthOutV: number = fget(s.graph.strengthOut, v);
+  const strengthInV: number = fget(s.graph.strengthIn, v);
+  const selfLoopWeight: number = fget(s.graph.selfLoop, v);
+  const nodeSz: number = fget(s.graph.size, v);
 
-  const twoMUndirected: number = graph.totalWeight;
-  function deltaModularityUndirected(v: number, newC: number, gamma: number = 1.0): number {
-    const oldC: number = iget(nodeCommunity, v);
-    if (newC === oldC) return 0;
-    const strengthV: number = fget(graph.strengthOut, v);
-    const weightToNew: number =
-      newC < neighborEdgeWeightToCommunity.length
-        ? fget(neighborEdgeWeightToCommunity, newC) || 0
-        : 0;
-    const weightToOld: number = fget(neighborEdgeWeightToCommunity, oldC) || 0;
-    const totalStrengthNew: number =
-      newC < communityTotalStrength.length ? fget(communityTotalStrength, newC) : 0;
-    const totalStrengthOld: number = fget(communityTotalStrength, oldC);
-    const gain_remove: number = -(
-      weightToOld / twoMUndirected -
-      (gamma * (strengthV * totalStrengthOld)) / (twoMUndirected * twoMUndirected)
-    );
-    const gain_add: number =
-      weightToNew / twoMUndirected -
-      (gamma * (strengthV * totalStrengthNew)) / (twoMUndirected * twoMUndirected);
-    return gain_remove + gain_add;
+  s.communityNodeCount[oldC] = iget(s.communityNodeCount, oldC) - 1;
+  s.communityNodeCount[newC] = iget(s.communityNodeCount, newC) + 1;
+  s.communityTotalSize[oldC] = fget(s.communityTotalSize, oldC) - nodeSz;
+  s.communityTotalSize[newC] = fget(s.communityTotalSize, newC) + nodeSz;
+  if (s.graph.directed) {
+    s.communityTotalOutStrength[oldC] = fget(s.communityTotalOutStrength, oldC) - strengthOutV;
+    s.communityTotalOutStrength[newC] = fget(s.communityTotalOutStrength, newC) + strengthOutV;
+    s.communityTotalInStrength[oldC] = fget(s.communityTotalInStrength, oldC) - strengthInV;
+    s.communityTotalInStrength[newC] = fget(s.communityTotalInStrength, newC) + strengthInV;
+  } else {
+    s.communityTotalStrength[oldC] = fget(s.communityTotalStrength, oldC) - strengthOutV;
+    s.communityTotalStrength[newC] = fget(s.communityTotalStrength, newC) + strengthOutV;
   }
 
-  function deltaModularityDirected(v: number, newC: number, gamma: number = 1.0): number {
-    const oldC: number = iget(nodeCommunity, v);
-    if (newC === oldC) return 0;
-    const totalEdgeWeight: number = graph.totalWeight;
-    const strengthOutV: number = fget(graph.strengthOut, v);
-    const strengthInV: number = fget(graph.strengthIn, v);
-    const inFromNew: number =
-      newC < inEdgeWeightFromCommunity.length ? fget(inEdgeWeightFromCommunity, newC) || 0 : 0;
+  if (s.graph.directed) {
+    const outToOld: number = fget(s.outEdgeWeightToCommunity, oldC) || 0;
+    const inFromOld: number = fget(s.inEdgeWeightFromCommunity, oldC) || 0;
     const outToNew: number =
-      newC < outEdgeWeightToCommunity.length ? fget(outEdgeWeightToCommunity, newC) || 0 : 0;
-    const inFromOld: number = fget(inEdgeWeightFromCommunity, oldC) || 0;
-    const outToOld: number = fget(outEdgeWeightToCommunity, oldC) || 0;
-    const totalInStrengthNew: number =
-      newC < communityTotalInStrength.length ? fget(communityTotalInStrength, newC) : 0;
-    const totalOutStrengthNew: number =
-      newC < communityTotalOutStrength.length ? fget(communityTotalOutStrength, newC) : 0;
-    const totalInStrengthOld: number = fget(communityTotalInStrength, oldC);
-    const totalOutStrengthOld: number = fget(communityTotalOutStrength, oldC);
-    // Self-loop correction + constant term (see modularity.ts diffModularityDirected)
-    const selfW: number = fget(graph.selfLoop, v) || 0;
-    const deltaInternal: number =
-      (inFromNew + outToNew - inFromOld - outToOld + 2 * selfW) / totalEdgeWeight;
-    const deltaExpected: number =
-      (gamma *
-        (strengthOutV * (totalInStrengthNew - totalInStrengthOld) +
-          strengthInV * (totalOutStrengthNew - totalOutStrengthOld) +
-          2 * strengthOutV * strengthInV)) /
-      (totalEdgeWeight * totalEdgeWeight);
-    return deltaInternal - deltaExpected;
+      newC < s.outEdgeWeightToCommunity.length ? fget(s.outEdgeWeightToCommunity, newC) || 0 : 0;
+    const inFromNew: number =
+      newC < s.inEdgeWeightFromCommunity.length ? fget(s.inEdgeWeightFromCommunity, newC) || 0 : 0;
+    // outToOld/inFromOld already include the self-loop weight (self-loops are
+    // in outEdges/inEdges), so subtract it once to avoid triple-counting.
+    s.communityInternalEdgeWeight[oldC] =
+      fget(s.communityInternalEdgeWeight, oldC) - (outToOld + inFromOld - selfLoopWeight);
+    s.communityInternalEdgeWeight[newC] =
+      fget(s.communityInternalEdgeWeight, newC) + (outToNew + inFromNew + selfLoopWeight);
+  } else {
+    const weightToOld: number = fget(s.neighborEdgeWeightToCommunity, oldC) || 0;
+    const weightToNew: number = fget(s.neighborEdgeWeightToCommunity, newC) || 0;
+    s.communityInternalEdgeWeight[oldC] =
+      fget(s.communityInternalEdgeWeight, oldC) - (2 * weightToOld + selfLoopWeight);
+    s.communityInternalEdgeWeight[newC] =
+      fget(s.communityInternalEdgeWeight, newC) + (2 * weightToNew + selfLoopWeight);
   }
 
-  function deltaCPM(v: number, newC: number, gamma: number = 1.0): number {
-    const oldC: number = iget(nodeCommunity, v);
-    if (newC === oldC) return 0;
-    let w_old: number;
-    let w_new: number;
-    let selfCorrection: number = 0;
-    if (graph.directed) {
-      w_old =
-        (fget(outEdgeWeightToCommunity, oldC) || 0) + (fget(inEdgeWeightFromCommunity, oldC) || 0);
-      w_new =
-        newC < outEdgeWeightToCommunity.length
-          ? (fget(outEdgeWeightToCommunity, newC) || 0) +
-            (fget(inEdgeWeightFromCommunity, newC) || 0)
-          : 0;
-      // Self-loop correction (see cpm.ts diffCPM)
-      selfCorrection = 2 * (fget(graph.selfLoop, v) || 0);
-    } else {
-      w_old = fget(neighborEdgeWeightToCommunity, oldC) || 0;
-      w_new =
-        newC < neighborEdgeWeightToCommunity.length
-          ? fget(neighborEdgeWeightToCommunity, newC) || 0
-          : 0;
-    }
-    const nodeSz: number = fget(graph.size, v) || 1;
-    const sizeOld: number = fget(communityTotalSize, oldC) || 0;
-    const sizeNew: number = newC < communityTotalSize.length ? fget(communityTotalSize, newC) : 0;
-    return w_new - w_old + selfCorrection - gamma * nodeSz * (sizeNew - sizeOld + nodeSz);
-  }
+  s.nodeCommunity[v] = newC;
+  return true;
+}
 
-  function moveNodeToCommunity(v: number, newC: number): boolean {
-    const oldC: number = iget(nodeCommunity, v);
-    if (oldC === newC) return false;
-    if (newC >= communityCount) {
-      ensureCommCapacity(newC + 1);
-      communityCount = newC + 1;
-    }
-    const strengthOutV: number = fget(graph.strengthOut, v);
-    const strengthInV: number = fget(graph.strengthIn, v);
-    const selfLoopWeight: number = fget(graph.selfLoop, v);
-    const nodeSz: number = fget(graph.size, v);
-
-    communityNodeCount[oldC] = iget(communityNodeCount, oldC) - 1;
-    communityNodeCount[newC] = iget(communityNodeCount, newC) + 1;
-    communityTotalSize[oldC] = fget(communityTotalSize, oldC) - nodeSz;
-    communityTotalSize[newC] = fget(communityTotalSize, newC) + nodeSz;
-    if (graph.directed) {
-      communityTotalOutStrength[oldC] = fget(communityTotalOutStrength, oldC) - strengthOutV;
-      communityTotalOutStrength[newC] = fget(communityTotalOutStrength, newC) + strengthOutV;
-      communityTotalInStrength[oldC] = fget(communityTotalInStrength, oldC) - strengthInV;
-      communityTotalInStrength[newC] = fget(communityTotalInStrength, newC) + strengthInV;
-    } else {
-      communityTotalStrength[oldC] = fget(communityTotalStrength, oldC) - strengthOutV;
-      communityTotalStrength[newC] = fget(communityTotalStrength, newC) + strengthOutV;
-    }
+/* ------------------------------------------------------------------ */
+/*  Extracted: community compaction                                    */
+/* ------------------------------------------------------------------ */
 
-    if (graph.directed) {
-      const outToOld: number = fget(outEdgeWeightToCommunity, oldC) || 0;
-      const inFromOld: number = fget(inEdgeWeightFromCommunity, oldC) || 0;
-      const outToNew: number =
-        newC < outEdgeWeightToCommunity.length ? fget(outEdgeWeightToCommunity, newC) || 0 : 0;
-      const inFromNew: number =
-        newC < inEdgeWeightFromCommunity.length ? fget(inEdgeWeightFromCommunity, newC) || 0 : 0;
-      // outToOld/inFromOld already include the self-loop weight (self-loops are
-      // in outEdges/inEdges), so subtract it once to avoid triple-counting.
-      communityInternalEdgeWeight[oldC] =
-        fget(communityInternalEdgeWeight, oldC) - (outToOld + inFromOld - selfLoopWeight);
-      communityInternalEdgeWeight[newC] =
-        fget(communityInternalEdgeWeight, newC) + (outToNew + inFromNew + selfLoopWeight);
-    } else {
-      const weightToOld: number = fget(neighborEdgeWeightToCommunity, oldC) || 0;
-      const weightToNew: number = fget(neighborEdgeWeightToCommunity, newC) || 0;
-      communityInternalEdgeWeight[oldC] =
-        fget(communityInternalEdgeWeight, oldC) - (2 * weightToOld + selfLoopWeight);
-      communityInternalEdgeWeight[newC] =
-        fget(communityInternalEdgeWeight, newC) + (2 * weightToNew + selfLoopWeight);
-    }
+function compactIds(s: PartitionState, opts: CompactOptions = {}): void {
+  const ids: number[] = [];
+  for (let c = 0; c < s.communityCount; c++) if (iget(s.communityNodeCount, c) > 0) ids.push(c);
+  buildSortedCommunityIds(ids, opts, s.communityTotalSize, s.communityNodeCount);
 
-    nodeCommunity[v] = newC;
-    return true;
-  }
+  const newId = new Int32Array(s.communityCount).fill(-1);
+  ids.forEach((c, i) => {
+    newId[c] = i;
+  });
+  for (let i = 0; i < s.nodeCommunity.length; i++)
+    s.nodeCommunity[i] = iget(newId, iget(s.nodeCommunity, i));
 
-  function compactCommunityIds(opts: CompactOptions = {}): void {
-    const ids: number[] = [];
-    for (let c = 0; c < communityCount; c++) if (iget(communityNodeCount, c) > 0) ids.push(c);
-    buildSortedCommunityIds(ids, opts, communityTotalSize, communityNodeCount);
+  const remappedCount: number = ids.length;
+  const newTotalSize = new Float64Array(remappedCount);
+  const newNodeCount = new Int32Array(remappedCount);
+  const newInternalEdgeWeight = new Float64Array(remappedCount);
+  const newTotalStrength = new Float64Array(remappedCount);
+  const newTotalOutStrength = new Float64Array(remappedCount);
+  const newTotalInStrength = new Float64Array(remappedCount);
+  accumulateNodeAggregates(
+    s.graph,
+    s.nodeCommunity,
+    s.n,
+    newTotalSize,
+    newNodeCount,
+    newInternalEdgeWeight,
+    newTotalStrength,
+    newTotalOutStrength,
+    newTotalInStrength,
+  );
+  accumulateInternalEdgeWeights(s.graph, s.nodeCommunity, s.n, newInternalEdgeWeight);
 
-    const newId = new Int32Array(communityCount).fill(-1);
-    ids.forEach((c, i) => {
-      newId[c] = i;
-    });
-    for (let i = 0; i < nodeCommunity.length; i++)
-      nodeCommunity[i] = iget(newId, iget(nodeCommunity, i));
-
-    const remappedCount: number = ids.length;
-    const newTotalSize = new Float64Array(remappedCount);
-    const newNodeCount = new Int32Array(remappedCount);
-    const newInternalEdgeWeight = new Float64Array(remappedCount);
-    const newTotalStrength = new Float64Array(remappedCount);
-    const newTotalOutStrength = new Float64Array(remappedCount);
-    const newTotalInStrength = new Float64Array(remappedCount);
-    accumulateNodeAggregates(
-      graph,
-      nodeCommunity,
-      n,
-      newTotalSize,
-      newNodeCount,
-      newInternalEdgeWeight,
-      newTotalStrength,
-      newTotalOutStrength,
-      newTotalInStrength,
-    );
-    accumulateInternalEdgeWeights(graph, nodeCommunity, n, newInternalEdgeWeight);
-
-    communityCount = remappedCount;
-    communityTotalSize = newTotalSize;
-    communityNodeCount = newNodeCount;
-    communityInternalEdgeWeight = newInternalEdgeWeight;
-    communityTotalStrength = newTotalStrength;
-    communityTotalOutStrength = newTotalOutStrength;
-    communityTotalInStrength = newTotalInStrength;
-  }
+  s.communityCount = remappedCount;
+  s.communityTotalSize = newTotalSize;
+  s.communityNodeCount = newNodeCount;
+  s.communityInternalEdgeWeight = newInternalEdgeWeight;
+  s.communityTotalStrength = newTotalStrength;
+  s.communityTotalOutStrength = newTotalOutStrength;
+  s.communityTotalInStrength = newTotalInStrength;
+}
 
-  function getCommunityMembers(): number[][] {
-    const comms: number[][] = new Array(communityCount);
-    for (let i = 0; i < communityCount; i++) comms[i] = [];
-    for (let i = 0; i < n; i++) comms[iget(nodeCommunity, i)]!.push(i);
-    return comms;
-  }
+/* ------------------------------------------------------------------ */
+/*  Factory: thin wrapper that wires state to extracted functions      */
+/* ------------------------------------------------------------------ */
 
-  function getCommunityTotalSizeFn(c: number): number {
-    return c < communityTotalSize.length ? fget(communityTotalSize, c) : 0;
-  }
-  function getCommunityNodeCountFn(c: number): number {
-    return c < communityNodeCount.length ? iget(communityNodeCount, c) : 0;
-  }
+export function makePartition(graph: GraphAdapter): Partition {
+  const n: number = graph.n;
+  const nodeCommunity = new Int32Array(n);
+  for (let i = 0; i < n; i++) nodeCommunity[i] = i;
+
+  const s: PartitionState = {
+    graph,
+    n,
+    nodeCommunity,
+    communityCount: n,
+    communityTotalSize: new Float64Array(n),
+    communityNodeCount: new Int32Array(n),
+    communityInternalEdgeWeight: new Float64Array(n),
+    communityTotalStrength: new Float64Array(n),
+    communityTotalOutStrength: new Float64Array(n),
+    communityTotalInStrength: new Float64Array(n),
+    candidateCommunities: new Int32Array(n),
+    candidateCommunityCount: 0,
+    neighborEdgeWeightToCommunity: new Float64Array(n),
+    outEdgeWeightToCommunity: new Float64Array(n),
+    inEdgeWeightFromCommunity: new Float64Array(n),
+    isCandidateCommunity: new Uint8Array(n),
+  };
 
   return {
     n,
     get communityCount() {
-      return communityCount;
+      return s.communityCount;
     },
     nodeCommunity,
     get communityTotalSize() {
-      return communityTotalSize;
+      return s.communityTotalSize;
     },
     get communityNodeCount() {
-      return communityNodeCount;
+      return s.communityNodeCount;
     },
     get communityInternalEdgeWeight() {
-      return communityInternalEdgeWeight;
+      return s.communityInternalEdgeWeight;
     },
     get communityTotalStrength() {
-      return communityTotalStrength;
+      return s.communityTotalStrength;
     },
     get communityTotalOutStrength() {
-      return communityTotalOutStrength;
+      return s.communityTotalOutStrength;
     },
     get communityTotalInStrength() {
-      return communityTotalInStrength;
+      return s.communityTotalInStrength;
     },
     resizeCommunities(newCount: number): void {
-      ensureCommCapacity(newCount);
-      communityCount = newCount;
+      ensureCommCapacity(s, newCount);
+      s.communityCount = newCount;
     },
-    initializeAggregates,
-    accumulateNeighborCommunityEdgeWeights,
-    getCandidateCommunityCount: (): number => candidateCommunityCount,
-    getCandidateCommunityAt: (i: number): number => iget(candidateCommunities, i),
+    initializeAggregates: () => initAggregates(s),
+    accumulateNeighborCommunityEdgeWeights: (v: number) => accumulateNeighborWeights(s, v),
+    getCandidateCommunityCount: (): number => s.candidateCommunityCount,
+    getCandidateCommunityAt: (i: number): number => iget(s.candidateCommunities, i),
     getNeighborEdgeWeightToCommunity: (c: number): number =>
-      fget(neighborEdgeWeightToCommunity, c) || 0,
-    getOutEdgeWeightToCommunity: (c: number): number => fget(outEdgeWeightToCommunity, c) || 0,
-    getInEdgeWeightFromCommunity: (c: number): number => fget(inEdgeWeightFromCommunity, c) || 0,
-    deltaModularityUndirected,
-    deltaModularityDirected,
-    deltaCPM,
-    moveNodeToCommunity,
-    compactCommunityIds,
-    getCommunityMembers,
-    getCommunityTotalSize: getCommunityTotalSizeFn,
-    getCommunityNodeCount: getCommunityNodeCountFn,
+      fget(s.neighborEdgeWeightToCommunity, c) || 0,
+    getOutEdgeWeightToCommunity: (c: number): number => fget(s.outEdgeWeightToCommunity, c) || 0,
+    getInEdgeWeightFromCommunity: (c: number): number => fget(s.inEdgeWeightFromCommunity, c) || 0,
+    deltaModularityUndirected: (v: number, newC: number, gamma?: number) =>
+      computeDeltaModularityUndirected(s, v, newC, gamma),
+    deltaModularityDirected: (v: number, newC: number, gamma?: number) =>
+      computeDeltaModularityDirected(s, v, newC, gamma),
+    deltaCPM: (v: number, newC: number, gamma?: number) => computeDeltaCPM(s, v, newC, gamma),
+    moveNodeToCommunity: (v: number, newC: number) => moveNode(s, v, newC),
+    compactCommunityIds: (opts?: CompactOptions) => compactIds(s, opts),
+    getCommunityMembers(): number[][] {
+      const comms: number[][] = new Array(s.communityCount);
+      for (let i = 0; i < s.communityCount; i++) comms[i] = [];
+      for (let i = 0; i < n; i++) comms[iget(nodeCommunity, i)]!.push(i);
+      return comms;
+    },
+    getCommunityTotalSize: (c: number): number =>
+      c < s.communityTotalSize.length ? fget(s.communityTotalSize, c) : 0,
+    getCommunityNodeCount: (c: number): number =>
+      c < s.communityNodeCount.length ? iget(s.communityNodeCount, c) : 0,
     graph: undefined,
   };
 }