@optave/codegraph 3.7.0 → 3.8.1

package/dist/graph/algorithms/leiden/partition.js

@@ -17,6 +17,9 @@ function iget(a, i) {
 function u8get(a, i) {
     return a[i];
 }
+/* ------------------------------------------------------------------ */
+/*  Aggregate helpers (shared by initializeAggregates & compact)      */
+/* ------------------------------------------------------------------ */
 /**
  * Accumulate per-community node-level totals (size, count, strength) into the
  * provided aggregate arrays. Both `initializeAggregates` and `compactCommunityIds`
@@ -101,303 +104,322 @@ function buildSortedCommunityIds(ids, opts, communityTotalSize, communityNodeCou
             a - b);
     }
 }
-export function makePartition(graph) {
-    const n = graph.n;
-    const nodeCommunity = new Int32Array(n);
-    for (let i = 0; i < n; i++)
-        nodeCommunity[i] = i;
-    let communityCount = 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 = 0;
-    const neighborEdgeWeightToCommunity = new Float64Array(n);
-    const outEdgeWeightToCommunity = new Float64Array(n);
-    const inEdgeWeightFromCommunity = new Float64Array(n);
-    const isCandidateCommunity = new Uint8Array(n);
-    function ensureCommCapacity(newCount) {
-        if (newCount <= communityTotalSize.length)
-            return;
-        const growTo = 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);
-    }
-    function initializeAggregates() {
-        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 resetScratch() {
-        for (let i = 0; i < candidateCommunityCount; i++) {
-            const c = iget(candidateCommunities, i);
-            isCandidateCommunity[c] = 0;
-            neighborEdgeWeightToCommunity[c] = 0;
-            outEdgeWeightToCommunity[c] = 0;
-            inEdgeWeightFromCommunity[c] = 0;
-        }
-        candidateCommunityCount = 0;
-    }
-    function touch(c) {
-        if (u8get(isCandidateCommunity, c))
-            return;
-        isCandidateCommunity[c] = 1;
-        candidateCommunities[candidateCommunityCount++] = c;
+/* ------------------------------------------------------------------ */
+/*  Extracted: capacity management                                     */
+/* ------------------------------------------------------------------ */
+function ensureCommCapacity(s, newCount) {
+    if (newCount <= s.communityTotalSize.length)
+        return;
+    const growTo = 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) {
+    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) {
+    for (let i = 0; i < s.candidateCommunityCount; i++) {
+        const c = iget(s.candidateCommunities, i);
+        s.isCandidateCommunity[c] = 0;
+        s.neighborEdgeWeightToCommunity[c] = 0;
+        s.outEdgeWeightToCommunity[c] = 0;
+        s.inEdgeWeightFromCommunity[c] = 0;
     }
-    function accumulateNeighborCommunityEdgeWeights(v) {
-        resetScratch();
-        const ci = iget(nodeCommunity, v);
-        touch(ci);
-        if (graph.directed) {
-            const outL = graph.outEdges[v];
-            for (let k = 0; k < outL.length; k++) {
-                const j = outL[k].to;
-                const w = outL[k].w;
-                const cj = 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 = inL[k].from;
-                const w = inL[k].w;
-                const ci2 = iget(nodeCommunity, i2);
-                touch(ci2);
-                inEdgeWeightFromCommunity[ci2] = fget(inEdgeWeightFromCommunity, ci2) + w;
-            }
+    s.candidateCommunityCount = 0;
+}
+function touchCandidate(s, c) {
+    if (u8get(s.isCandidateCommunity, c))
+        return;
+    s.isCandidateCommunity[c] = 1;
+    s.candidateCommunities[s.candidateCommunityCount++] = c;
+}
+function accumulateNeighborWeights(s, v) {
+    resetScratch(s);
+    const ci = 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 = outL[k].to;
+            const w = outL[k].w;
+            const cj = iget(s.nodeCommunity, j);
+            touchCandidate(s, cj);
+            s.outEdgeWeightToCommunity[cj] = fget(s.outEdgeWeightToCommunity, cj) + w;
         }
-        else {
-            const list = graph.outEdges[v];
-            for (let k = 0; k < list.length; k++) {
-                const j = list[k].to;
-                const w = list[k].w;
-                const cj = iget(nodeCommunity, j);
-                touch(cj);
-                neighborEdgeWeightToCommunity[cj] = fget(neighborEdgeWeightToCommunity, cj) + w;
-            }
+        const inL = s.graph.inEdges[v];
+        for (let k = 0; k < inL.length; k++) {
+            const i2 = inL[k].from;
+            const w = inL[k].w;
+            const ci2 = iget(s.nodeCommunity, i2);
+            touchCandidate(s, ci2);
+            s.inEdgeWeightFromCommunity[ci2] = fget(s.inEdgeWeightFromCommunity, ci2) + w;
         }
-        return candidateCommunityCount;
     }
-    const twoMUndirected = graph.totalWeight;
-    function deltaModularityUndirected(v, newC, gamma = 1.0) {
-        const oldC = iget(nodeCommunity, v);
-        if (newC === oldC)
-            return 0;
-        const strengthV = fget(graph.strengthOut, v);
-        const weightToNew = newC < neighborEdgeWeightToCommunity.length
-            ? fget(neighborEdgeWeightToCommunity, newC) || 0
-            : 0;
-        const weightToOld = fget(neighborEdgeWeightToCommunity, oldC) || 0;
-        const totalStrengthNew = newC < communityTotalStrength.length ? fget(communityTotalStrength, newC) : 0;
-        const totalStrengthOld = fget(communityTotalStrength, oldC);
-        const gain_remove = -(weightToOld / twoMUndirected -
-            (gamma * (strengthV * totalStrengthOld)) / (twoMUndirected * twoMUndirected));
-        const gain_add = weightToNew / twoMUndirected -
-            (gamma * (strengthV * totalStrengthNew)) / (twoMUndirected * twoMUndirected);
-        return gain_remove + gain_add;
+    else {
+        const list = s.graph.outEdges[v];
+        for (let k = 0; k < list.length; k++) {
+            const j = list[k].to;
+            const w = list[k].w;
+            const cj = iget(s.nodeCommunity, j);
+            touchCandidate(s, cj);
+            s.neighborEdgeWeightToCommunity[cj] = fget(s.neighborEdgeWeightToCommunity, cj) + w;
+        }
     }
-    function deltaModularityDirected(v, newC, gamma = 1.0) {
-        const oldC = iget(nodeCommunity, v);
-        if (newC === oldC)
-            return 0;
-        const totalEdgeWeight = graph.totalWeight;
-        const strengthOutV = fget(graph.strengthOut, v);
-        const strengthInV = fget(graph.strengthIn, v);
-        const inFromNew = newC < inEdgeWeightFromCommunity.length ? fget(inEdgeWeightFromCommunity, newC) || 0 : 0;
-        const outToNew = newC < outEdgeWeightToCommunity.length ? fget(outEdgeWeightToCommunity, newC) || 0 : 0;
-        const inFromOld = fget(inEdgeWeightFromCommunity, oldC) || 0;
-        const outToOld = fget(outEdgeWeightToCommunity, oldC) || 0;
-        const totalInStrengthNew = newC < communityTotalInStrength.length ? fget(communityTotalInStrength, newC) : 0;
-        const totalOutStrengthNew = newC < communityTotalOutStrength.length ? fget(communityTotalOutStrength, newC) : 0;
-        const totalInStrengthOld = fget(communityTotalInStrength, oldC);
-        const totalOutStrengthOld = fget(communityTotalOutStrength, oldC);
-        // Self-loop correction + constant term (see modularity.ts diffModularityDirected)
-        const selfW = fget(graph.selfLoop, v) || 0;
-        const deltaInternal = (inFromNew + outToNew - inFromOld - outToOld + 2 * selfW) / totalEdgeWeight;
-        const deltaExpected = (gamma *
-            (strengthOutV * (totalInStrengthNew - totalInStrengthOld) +
-                strengthInV * (totalOutStrengthNew - totalOutStrengthOld) +
-                2 * strengthOutV * strengthInV)) /
-            (totalEdgeWeight * totalEdgeWeight);
-        return deltaInternal - deltaExpected;
+    return s.candidateCommunityCount;
+}
+/* ------------------------------------------------------------------ */
+/*  Extracted: modularity delta computations                           */
+/* ------------------------------------------------------------------ */
+function computeDeltaModularityUndirected(s, v, newC, gamma = 1.0) {
+    const oldC = iget(s.nodeCommunity, v);
+    if (newC === oldC)
+        return 0;
+    const twoM = s.graph.totalWeight;
+    const strengthV = fget(s.graph.strengthOut, v);
+    const weightToNew = newC < s.neighborEdgeWeightToCommunity.length
+        ? fget(s.neighborEdgeWeightToCommunity, newC) || 0
+        : 0;
+    const weightToOld = fget(s.neighborEdgeWeightToCommunity, oldC) || 0;
+    const totalStrengthNew = newC < s.communityTotalStrength.length ? fget(s.communityTotalStrength, newC) : 0;
+    const totalStrengthOld = fget(s.communityTotalStrength, oldC);
+    const gain_remove = -(weightToOld / twoM -
+        (gamma * (strengthV * totalStrengthOld)) / (twoM * twoM));
+    const gain_add = weightToNew / twoM - (gamma * (strengthV * totalStrengthNew)) / (twoM * twoM);
+    return gain_remove + gain_add;
+}
+function computeDeltaModularityDirected(s, v, newC, gamma = 1.0) {
+    const oldC = iget(s.nodeCommunity, v);
+    if (newC === oldC)
+        return 0;
+    const totalEdgeWeight = s.graph.totalWeight;
+    const strengthOutV = fget(s.graph.strengthOut, v);
+    const strengthInV = fget(s.graph.strengthIn, v);
+    const inFromNew = newC < s.inEdgeWeightFromCommunity.length ? fget(s.inEdgeWeightFromCommunity, newC) || 0 : 0;
+    const outToNew = newC < s.outEdgeWeightToCommunity.length ? fget(s.outEdgeWeightToCommunity, newC) || 0 : 0;
+    const inFromOld = fget(s.inEdgeWeightFromCommunity, oldC) || 0;
+    const outToOld = fget(s.outEdgeWeightToCommunity, oldC) || 0;
+    const totalInStrengthNew = newC < s.communityTotalInStrength.length ? fget(s.communityTotalInStrength, newC) : 0;
+    const totalOutStrengthNew = newC < s.communityTotalOutStrength.length ? fget(s.communityTotalOutStrength, newC) : 0;
+    const totalInStrengthOld = fget(s.communityTotalInStrength, oldC);
+    const totalOutStrengthOld = fget(s.communityTotalOutStrength, oldC);
+    // Self-loop correction + constant term (see modularity.ts diffModularityDirected)
+    const selfW = fget(s.graph.selfLoop, v) || 0;
+    const deltaInternal = (inFromNew + outToNew - inFromOld - outToOld + 2 * selfW) / totalEdgeWeight;
+    const deltaExpected = (gamma *
+        (strengthOutV * (totalInStrengthNew - totalInStrengthOld) +
+            strengthInV * (totalOutStrengthNew - totalOutStrengthOld) +
+            2 * strengthOutV * strengthInV)) /
+        (totalEdgeWeight * totalEdgeWeight);
+    return deltaInternal - deltaExpected;
+}
+function computeDeltaCPM(s, v, newC, gamma = 1.0) {
+    const oldC = iget(s.nodeCommunity, v);
+    if (newC === oldC)
+        return 0;
+    let w_old;
+    let w_new;
+    let selfCorrection = 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);
     }
-    function deltaCPM(v, newC, gamma = 1.0) {
-        const oldC = iget(nodeCommunity, v);
-        if (newC === oldC)
-            return 0;
-        let w_old;
-        let w_new;
-        let selfCorrection = 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 = fget(graph.size, v) || 1;
-        const sizeOld = fget(communityTotalSize, oldC) || 0;
-        const sizeNew = newC < communityTotalSize.length ? fget(communityTotalSize, newC) : 0;
-        return w_new - w_old + selfCorrection - gamma * nodeSz * (sizeNew - sizeOld + nodeSz);
+    else {
+        w_old = fget(s.neighborEdgeWeightToCommunity, oldC) || 0;
+        w_new =
+            newC < s.neighborEdgeWeightToCommunity.length
+                ? fget(s.neighborEdgeWeightToCommunity, newC) || 0
+                : 0;
     }
-    function moveNodeToCommunity(v, newC) {
-        const oldC = iget(nodeCommunity, v);
-        if (oldC === newC)
-            return false;
-        if (newC >= communityCount) {
-            ensureCommCapacity(newC + 1);
-            communityCount = newC + 1;
-        }
-        const strengthOutV = fget(graph.strengthOut, v);
-        const strengthInV = fget(graph.strengthIn, v);
-        const selfLoopWeight = fget(graph.selfLoop, v);
-        const nodeSz = 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;
-        }
-        if (graph.directed) {
-            const outToOld = fget(outEdgeWeightToCommunity, oldC) || 0;
-            const inFromOld = fget(inEdgeWeightFromCommunity, oldC) || 0;
-            const outToNew = newC < outEdgeWeightToCommunity.length ? fget(outEdgeWeightToCommunity, newC) || 0 : 0;
-            const inFromNew = 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 = fget(neighborEdgeWeightToCommunity, oldC) || 0;
-            const weightToNew = fget(neighborEdgeWeightToCommunity, newC) || 0;
-            communityInternalEdgeWeight[oldC] =
-                fget(communityInternalEdgeWeight, oldC) - (2 * weightToOld + selfLoopWeight);
-            communityInternalEdgeWeight[newC] =
-                fget(communityInternalEdgeWeight, newC) + (2 * weightToNew + selfLoopWeight);
-        }
-        nodeCommunity[v] = newC;
-        return true;
+    const nodeSz = fget(s.graph.size, v) || 1;
+    const sizeOld = fget(s.communityTotalSize, oldC) || 0;
+    const sizeNew = newC < s.communityTotalSize.length ? fget(s.communityTotalSize, newC) : 0;
+    return w_new - w_old + selfCorrection - gamma * nodeSz * (sizeNew - sizeOld + nodeSz);
+}
+/* ------------------------------------------------------------------ */
+/*  Extracted: node move                                               */
+/* ------------------------------------------------------------------ */
+function moveNode(s, v, newC) {
+    const oldC = iget(s.nodeCommunity, v);
+    if (oldC === newC)
+        return false;
+    if (newC >= s.communityCount) {
+        ensureCommCapacity(s, newC + 1);
+        s.communityCount = newC + 1;
     }
-    function compactCommunityIds(opts = {}) {
-        const ids = [];
-        for (let c = 0; c < communityCount; c++)
-            if (iget(communityNodeCount, c) > 0)
-                ids.push(c);
-        buildSortedCommunityIds(ids, opts, communityTotalSize, communityNodeCount);
-        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 = 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;
+    const strengthOutV = fget(s.graph.strengthOut, v);
+    const strengthInV = fget(s.graph.strengthIn, v);
+    const selfLoopWeight = fget(s.graph.selfLoop, v);
+    const nodeSz = fget(s.graph.size, v);
+    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;
     }
-    function getCommunityMembers() {
-        const comms = 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;
+    else {
+        s.communityTotalStrength[oldC] = fget(s.communityTotalStrength, oldC) - strengthOutV;
+        s.communityTotalStrength[newC] = fget(s.communityTotalStrength, newC) + strengthOutV;
     }
-    function getCommunityTotalSizeFn(c) {
-        return c < communityTotalSize.length ? fget(communityTotalSize, c) : 0;
+    if (s.graph.directed) {
+        const outToOld = fget(s.outEdgeWeightToCommunity, oldC) || 0;
+        const inFromOld = fget(s.inEdgeWeightFromCommunity, oldC) || 0;
+        const outToNew = newC < s.outEdgeWeightToCommunity.length ? fget(s.outEdgeWeightToCommunity, newC) || 0 : 0;
+        const inFromNew = 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);
     }
-    function getCommunityNodeCountFn(c) {
-        return c < communityNodeCount.length ? iget(communityNodeCount, c) : 0;
+    else {
+        const weightToOld = fget(s.neighborEdgeWeightToCommunity, oldC) || 0;
+        const weightToNew = 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);
     }
+    s.nodeCommunity[v] = newC;
+    return true;
+}
+/* ------------------------------------------------------------------ */
+/*  Extracted: community compaction                                    */
+/* ------------------------------------------------------------------ */
+function compactIds(s, opts = {}) {
+    const ids = [];
+    for (let c = 0; c < s.communityCount; c++)
+        if (iget(s.communityNodeCount, c) > 0)
+            ids.push(c);
+    buildSortedCommunityIds(ids, opts, s.communityTotalSize, s.communityNodeCount);
+    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));
+    const remappedCount = 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);
+    s.communityCount = remappedCount;
+    s.communityTotalSize = newTotalSize;
+    s.communityNodeCount = newNodeCount;
+    s.communityInternalEdgeWeight = newInternalEdgeWeight;
+    s.communityTotalStrength = newTotalStrength;
+    s.communityTotalOutStrength = newTotalOutStrength;
+    s.communityTotalInStrength = newTotalInStrength;
+}
+/* ------------------------------------------------------------------ */
+/*  Factory: thin wrapper that wires state to extracted functions      */
+/* ------------------------------------------------------------------ */
+export function makePartition(graph) {
+    const n = graph.n;
+    const nodeCommunity = new Int32Array(n);
+    for (let i = 0; i < n; i++)
+        nodeCommunity[i] = i;
+    const s = {
+        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) {
-            ensureCommCapacity(newCount);
-            communityCount = newCount;
+            ensureCommCapacity(s, newCount);
+            s.communityCount = newCount;
+        },
+        initializeAggregates: () => initAggregates(s),
+        accumulateNeighborCommunityEdgeWeights: (v) => accumulateNeighborWeights(s, v),
+        getCandidateCommunityCount: () => s.candidateCommunityCount,
+        getCandidateCommunityAt: (i) => iget(s.candidateCommunities, i),
+        getNeighborEdgeWeightToCommunity: (c) => fget(s.neighborEdgeWeightToCommunity, c) || 0,
+        getOutEdgeWeightToCommunity: (c) => fget(s.outEdgeWeightToCommunity, c) || 0,
+        getInEdgeWeightFromCommunity: (c) => fget(s.inEdgeWeightFromCommunity, c) || 0,
+        deltaModularityUndirected: (v, newC, gamma) => computeDeltaModularityUndirected(s, v, newC, gamma),
+        deltaModularityDirected: (v, newC, gamma) => computeDeltaModularityDirected(s, v, newC, gamma),
+        deltaCPM: (v, newC, gamma) => computeDeltaCPM(s, v, newC, gamma),
+        moveNodeToCommunity: (v, newC) => moveNode(s, v, newC),
+        compactCommunityIds: (opts) => compactIds(s, opts),
+        getCommunityMembers() {
+            const comms = 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;
         },
-        initializeAggregates,
-        accumulateNeighborCommunityEdgeWeights,
-        getCandidateCommunityCount: () => candidateCommunityCount,
-        getCandidateCommunityAt: (i) => iget(candidateCommunities, i),
-        getNeighborEdgeWeightToCommunity: (c) => fget(neighborEdgeWeightToCommunity, c) || 0,
-        getOutEdgeWeightToCommunity: (c) => fget(outEdgeWeightToCommunity, c) || 0,
-        getInEdgeWeightFromCommunity: (c) => fget(inEdgeWeightFromCommunity, c) || 0,
-        deltaModularityUndirected,
-        deltaModularityDirected,
-        deltaCPM,
-        moveNodeToCommunity,
-        compactCommunityIds,
-        getCommunityMembers,
-        getCommunityTotalSize: getCommunityTotalSizeFn,
-        getCommunityNodeCount: getCommunityNodeCountFn,
+        getCommunityTotalSize: (c) => c < s.communityTotalSize.length ? fget(s.communityTotalSize, c) : 0,
+        getCommunityNodeCount: (c) => c < s.communityNodeCount.length ? iget(s.communityNodeCount, c) : 0,
         graph: undefined,
     };
 }