@graphty/algorithms 1.1.0 → 1.3.1

package/src/algorithms/community/girvan-newman.ts

@@ -27,9 +27,11 @@ export function girvanNewman(
 ): CommunityResult[] {
     const {maxCommunities} = options;
     const minCommunitySize = options.minCommunitySize ?? 1;
+    const maxIterations = options.maxIterations ?? 100; // Prevent infinite loops
 
     const dendrogram: CommunityResult[] = [];
-    const workingGraph = cloneGraph(graph);
+    const workingGraph = graph.clone();
+    let iterations = 0;
 
     // Initial state: one large component
     let components = getConnectedComponentsResult(workingGraph);
@@ -38,7 +40,8 @@ export function girvanNewman(
         modularity: calculateModularity(graph, components.componentMap),
     });
 
-    while (Array.from(workingGraph.edges()).length > 0) {
+    while (Array.from(workingGraph.edges()).length > 0 && iterations < maxIterations) {
+        iterations++;
         // Calculate edge betweenness centrality
         const edgeBetweenness = calculateEdgeBetweenness(workingGraph);
 
@@ -187,7 +190,7 @@ function calculateEdgeBetweenness(graph: Graph): Map<string, number> {
 }
 
 /**
- * Find all shortest paths from a source node using BFS
+ * Find all shortest paths from a source node using optimized BFS
  */
 function findAllShortestPaths(graph: Graph, source: NodeId): {
     distances: Map<NodeId, number>;
@@ -198,39 +201,43 @@ function findAllShortestPaths(graph: Graph, source: NodeId): {
     const predecessors = new Map<NodeId, NodeId[]>();
     const pathCounts = new Map<NodeId, number>();
     const queue: NodeId[] = [];
+    const visited = new Set<NodeId>();
 
-    // Initialize
-    for (const node of graph.nodes()) {
-        distances.set(node.id, Infinity);
-        predecessors.set(node.id, []);
-        pathCounts.set(node.id, 0);
-    }
-
+    // Only initialize for reachable nodes
     distances.set(source, 0);
+    predecessors.set(source, []);
     pathCounts.set(source, 1);
     queue.push(source);
 
-    // BFS
-    while (queue.length > 0) {
-        const current = queue.shift();
-        if (current === undefined) {
-            break;
+    // Optimized BFS with early termination
+    let queueIndex = 0;
+    while (queueIndex < queue.length) {
+        const current = queue[queueIndex++];
+        if (!current) {
+            continue;
+        }
+
+        if (visited.has(current)) {
+            continue;
         }
 
+        visited.add(current);
+
         const currentDistance = distances.get(current);
         if (currentDistance === undefined) {
             continue;
         }
 
         for (const neighbor of graph.neighbors(current)) {
-            const edge = graph.getEdge(current, neighbor);
-            const edgeWeight = edge?.weight ?? 1;
-            const newDistance = currentDistance + edgeWeight;
-            const neighborDistance = distances.get(neighbor);
-            if (neighborDistance === undefined) {
+            // Skip if already processed
+            if (visited.has(neighbor)) {
                 continue;
             }
 
+            const edgeWeight = 1; // Unweighted for community detection
+            const newDistance = currentDistance + edgeWeight;
+            const neighborDistance = distances.get(neighbor) ?? Infinity;
+
             if (newDistance < neighborDistance) {
                 // Found shorter path
                 distances.set(neighbor, newDistance);
@@ -241,15 +248,15 @@ function findAllShortestPaths(graph: Graph, source: NodeId): {
                 }
 
                 queue.push(neighbor);
-            } else if (Math.abs(newDistance - neighborDistance) < 1e-10) {
+            } else if (newDistance === neighborDistance) {
                 // Found alternative shortest path
                 const neighborPredecessors = predecessors.get(neighbor);
-                const neighborPathCount = pathCounts.get(neighbor);
-                const currentPathCount = pathCounts.get(current);
-
-                if (neighborPredecessors && neighborPathCount !== undefined && currentPathCount !== undefined) {
+                if (neighborPredecessors) {
                     neighborPredecessors.push(current);
-                    pathCounts.set(neighbor, neighborPathCount + currentPathCount);
+                    const currentPathCount = pathCounts.get(current);
+                    if (currentPathCount !== undefined) {
+                        pathCounts.set(neighbor, (pathCounts.get(neighbor) ?? 0) + currentPathCount);
+                    }
                 }
             }
         }
@@ -274,7 +281,7 @@ function getEdgeKey(source: NodeId, target: NodeId): string {
 }
 
 /**
- * Calculate modularity for a given community structure
+ * Calculate modularity for a given community structure - optimized version
  */
 function calculateModularity(
     graph: Graph,
@@ -286,19 +293,27 @@ function calculateModularity(
     }
 
     let modularity = 0;
+    const degrees = new Map<NodeId, number>();
 
-    // Calculate modularity: Q = (1/2m) * Σ[A_ij - (k_i * k_j)/(2m)] * δ(c_i, c_j)
-    for (const nodeI of graph.nodes()) {
-        for (const nodeJ of graph.nodes()) {
-            if (communityMap.get(nodeI.id) === communityMap.get(nodeJ.id)) {
-                const edge = graph.getEdge(nodeI.id, nodeJ.id);
-                const edgeWeight = edge?.weight ?? 0;
-
-                const degreeI = getNodeDegree(graph, nodeI.id);
-                const degreeJ = getNodeDegree(graph, nodeJ.id);
+    // Pre-calculate all degrees
+    for (const node of graph.nodes()) {
+        degrees.set(node.id, getNodeDegree(graph, node.id));
+    }
 
-                modularity += edgeWeight - ((degreeI * degreeJ) / (2 * totalEdgeWeight));
+    // Only iterate over existing edges
+    for (const edge of graph.edges()) {
+        const communityI = communityMap.get(edge.source);
+        const communityJ = communityMap.get(edge.target);
+
+        if (communityI === communityJ) {
+            const edgeWeight = edge.weight ?? 1;
+            const degreeI = degrees.get(edge.source);
+            const degreeJ = degrees.get(edge.target);
+            if (degreeI === undefined || degreeJ === undefined) {
+                continue;
             }
+
+            modularity += edgeWeight - ((degreeI * degreeJ) / (2 * totalEdgeWeight));
         }
     }
 
@@ -348,25 +363,3 @@ function getConnectedComponentsResult(graph: Graph): ComponentResult {
     return {components, componentMap};
 }
 
-/**
- * Create a deep clone of the graph
- */
-function cloneGraph(graph: Graph): Graph {
-    const clone = new Graph({
-        directed: graph.isDirected,
-        allowSelfLoops: true,
-        allowParallelEdges: false,
-    });
-
-    // Add all nodes
-    for (const node of graph.nodes()) {
-        clone.addNode(node.id, node.data);
-    }
-
-    // Add all edges
-    for (const edge of graph.edges()) {
-        clone.addEdge(edge.source, edge.target, edge.weight, edge.data);
-    }
-
-    return clone;
-}

package/src/algorithms/community/index.ts

@@ -7,7 +7,9 @@
  */
 
 export {girvanNewman} from "./girvan-newman.js";
+export type {LabelPropagationOptions, LabelPropagationResult} from "./label-propagation.js";
 export {labelPropagation, labelPropagationAsync, labelPropagationSemiSupervised} from "./label-propagation.js";
+export type {LeidenOptions, LeidenResult} from "./leiden.js";
 export {leiden} from "./leiden.js";
 export {louvain} from "./louvain.js";
 

package/src/algorithms/community/label-propagation.ts

@@ -9,6 +9,10 @@
  * detect community structures in large-scale networks"
  */
 
+import type {Graph} from "../../core/graph.js";
+import {graphToMap} from "../../utils/graph-converters.js";
+import {SeededRandom, shuffle} from "../../utils/math-utilities.js";
+
 export interface LabelPropagationOptions {
     maxIterations?: number;
     randomSeed?: number;
@@ -21,17 +25,9 @@ export interface LabelPropagationResult {
 }
 
 /**
- * Label Propagation Algorithm
- * Each node adopts the most frequent label among its neighbors
- *
- * @param graph - Undirected graph (can be weighted)
- * @param options - Algorithm options
- * @returns Community assignments
- *
- * Time Complexity: O(m) per iteration, typically O(km) for k iterations
- * Space Complexity: O(n)
+ * Internal implementation of Label Propagation Algorithm
  */
-export function labelPropagation(
+function labelPropagationImpl(
     graph: Map<string, Map<string, number>>,
     options: LabelPropagationOptions = {},
 ): LabelPropagationResult {
@@ -49,11 +45,7 @@ export function labelPropagation(
     }
 
     // Initialize random number generator
-    let seed = randomSeed;
-    const random = (): number => {
-        seed = ((seed * 1664525) + 1013904223) % 2147483647;
-        return seed / 2147483647;
-    };
+    const random = SeededRandom.createGenerator(randomSeed);
 
     // Initialize labels - each node gets its own label
     const labels = new Map<string, number>();
@@ -157,10 +149,10 @@ export function labelPropagation(
 }
 
 /**
- * Asynchronous Label Propagation
+ * Internal implementation of Asynchronous Label Propagation
  * Updates all nodes simultaneously (can lead to oscillations)
  */
-export function labelPropagationAsync(
+function labelPropagationAsyncImpl(
     graph: Map<string, Map<string, number>>,
     options: LabelPropagationOptions = {},
 ): LabelPropagationResult {
@@ -267,10 +259,10 @@ export function labelPropagationAsync(
 }
 
 /**
- * Semi-supervised Label Propagation
+ * Internal implementation of Semi-supervised Label Propagation
  * Some nodes have fixed labels that don't change
  */
-export function labelPropagationSemiSupervised(
+function labelPropagationSemiSupervisedImpl(
     graph: Map<string, Map<string, number>>,
     seedLabels: Map<string, number>,
     options: LabelPropagationOptions = {},
@@ -281,11 +273,7 @@ export function labelPropagationSemiSupervised(
     } = options;
 
     // Initialize random number generator
-    let seed = randomSeed;
-    const random = (): number => {
-        seed = ((seed * 1664525) + 1013904223) % 2147483647;
-        return seed / 2147483647;
-    };
+    const random = SeededRandom.createGenerator(randomSeed);
 
     // Initialize labels
     const labels = new Map<string, number>();
@@ -376,17 +364,58 @@ export function labelPropagationSemiSupervised(
 }
 
 /**
- * Fisher-Yates shuffle
+ * Label Propagation Algorithm
+ * Each node adopts the most frequent label among its neighbors
+ *
+ * @param graph - Undirected graph (can be weighted)
+ * @param options - Algorithm options
+ * @returns Community assignments
+ *
+ * Time Complexity: O(m) per iteration, typically O(km) for k iterations
+ * Space Complexity: O(n)
  */
-function shuffle(array: unknown[], random: () => number): void {
-    for (let i = array.length - 1; i > 0; i--) {
-        const j = Math.floor(random() * (i + 1));
-        const temp = array[i];
-        const swapItem = array[j];
-        if (temp !== undefined && swapItem !== undefined) {
-            array[i] = swapItem;
-            array[j] = temp;
-        }
-    }
+export function labelPropagation(
+    graph: Graph,
+    options: LabelPropagationOptions = {},
+): LabelPropagationResult {
+    // Convert Graph to Map representation
+    const graphMap = graphToMap(graph);
+    return labelPropagationImpl(graphMap, options);
+}
+
+/**
+ * Asynchronous Label Propagation
+ * Updates all nodes simultaneously (can lead to oscillations)
+ *
+ * @param graph - Undirected graph (can be weighted)
+ * @param options - Algorithm options
+ * @returns Community assignments
+ */
+export function labelPropagationAsync(
+    graph: Graph,
+    options: LabelPropagationOptions = {},
+): LabelPropagationResult {
+    // Convert Graph to Map representation
+    const graphMap = graphToMap(graph);
+    return labelPropagationAsyncImpl(graphMap, options);
+}
+
+/**
+ * Semi-supervised Label Propagation
+ * Some nodes have fixed labels that don't change
+ *
+ * @param graph - Undirected graph (can be weighted)
+ * @param seedLabels - Initial fixed labels for some nodes
+ * @param options - Algorithm options
+ * @returns Community assignments
+ */
+export function labelPropagationSemiSupervised(
+    graph: Graph,
+    seedLabels: Map<string, number>,
+    options: LabelPropagationOptions = {},
+): LabelPropagationResult {
+    // Convert Graph to Map representation
+    const graphMap = graphToMap(graph);
+    return labelPropagationSemiSupervisedImpl(graphMap, seedLabels, options);
 }
 

package/src/algorithms/community/leiden.ts

@@ -8,7 +8,9 @@
  * "From Louvain to Leiden: guaranteeing well-connected communities"
  */
 
-// Louvain import removed - not used in this implementation
+import type {Graph} from "../../core/graph.js";
+import {graphToMap} from "../../utils/graph-converters.js";
+import {SeededRandom, shuffle} from "../../utils/math-utilities.js";
 
 export interface LeidenOptions {
     resolution?: number;
@@ -24,18 +26,11 @@ export interface LeidenResult {
 }
 
 /**
- * Leiden algorithm for community detection
+ * Internal implementation of Leiden algorithm for community detection
  * Improves upon Louvain by ensuring well-connected communities
- *
- * @param graph - Undirected weighted graph
- * @param options - Algorithm options
- * @returns Community assignments and modularity
- *
- * Time Complexity: O(m) per iteration, typically O(m log m) total
- * Space Complexity: O(n + m)
  */
-export function leiden(
-    graph: Map<string, Map<string, number>>,
+function leidenImpl(
+    inputGraph: Map<string, Map<string, number>>,
     options: LeidenOptions = {},
 ): LeidenResult {
     const {
@@ -46,7 +41,7 @@ export function leiden(
     } = options;
 
     // Handle empty graph
-    if (graph.size === 0) {
+    if (inputGraph.size === 0) {
         return {
             communities: new Map(),
             modularity: 0,
@@ -54,18 +49,17 @@ export function leiden(
         };
     }
 
+    // Use a mutable variable for the current graph state
+    let currentGraph = inputGraph;
+
     // Initialize random number generator
-    let seed = randomSeed;
-    const random = (): number => {
-        seed = ((seed * 1664525) + 1013904223) % 2147483647;
-        return seed / 2147483647;
-    };
+    const random = SeededRandom.createGenerator(randomSeed);
 
     // Calculate total weight
     let totalWeight = 0;
     const degrees = new Map<string, number>();
 
-    for (const [node, neighbors] of graph) {
+    for (const [node, neighbors] of currentGraph) {
         let degree = 0;
         for (const weight of neighbors.values()) {
             degree += weight;
@@ -77,10 +71,10 @@ export function leiden(
 
     // Initialize communities - each node in its own community
     const communities = new Map<string, number>();
-    const nodes = Array.from(graph.keys());
+    const nodes = Array.from(currentGraph.keys());
     nodes.forEach((node, i) => communities.set(node, i));
 
-    let modularity = calculateModularity(graph, communities, degrees, totalWeight, resolution);
+    let modularity = calculateModularity(currentGraph, communities, degrees, totalWeight, resolution);
     let bestModularity = modularity;
     let bestCommunities = new Map(communities);
     let iterations = 0;
@@ -100,7 +94,7 @@ export function leiden(
                 continue;
             }
 
-            const neighborCommunities = getNeighborCommunities(node, graph, communities);
+            const neighborCommunities = getNeighborCommunities(node, currentGraph, communities);
 
             let bestCommunity = currentCommunity;
             let bestGain = 0;
@@ -112,7 +106,7 @@ export function leiden(
                 }
 
                 const gain = calculateModularityGain(
-                    node, community, graph, communities, degrees, totalWeight, resolution,
+                    node, community, currentGraph, communities, degrees, totalWeight, resolution,
                 );
 
                 if (gain > bestGain) {
@@ -131,11 +125,11 @@ export function leiden(
 
         // Phase 2: Refinement (Leiden improvement over Louvain)
         // Create aggregate network based on current partition
-        createAggregateNetwork(graph, communities);
+        createAggregateNetwork(currentGraph, communities);
 
         // Refine partition using aggregate network
         const subsetPartition = refinePartition(
-            graph, communities,
+            currentGraph, communities,
         );
 
         // Apply refined partition
@@ -144,7 +138,7 @@ export function leiden(
         }
 
         // Recalculate modularity
-        modularity = calculateModularity(graph, communities, degrees, totalWeight, resolution);
+        modularity = calculateModularity(currentGraph, communities, degrees, totalWeight, resolution);
 
         // Check if we've improved
         if (modularity > bestModularity + threshold) {
@@ -158,17 +152,17 @@ export function leiden(
         }
 
         // Phase 3: Aggregate network (create super-nodes)
-        const aggregated = aggregateCommunities(graph, communities);
-        if (aggregated.graph.size === graph.size) {
+        const aggregated = aggregateCommunities(currentGraph, communities);
+        if (aggregated.graph.size === currentGraph.size) {
             break;
         } // No aggregation possible
 
         // Continue with aggregated network
-        const {graph: newGraph} = aggregated;
-        graph = newGraph;
+        const {graph: aggregatedGraph} = aggregated;
+        currentGraph = aggregatedGraph;
         communities.clear();
         let communityId = 0;
-        for (const node of graph.keys()) {
+        for (const node of currentGraph.keys()) {
             communities.set(node, communityId++);
         }
     }
@@ -556,17 +550,22 @@ function aggregateCommunities(
 }
 
 /**
- * Fisher-Yates shuffle
+ * Leiden algorithm for community detection
+ * Improves upon Louvain by ensuring well-connected communities
+ *
+ * @param graph - Undirected weighted graph - accepts Graph class or Map representation
+ * @param options - Algorithm options
+ * @returns Community assignments and modularity
+ *
+ * Time Complexity: O(m) per iteration, typically O(m log m) total
+ * Space Complexity: O(n + m)
  */
-function shuffle(array: unknown[], random: () => number): void {
-    for (let i = array.length - 1; i > 0; i--) {
-        const j = Math.floor(random() * (i + 1));
-        const temp = array[i];
-        const swapItem = array[j];
-        if (temp !== undefined && swapItem !== undefined) {
-            array[i] = swapItem;
-            array[j] = temp;
-        }
-    }
+export function leiden(
+    graph: Graph,
+    options: LeidenOptions = {},
+): LeidenResult {
+    // Convert Graph to Map representation
+    const graphMap = graphToMap(graph);
+    return leidenImpl(graphMap, options);
 }