@graphty/algorithms 1.8.1 → 2.0.1

package/src/algorithms/community/louvain-optimized.ts

@@ -4,13 +4,18 @@ import type { CommunityResult, NodeId } from "../../types/index.js";
 /**
  * Optimized Louvain community detection algorithm with early pruning and threshold cycling
  *
+ * Runs the full multilevel method of Blondel et al. (local moving, then aggregating each community
+ * into one node, repeated until nothing moves) over typed arrays indexed 0..n-1.
+ *
  * Key optimizations:
- * - Leaf node pruning: Skip nodes with degree 1
+ * - Typed-array adjacency (CSR) instead of per-edge map lookups
+ * - Leaf node pruning: skip a degree-1 node already in its neighbour's community
  * - Importance ordering: Process high-impact nodes first
- * - Threshold cycling: Adaptive convergence thresholds
+ * - Threshold cycling: Adaptive move thresholds, relative to each node's largest possible gain
  * - Early termination: Stop when changes become insignificant
  *
- * Expected speedup: 2-5x on large graphs with many leaf nodes
+ * The graph is treated as undirected: a directed edge counts as an undirected edge of its weight.
+ * A self-loop of weight w adds 2w to its node's degree, the standard convention (NetworkX too).
  */
 
 interface OptimizedLouvainOptions {
@@ -19,11 +24,11 @@ interface OptimizedLouvainOptions {
      */
     resolution?: number;
     /**
-     * Maximum iterations per level (default: 100)
+     * Maximum local-moving sweeps per level (default: 100)
      */
     maxIterations?: number;
     /**
-     * Convergence tolerance (default: 1e-6)
+     * Convergence tolerance on a sweep's modularity gain (default: 1e-6)
      */
     tolerance?: number;
     /**
@@ -35,7 +40,7 @@ interface OptimizedLouvainOptions {
      */
     importanceOrdering?: boolean;
     /**
-     * Base pruning threshold (default: 0.01)
+     * Base move threshold, as a fraction of a node's largest possible modularity gain (default: 0.01)
      */
     pruningThreshold?: number;
     /**
@@ -50,16 +55,34 @@ interface PruningStats {
     stableNodesPruned: number;
 }
 
+/** One level of the multilevel method: an undirected weighted graph in CSR form. */
+interface Level {
+    n: number;
+    /** Row offsets into `targets` / `weights`, length n + 1. Each edge appears in both rows. */
+    offsets: Int32Array;
+    targets: Int32Array;
+    weights: Float64Array;
+    /** Weight of the edges inside each node (self-loops), each edge counted once. */
+    self: Float64Array;
+    /** Weighted degree of each node (a self-loop counts twice). */
+    degree: Float64Array;
+}
+
+interface LocalMovingOptions {
+    resolution: number;
+    maxIterations: number;
+    tolerance: number;
+    pruneLeaves: boolean;
+    importanceOrdering: boolean;
+    pruningThreshold: number;
+    thresholdCycling: boolean;
+}
+
 /**
  * Optimized Louvain implementation with early pruning and threshold cycling
  */
 export class OptimizedLouvain {
     private graph: Graph;
-    private communities: Map<NodeId, number>;
-    private communityWeights: Map<number, number>;
-    private nodeWeights: Map<NodeId, number>;
-    private nodeDegrees: Map<NodeId, number>;
-    private totalWeight: number;
     private pruningStats: PruningStats;
 
     /**
@@ -68,11 +91,6 @@ export class OptimizedLouvain {
      */
     constructor(graph: Graph) {
         this.graph = graph;
-        this.communities = new Map();
-        this.communityWeights = new Map();
-        this.nodeWeights = new Map();
-        this.nodeDegrees = new Map();
-        this.totalWeight = 0;
         this.pruningStats = {
             leafNodesPruned: 0,
             lowDegreeNodesPruned: 0,
@@ -83,383 +101,355 @@ export class OptimizedLouvain {
     /**
      * Run optimized Louvain algorithm
      * @param options - Algorithm configuration options
-     * @returns Community detection result with communities, modularity, and iterations
+     * @returns Community detection result with communities, modularity, and iterations (levels)
      */
     public detectCommunities(options: OptimizedLouvainOptions = {}): CommunityResult {
-        const {
-            resolution = 1.0,
-            maxIterations = 100,
-            tolerance = 1e-6,
-            pruneLeaves = true,
-            importanceOrdering = true,
-            pruningThreshold = 0.01,
-            thresholdCycling = true,
-        } = options;
-
-        // Initialize
-        this.initialize();
-        let modularity = this.calculateModularity(resolution);
-        let iteration = 0;
-        let improved = true;
-
-        while (iteration < maxIterations && improved) {
-            // Get nodes in optimal processing order
-            const orderedNodes = importanceOrdering
-                ? this.getNodesInImportanceOrder()
-                : Array.from(this.graph.nodes()).map((n) => n.id);
-
-            // Apply adaptive threshold
-            const threshold = thresholdCycling ? this.getAdaptiveThreshold(iteration, pruningThreshold) : 0;
-
-            // Perform local optimization
-            improved = this.performLocalMoving(orderedNodes, {
-                pruneLeaves,
-                threshold,
-                resolution,
-            });
-
-            if (improved) {
-                const newModularity = this.calculateModularity(resolution);
-
-                // Check convergence
-                if (Math.abs(newModularity - modularity) < tolerance) {
-                    break;
-                }
+        const settings: LocalMovingOptions = {
+            resolution: options.resolution ?? 1.0,
+            maxIterations: options.maxIterations ?? 100,
+            tolerance: options.tolerance ?? 1e-6,
+            pruneLeaves: options.pruneLeaves ?? true,
+            importanceOrdering: options.importanceOrdering ?? true,
+            pruningThreshold: options.pruningThreshold ?? 0.01,
+            thresholdCycling: options.thresholdCycling ?? true,
+        };
 
-                modularity = newModularity;
-                iteration++;
-            }
+        const { level: base, ids } = this.buildLevel();
+        // membership[i] = the current level's node that original node i has been folded into
+        const membership = new Int32Array(base.n);
+        for (let i = 0; i < base.n; i++) {
+            membership[i] = i;
         }
 
-        // Convert community assignments to result format
-        const communityGroups = new Map<number, NodeId[]>();
-
-        for (const [nodeId, community] of this.communities) {
-            if (!communityGroups.has(community)) {
-                communityGroups.set(community, []);
+        let level = base;
+        let iterations = 0;
+        while (level.n > 1) {
+            const { community, count, moved } = this.localMoving(level, settings);
+            if (!moved) {
+                break;
             }
 
-            const group = communityGroups.get(community);
-            if (group) {
-                group.push(nodeId);
+            iterations++;
+            for (let i = 0; i < membership.length; i++) {
+                membership[i] = community[membership[i]];
             }
+
+            level = aggregate(level, community, count);
+        }
+
+        const groups: NodeId[][] = Array.from({ length: level.n }, () => []);
+        for (let i = 0; i < membership.length; i++) {
+            groups[membership[i]].push(ids[i]);
         }
 
         return {
-            communities: Array.from(communityGroups.values()),
-            modularity,
-            iterations: iteration,
+            communities: groups.filter((group) => group.length > 0),
+            modularity: levelModularity(level, settings.resolution),
+            iterations,
         };
     }
 
     /**
-     * Initialize data structures
+     * Get pruning statistics
+     * @returns Statistics about nodes pruned during optimization
      */
-    private initialize(): void {
-        let communityId = 0;
+    public getPruningStats(): PruningStats {
+        return { ...this.pruningStats };
+    }
 
-        // Initialize each node in its own community
+    /**
+     * Index the graph's nodes 0..n-1 and build the level-0 CSR adjacency
+     * @returns The level-0 graph and the node id at each index
+     */
+    private buildLevel(): { level: Level; ids: NodeId[] } {
+        const ids: NodeId[] = [];
+        const index = new Map<NodeId, number>();
         for (const node of this.graph.nodes()) {
-            this.communities.set(node.id, communityId);
-
-            // Calculate node weight and degree
-            let nodeWeight = 0;
-            let degree = 0;
+            index.set(node.id, ids.length);
+            ids.push(node.id);
+        }
 
-            for (const neighbor of Array.from(this.graph.neighbors(node.id))) {
-                const edge = this.graph.getEdge(node.id, neighbor);
-                const weight = edge?.weight ?? 1;
-                nodeWeight += weight;
-                degree++;
+        const n = ids.length;
+        const edges: [number, number, number][] = [];
+        const counts = new Int32Array(n + 1);
+        const self = new Float64Array(n);
+        const degree = new Float64Array(n);
+
+        for (const edge of this.graph.edges()) {
+            const s = index.get(edge.source);
+            const t = index.get(edge.target);
+            if (s === undefined || t === undefined) {
+                continue;
             }
 
-            // For undirected graphs, also check incoming edges
-            if (!this.graph.isDirected) {
-                for (const neighbor of Array.from(this.graph.inNeighbors(node.id))) {
-                    if (!this.graph.hasEdge(node.id, neighbor)) {
-                        const edge = this.graph.getEdge(neighbor, node.id);
-                        const weight = edge?.weight ?? 1;
-                        nodeWeight += weight;
-                        degree++;
-                    }
-                }
+            const w = edge.weight ?? 1;
+            degree[s] += w;
+            degree[t] += w;
+            if (s === t) {
+                self[s] += w;
+                continue;
             }
 
-            this.nodeWeights.set(node.id, nodeWeight);
-            this.nodeDegrees.set(node.id, degree);
-            this.communityWeights.set(communityId, nodeWeight);
-            this.totalWeight += nodeWeight;
-
-            communityId++;
+            edges.push([s, t, w]);
+            counts[s + 1]++;
+            counts[t + 1]++;
         }
 
-        // Total weight is sum of all edge weights
-        // For undirected graphs, each edge is counted twice from both endpoints
-        this.totalWeight = this.totalWeight / 2;
+        return { level: buildCsr(n, counts, edges, self, degree), ids };
     }
 
     /**
-     * Get nodes ordered by importance (degree * log(weight))
-     * @returns Array of node IDs sorted by descending importance
+     * Move each node to the neighbouring community with the best modularity gain, until no move
+     * improves modularity
+     * @param level - The graph at this level
+     * @param options - Local moving options
+     * @returns Each node's community (numbered 0..count-1), the count, and whether any node moved
      */
-    private getNodesInImportanceOrder(): NodeId[] {
-        const nodeImportance = new Map<NodeId, number>();
-
-        for (const [nodeId, degree] of this.nodeDegrees) {
-            const weight = this.nodeWeights.get(nodeId) ?? 0;
-            // Importance score: combination of degree and weight
-            // High-degree nodes and nodes with heavy edges are processed first
-            const importance = degree * Math.log(1 + weight);
-            nodeImportance.set(nodeId, importance);
+    private localMoving(
+        level: Level,
+        options: LocalMovingOptions,
+    ): { community: Int32Array; count: number; moved: boolean } {
+        const { n, offsets, targets, weights, degree } = level;
+        const { resolution, maxIterations, tolerance, pruneLeaves } = options;
+
+        const twoM = degree.reduce((sum, d) => sum + d, 0);
+        const community = new Int32Array(n);
+        const total = new Float64Array(n);
+        for (let i = 0; i < n; i++) {
+            community[i] = i;
+            total[i] = degree[i];
         }
 
-        // Sort by importance (descending)
-        return Array.from(nodeImportance.entries())
-            .sort((a, b) => b[1] - a[1])
-            .map(([nodeId]) => nodeId);
-    }
+        if (twoM === 0) {
+            return { community, count: n, moved: false };
+        }
 
-    /**
-     * Perform local moving phase with optimizations
-     * @param nodes - Array of node IDs to process
-     * @param options - Local moving options
-     * @param options.pruneLeaves - Whether to skip leaf nodes
-     * @param options.threshold - Minimum gain threshold for moves
-     * @param options.resolution - Resolution parameter for modularity
-     * @returns True if any improvement was made, false otherwise
-     */
-    private performLocalMoving(
-        nodes: NodeId[],
-        options: {
-            pruneLeaves: boolean;
-            threshold: number;
-            resolution: number;
-        },
-    ): boolean {
-        const { pruneLeaves, threshold, resolution } = options;
-        let improvement = false;
-        let hasChanged = true;
-
-        while (hasChanged) {
-            hasChanged = false;
-
-            for (const nodeId of nodes) {
-                // Early pruning: skip leaf nodes
-                if (pruneLeaves && this.isLeafNode(nodeId)) {
+        const order = this.nodeOrder(level, options.importanceOrdering);
+        // Scratch: weight from the current node to each community, and the communities touched
+        const toCommunity = new Float64Array(n);
+        const touched = new Int32Array(n);
+
+        let moved = false;
+        let useThreshold = options.thresholdCycling;
+        for (let sweep = 0; sweep < maxIterations; sweep++) {
+            // The threshold is a fraction of the most node i could gain from any move (all of its
+            // weight landing inside the target, k_i), so it scales with the graph
+            const threshold = useThreshold ? options.pruningThreshold * Math.pow(0.5, sweep / 10) : 0;
+            let sweepMoved = false;
+            let sweepGain = 0;
+
+            for (const i of order) {
+                const start = offsets[i];
+                const end = offsets[i + 1];
+                if (pruneLeaves && end - start === 1 && community[targets[start]] === community[i]) {
+                    // A leaf's only move is to its one neighbour's community, and it is there
                     this.pruningStats.leafNodesPruned++;
                     continue;
                 }
 
-                const currentCommunity = this.communities.get(nodeId) ?? 0;
-                const neighborCommunities = this.getNeighborCommunities(nodeId);
-
-                // Skip isolated nodes
-                if (neighborCommunities.size === 0) {
+                if (end === start) {
                     continue;
                 }
 
-                // Find best community to move to
-                let bestCommunity = currentCommunity;
-                let bestGain = 0;
-
-                // Remove node from its current community to calculate gains
-                this.removeNodeFromCommunity(nodeId, currentCommunity);
+                const current = community[i];
+                let touchedCount = 0;
+                for (let e = start; e < end; e++) {
+                    const c = community[targets[e]];
+                    if (toCommunity[c] === 0) {
+                        touched[touchedCount++] = c;
+                    }
 
-                for (const community of neighborCommunities) {
-                    const gain = this.calculateModularityGain(nodeId, community, resolution);
+                    toCommunity[c] += weights[e];
+                }
 
-                    // Apply threshold - only move if gain exceeds threshold
-                    if (gain > bestGain + threshold) {
-                        bestGain = gain;
-                        bestCommunity = community;
+                // Gains are in units of m * dQ: w(i, c) - resolution * tot(c) * k_i / 2m
+                const k = degree[i];
+                total[current] -= k;
+                const stayGain = toCommunity[current] - (resolution * total[current] * k) / twoM;
+                let best = current;
+                let bestGain = stayGain;
+                const minImprovement = threshold * k;
+
+                for (let t = 0; t < touchedCount; t++) {
+                    const c = touched[t];
+                    if (c !== current) {
+                        const gain = toCommunity[c] - (resolution * total[c] * k) / twoM;
+                        if (gain > bestGain + minImprovement) {
+                            bestGain = gain;
+                            best = c;
+                        }
                     }
-                }
 
-                // Try staying in current community
-                const currentGain = this.calculateModularityGain(nodeId, currentCommunity, resolution);
-                if (currentGain > bestGain + threshold) {
-                    bestGain = currentGain;
-                    bestCommunity = currentCommunity;
+                    toCommunity[c] = 0;
                 }
 
-                // Add node to best community
-                this.addNodeToCommunity(nodeId, bestCommunity);
+                total[best] += k;
+                if (best !== current) {
+                    community[i] = best;
+                    sweepMoved = true;
+                    sweepGain += (bestGain - stayGain) / (twoM / 2);
+                }
+            }
 
-                // Track if node moved
-                if (bestCommunity !== currentCommunity) {
-                    hasChanged = true;
-                    improvement = true;
+            moved ||= sweepMoved;
+            if (!sweepMoved || sweepGain < tolerance) {
+                // A threshold can stall moves that are still worth making: finish without one
+                if (useThreshold) {
+                    useThreshold = false;
+                    continue;
                 }
+
+                break;
             }
         }
 
-        return improvement;
-    }
+        // Renumber the communities 0..count-1
+        const renumber = new Int32Array(n).fill(-1);
+        let count = 0;
+        for (let i = 0; i < n; i++) {
+            const c = community[i];
+            if (renumber[c] === -1) {
+                renumber[c] = count++;
+            }
 
-    /**
-     * Check if node is a leaf (degree 1)
-     * @param nodeId - The node ID to check
-     * @returns True if the node has degree 1, false otherwise
-     */
-    private isLeafNode(nodeId: NodeId): boolean {
-        const degree = this.nodeDegrees.get(nodeId) ?? 0;
-        return degree === 1;
-    }
+            community[i] = renumber[c];
+        }
 
-    /**
-     * Get adaptive threshold that decreases with iterations
-     * @param iteration - Current iteration number
-     * @param baseThreshold - Base threshold value to scale
-     * @returns Adaptive threshold value that decays over iterations
-     */
-    private getAdaptiveThreshold(iteration: number, baseThreshold: number): number {
-        // Exponentially decay threshold with iterations
-        // This allows coarse movements early and fine-tuning later
-        return baseThreshold * Math.pow(0.5, iteration / 10);
+        return { community, count, moved };
     }
 
     /**
-     * Calculate modularity gain from moving a node to a community
-     * @param nodeId - The node ID to move
-     * @param targetCommunity - The target community ID
-     * @param resolution - Resolution parameter for modularity calculation
-     * @returns The modularity gain from moving the node
+     * Order nodes for local moving, by importance (degree * log(1 + weighted degree)) if asked
+     * @param level - The graph at this level
+     * @param importanceOrdering - Whether to sort by importance
+     * @returns Node indices in processing order
      */
-    private calculateModularityGain(nodeId: NodeId, targetCommunity: number, resolution: number): number {
-        const nodeWeight = this.nodeWeights.get(nodeId) ?? 0;
-
-        // Sum of weights from node to target community
-        let weightToTarget = 0;
-
-        for (const neighbor of Array.from(this.graph.neighbors(nodeId))) {
-            if (this.communities.get(neighbor) === targetCommunity) {
-                const edge = this.graph.getEdge(nodeId, neighbor);
-                weightToTarget += edge?.weight ?? 1;
-            }
+    private nodeOrder(level: Level, importanceOrdering: boolean): Int32Array {
+        const order = new Int32Array(level.n);
+        for (let i = 0; i < level.n; i++) {
+            order[i] = i;
         }
 
-        // For undirected graphs, also check incoming edges
-        if (!this.graph.isDirected) {
-            for (const neighbor of Array.from(this.graph.inNeighbors(nodeId))) {
-                if (this.communities.get(neighbor) === targetCommunity && !this.graph.hasEdge(nodeId, neighbor)) {
-                    const edge = this.graph.getEdge(neighbor, nodeId);
-                    weightToTarget += edge?.weight ?? 1;
-                }
-            }
+        if (!importanceOrdering) {
+            return order;
         }
 
-        // Weight of target community
-        const targetWeight = this.communityWeights.get(targetCommunity) ?? 0;
-
-        // Modularity gain formula
-        const gain =
-            (weightToTarget - (resolution * nodeWeight * targetWeight) / (2 * this.totalWeight)) / this.totalWeight;
+        const importance = new Float64Array(level.n);
+        for (let i = 0; i < level.n; i++) {
+            importance[i] = (level.offsets[i + 1] - level.offsets[i]) * Math.log(1 + level.degree[i]);
+        }
 
-        return gain;
+        return order.sort((a, b) => importance[b] - importance[a]);
     }
+}
 
-    /**
-     * Remove node from community (for gain calculation)
-     * @param nodeId - The node ID to remove
-     * @param community - The community ID to remove from
-     */
-    private removeNodeFromCommunity(nodeId: NodeId, community: number): void {
-        const nodeWeight = this.nodeWeights.get(nodeId) ?? 0;
-        this.communityWeights.set(community, (this.communityWeights.get(community) ?? 0) - nodeWeight);
-        this.communities.delete(nodeId);
+/**
+ * Build a CSR level from an undirected edge list (each edge listed once, no self-loops)
+ * @param n - Node count
+ * @param counts - counts[i + 1] = number of edges incident to node i
+ * @param edges - The edges as [source, target, weight]
+ * @param self - Self-loop weight of each node
+ * @param degree - Weighted degree of each node
+ * @returns The level
+ */
+function buildCsr(
+    n: number,
+    counts: Int32Array,
+    edges: [number, number, number][],
+    self: Float64Array,
+    degree: Float64Array,
+): Level {
+    const offsets = counts;
+    for (let i = 0; i < n; i++) {
+        offsets[i + 1] += offsets[i];
     }
 
-    /**
-     * Add node to community
-     * @param nodeId - The node ID to add
-     * @param community - The community ID to add to
-     */
-    private addNodeToCommunity(nodeId: NodeId, community: number): void {
-        const nodeWeight = this.nodeWeights.get(nodeId) ?? 0;
-        this.communityWeights.set(community, (this.communityWeights.get(community) ?? 0) + nodeWeight);
-        this.communities.set(nodeId, community);
+    const targets = new Int32Array(offsets[n]);
+    const weights = new Float64Array(offsets[n]);
+    const fill = offsets.slice(0, n);
+    for (const [s, t, w] of edges) {
+        targets[fill[s]] = t;
+        weights[fill[s]++] = w;
+        targets[fill[t]] = s;
+        weights[fill[t]++] = w;
     }
 
-    /**
-     * Get neighboring communities of a node
-     * @param nodeId - The node ID to find neighbor communities for
-     * @returns Set of community IDs that neighbors belong to
-     */
-    private getNeighborCommunities(nodeId: NodeId): Set<number> {
-        const communities = new Set<number>();
-
-        for (const neighbor of Array.from(this.graph.neighbors(nodeId))) {
-            const community = this.communities.get(neighbor);
-            if (community !== undefined) {
-                communities.add(community);
-            }
-        }
-
-        // For undirected graphs, also check incoming edges
-        if (!this.graph.isDirected) {
-            for (const neighbor of Array.from(this.graph.inNeighbors(nodeId))) {
-                const community = this.communities.get(neighbor);
-                if (community !== undefined) {
-                    communities.add(community);
-                }
-            }
-        }
+    return { n, offsets, targets, weights, self, degree };
+}
 
-        return communities;
+/**
+ * Fold each community into one node: edges between communities are summed, edges inside a
+ * community become its self-loop
+ * @param level - The graph at this level
+ * @param community - Each node's community, numbered 0..count-1
+ * @param count - Number of communities
+ * @returns The next level
+ */
+function aggregate(level: Level, community: Int32Array, count: number): Level {
+    const self = new Float64Array(count);
+    const degree = new Float64Array(count);
+    const members: number[][] = Array.from({ length: count }, () => []);
+    for (let i = 0; i < level.n; i++) {
+        const c = community[i];
+        members[c].push(i);
+        self[c] += level.self[i];
+        degree[c] += level.degree[i];
     }
 
-    /**
-     * Calculate total modularity
-     * @param resolution - Resolution parameter for modularity calculation
-     * @returns The modularity score of the current partition
-     */
-    private calculateModularity(resolution: number): number {
-        if (this.totalWeight === 0) {
-            return 0;
-        }
-
-        let modularity = 0;
-
-        // Sum over all communities
-        const communityInternalWeights = new Map<number, number>();
+    const edges: [number, number, number][] = [];
+    const counts = new Int32Array(count + 1);
+    const toCommunity = new Float64Array(count);
+    const touched: number[] = [];
+    for (let c = 0; c < count; c++) {
+        for (const i of members[c]) {
+            for (let e = level.offsets[i]; e < level.offsets[i + 1]; e++) {
+                const d = community[level.targets[e]];
+                if (d === c) {
+                    // Seen once from each endpoint
+                    self[c] += level.weights[e] / 2;
+                } else if (d > c) {
+                    // Keep each inter-community edge once, from its lower-numbered side
+                    if (toCommunity[d] === 0) {
+                        touched.push(d);
+                    }
 
-        // Calculate internal weights for each community
-        for (const node of this.graph.nodes()) {
-            const nodeId = node.id;
-            const community = this.communities.get(nodeId) ?? 0;
-
-            for (const neighbor of Array.from(this.graph.neighbors(nodeId))) {
-                if (this.communities.get(neighbor) === community) {
-                    const edge = this.graph.getEdge(nodeId, neighbor);
-                    const weight = edge?.weight ?? 1;
-                    communityInternalWeights.set(community, (communityInternalWeights.get(community) ?? 0) + weight);
+                    toCommunity[d] += level.weights[e];
                 }
             }
         }
 
-        // Calculate modularity
-        for (const [community, internalWeight] of communityInternalWeights) {
-            const communityWeight = this.communityWeights.get(community) ?? 0;
-            // For undirected graphs, internal weights are counted twice
-            const aIn = this.graph.isDirected ? internalWeight : internalWeight / 2;
-            const aTotal = communityWeight;
-
-            // Modularity formula: sum of (fraction of edges within community - expected fraction)
-            const actualFraction = aIn / this.totalWeight;
-            const expectedFraction = resolution * Math.pow(aTotal / (2 * this.totalWeight), 2);
-            modularity += actualFraction - expectedFraction;
+        for (const d of touched) {
+            edges.push([c, d, toCommunity[d]]);
+            counts[c + 1]++;
+            counts[d + 1]++;
+            toCommunity[d] = 0;
         }
 
-        return modularity;
+        touched.length = 0;
     }
 
-    /**
-     * Get pruning statistics
-     * @returns Statistics about nodes pruned during optimization
-     */
-    public getPruningStats(): PruningStats {
-        return { ...this.pruningStats };
+    return buildCsr(count, counts, edges, self, degree);
+}
+
+/**
+ * Modularity of the partition that puts each node of `level` in its own community
+ * @param level - The graph at this level
+ * @param resolution - Resolution parameter
+ * @returns Q = sum over nodes c of [ self(c) / m - resolution * (k_c / 2m)^2 ]
+ */
+function levelModularity(level: Level, resolution: number): number {
+    const twoM = level.degree.reduce((sum, d) => sum + d, 0);
+    if (twoM === 0) {
+        return 0;
     }
+
+    let modularity = 0;
+    for (let c = 0; c < level.n; c++) {
+        const share = level.degree[c] / twoM;
+        modularity += (2 * level.self[c]) / twoM - resolution * share * share;
+    }
+
+    return modularity;
 }
 
 /**