@graphty/algorithms 1.2.0 → 1.4.2

package/dist/src/algorithms/traversal/bfs-unified.js

@@ -0,0 +1,370 @@
+import { DirectionOptimizedBFS } from "../../optimized/direction-optimized-bfs.js";
+import { toCSRGraph } from "../../optimized/graph-adapter.js";
+import { reconstructPath } from "../../utils/graph-utilities.js";
+/**
+ * Unified BFS implementation that automatically optimizes for large graphs
+ *
+ * This module provides a single, user-friendly BFS implementation that:
+ * - Automatically uses Direction-Optimized BFS for large graphs (>10k nodes)
+ * - Maintains backward compatibility with existing APIs
+ * - Requires no configuration or understanding of optimization thresholds
+ * - Provides the best performance by default
+ */
+// Cache for CSR conversions to avoid repeated conversions
+const csrCache = new WeakMap();
+/**
+ * Get or create CSR representation of a graph
+ * @param graph - The input graph to convert
+ * @returns CSR graph representation (cached for efficiency)
+ */
+function getCSRGraph(graph) {
+    let csrGraph = csrCache.get(graph);
+    if (!csrGraph) {
+        csrGraph = toCSRGraph(graph);
+        csrCache.set(graph, csrGraph);
+    }
+    return csrGraph;
+}
+/**
+ * Perform breadth-first search starting from a given node
+ *
+ * Automatically uses the most optimized implementation based on graph size.
+ * No configuration needed - just call this function for the best performance.
+ * @param graph - The input graph to traverse
+ * @param startNode - The node to start the BFS from
+ * @param options - Traversal options (callbacks, target node, etc.)
+ * @returns Traversal result with visited nodes, order, and tree structure
+ */
+export function breadthFirstSearch(graph, startNode, options = {}) {
+    if (!graph.hasNode(startNode)) {
+        throw new Error(`Start node ${String(startNode)} not found in graph`);
+    }
+    // Automatically use optimized implementation for large graphs
+    if (graph.nodeCount > 10000) {
+        return breadthFirstSearchOptimized(graph, startNode, options);
+    }
+    // Standard implementation for smaller graphs
+    return breadthFirstSearchStandard(graph, startNode, options);
+}
+/**
+ * Standard BFS implementation for smaller graphs
+ * @param graph - The input graph to traverse
+ * @param startNode - The node to start the BFS from
+ * @param options - Traversal options (callbacks, target node, etc.)
+ * @returns Traversal result with visited nodes, order, and tree structure
+ */
+function breadthFirstSearchStandard(graph, startNode, options = {}) {
+    const visited = new Set();
+    const queue = [];
+    const order = [];
+    const tree = new Map();
+    // Initialize with start node
+    queue.push({ node: startNode, level: 0 });
+    visited.add(startNode);
+    tree.set(startNode, null);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+            break;
+        }
+        order.push(current.node);
+        // Call visitor callback if provided
+        if (options.visitCallback) {
+            options.visitCallback(current.node, current.level);
+        }
+        // Early termination if target found
+        if (options.targetNode && current.node === options.targetNode) {
+            break;
+        }
+        // Explore neighbors
+        for (const neighbor of graph.neighbors(current.node)) {
+            if (!visited.has(neighbor)) {
+                visited.add(neighbor);
+                tree.set(neighbor, current.node);
+                queue.push({ node: neighbor, level: current.level + 1 });
+            }
+        }
+    }
+    return { visited, order, tree };
+}
+/**
+ * Optimized BFS implementation using Direction-Optimized BFS
+ * @param graph - The input graph to traverse
+ * @param startNode - The node to start the BFS from
+ * @param options - Traversal options (callbacks, target node, etc.)
+ * @returns Traversal result with visited nodes, order, and tree structure
+ */
+function breadthFirstSearchOptimized(graph, startNode, options = {}) {
+    const csrGraph = getCSRGraph(graph);
+    const dobfs = new DirectionOptimizedBFS(csrGraph, {
+        alpha: 15.0,
+        beta: 20.0,
+    });
+    const result = dobfs.search(startNode);
+    // Convert result to TraversalResult format
+    const visited = new Set();
+    const order = [];
+    const tree = new Map();
+    // Build traversal order using BFS from distances
+    const nodesByDistance = new Map();
+    let maxDistance = 0;
+    for (const [nodeId, distance] of result.distances) {
+        visited.add(nodeId);
+        tree.set(nodeId, result.parents.get(nodeId) ?? null);
+        if (!nodesByDistance.has(distance)) {
+            nodesByDistance.set(distance, []);
+        }
+        nodesByDistance.get(distance)?.push(nodeId);
+        maxDistance = Math.max(maxDistance, distance);
+    }
+    // Reconstruct BFS order
+    for (let d = 0; d <= maxDistance; d++) {
+        const nodes = nodesByDistance.get(d);
+        if (nodes) {
+            order.push(...nodes);
+        }
+    }
+    // Handle visit callback if provided
+    if (options.visitCallback) {
+        for (const [nodeId, distance] of result.distances) {
+            options.visitCallback(nodeId, distance);
+        }
+    }
+    return { visited, order, tree };
+}
+/**
+ * Find shortest path between two nodes using BFS
+ *
+ * Automatically optimized for large graphs. Returns null if no path exists.
+ * @param graph - The input graph to search
+ * @param source - The source node ID
+ * @param target - The target node ID
+ * @returns Shortest path result or null if no path exists
+ */
+export function shortestPathBFS(graph, source, target) {
+    if (!graph.hasNode(source)) {
+        throw new Error(`Source node ${String(source)} not found in graph`);
+    }
+    if (!graph.hasNode(target)) {
+        throw new Error(`Target node ${String(target)} not found in graph`);
+    }
+    // Special case: source equals target
+    if (source === target) {
+        return {
+            distance: 0,
+            path: [source],
+            predecessor: new Map([[source, null]]),
+        };
+    }
+    // Use optimized implementation for large graphs
+    if (graph.nodeCount > 10000) {
+        return shortestPathBFSOptimized(graph, source, target);
+    }
+    // Standard implementation
+    return shortestPathBFSStandard(graph, source, target);
+}
+/**
+ * Standard shortest path BFS
+ * @param graph - The input graph to search
+ * @param source - The source node ID
+ * @param target - The target node ID
+ * @returns Shortest path result or null if no path exists
+ */
+function shortestPathBFSStandard(graph, source, target) {
+    const visited = new Set();
+    const queue = [];
+    const predecessor = new Map();
+    // Initialize BFS
+    queue.push({ node: source, distance: 0 });
+    visited.add(source);
+    predecessor.set(source, null);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+            break;
+        }
+        // Target found
+        if (current.node === target) {
+            const path = reconstructPath(target, predecessor);
+            return {
+                distance: current.distance,
+                path,
+                predecessor,
+            };
+        }
+        // Explore neighbors
+        for (const neighbor of graph.neighbors(current.node)) {
+            if (!visited.has(neighbor)) {
+                visited.add(neighbor);
+                predecessor.set(neighbor, current.node);
+                queue.push({ node: neighbor, distance: current.distance + 1 });
+            }
+        }
+    }
+    // No path found
+    return null;
+}
+/**
+ * Optimized shortest path using Direction-Optimized BFS
+ * @param graph - The input graph to search
+ * @param source - The source node ID
+ * @param target - The target node ID
+ * @returns Shortest path result or null if no path exists
+ */
+function shortestPathBFSOptimized(graph, source, target) {
+    const csrGraph = getCSRGraph(graph);
+    const dobfs = new DirectionOptimizedBFS(csrGraph, {
+        alpha: 15.0,
+        beta: 20.0,
+    });
+    // Perform BFS
+    const result = dobfs.search(source);
+    // Check if target was reached
+    const distance = result.distances.get(target);
+    if (distance === undefined) {
+        return null; // No path found
+    }
+    // Reconstruct path
+    const path = reconstructPath(target, result.parents);
+    return {
+        distance,
+        path,
+        predecessor: result.parents,
+    };
+}
+/**
+ * Find shortest paths from source to all reachable nodes
+ *
+ * Automatically optimized for large graphs.
+ * @param graph - The input graph to search
+ * @param source - The source node ID to compute shortest paths from
+ * @returns Map of node IDs to their shortest path results
+ */
+export function singleSourceShortestPathBFS(graph, source) {
+    if (!graph.hasNode(source)) {
+        throw new Error(`Source node ${String(source)} not found in graph`);
+    }
+    // Use optimized implementation for large graphs
+    if (graph.nodeCount > 10000) {
+        return singleSourceShortestPathBFSOptimized(graph, source);
+    }
+    // Standard implementation
+    return singleSourceShortestPathBFSStandard(graph, source);
+}
+/**
+ * Standard single-source shortest paths
+ * @param graph - The input graph to search
+ * @param source - The source node ID to compute shortest paths from
+ * @returns Map of node IDs to their shortest path results
+ */
+function singleSourceShortestPathBFSStandard(graph, source) {
+    const results = new Map();
+    const visited = new Set();
+    const queue = [];
+    const predecessor = new Map();
+    const distances = new Map();
+    // Initialize BFS
+    queue.push({ node: source, distance: 0 });
+    visited.add(source);
+    predecessor.set(source, null);
+    distances.set(source, 0);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+            break;
+        }
+        // Explore neighbors
+        for (const neighbor of graph.neighbors(current.node)) {
+            if (!visited.has(neighbor)) {
+                visited.add(neighbor);
+                predecessor.set(neighbor, current.node);
+                distances.set(neighbor, current.distance + 1);
+                queue.push({ node: neighbor, distance: current.distance + 1 });
+            }
+        }
+    }
+    // Build results after BFS completes
+    // This avoids copying the predecessor map for each node
+    for (const [node, distance] of distances) {
+        const path = reconstructPath(node, predecessor);
+        results.set(node, {
+            distance,
+            path,
+            predecessor, // Share the same predecessor map
+        });
+    }
+    return results;
+}
+/**
+ * Optimized single-source shortest paths
+ * @param graph - The input graph to search
+ * @param source - The source node ID to compute shortest paths from
+ * @returns Map of node IDs to their shortest path results
+ */
+function singleSourceShortestPathBFSOptimized(graph, source) {
+    const csrGraph = getCSRGraph(graph);
+    const dobfs = new DirectionOptimizedBFS(csrGraph, {
+        alpha: 15.0,
+        beta: 20.0,
+    });
+    const bfsResult = dobfs.search(source);
+    // Convert to expected format
+    const results = new Map();
+    for (const [nodeId, distance] of bfsResult.distances) {
+        // Reconstruct path for each node
+        const path = reconstructPath(nodeId, bfsResult.parents);
+        results.set(nodeId, {
+            distance,
+            path,
+            predecessor: bfsResult.parents, // Share the same predecessor map
+        });
+    }
+    return results;
+}
+/**
+ * Check if the graph is bipartite using BFS coloring
+ *
+ * Note: This function does not use Direction-Optimized BFS as the
+ * coloring logic is specific and doesn't benefit from the optimization.
+ * @param graph - The undirected graph to check
+ * @returns True if the graph is bipartite, false otherwise
+ */
+export function isBipartite(graph) {
+    if (graph.isDirected) {
+        throw new Error("Bipartite test requires an undirected graph");
+    }
+    const color = new Map();
+    const visited = new Set();
+    // Check each connected component
+    for (const node of Array.from(graph.nodes())) {
+        if (!visited.has(node.id)) {
+            const queue = [node.id];
+            color.set(node.id, 0);
+            visited.add(node.id);
+            while (queue.length > 0) {
+                const current = queue.shift();
+                if (!current) {
+                    break;
+                }
+                const currentColor = color.get(current);
+                if (currentColor === undefined) {
+                    continue;
+                }
+                for (const neighbor of Array.from(graph.neighbors(current))) {
+                    if (!visited.has(neighbor)) {
+                        // Color with opposite color
+                        color.set(neighbor, currentColor === 0 ? 1 : 0);
+                        visited.add(neighbor);
+                        queue.push(neighbor);
+                    }
+                    else if (color.get(neighbor) === currentColor) {
+                        // Same color as current node - not bipartite
+                        return false;
+                    }
+                }
+            }
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=bfs-unified.js.map

package/dist/src/algorithms/traversal/bfs-unified.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bfs-unified.js","sourceRoot":"","sources":["../../../../src/algorithms/traversal/bfs-unified.ts"],"names":[],"mappings":"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"}

package/dist/src/algorithms/traversal/bfs-variants.d.ts

@@ -0,0 +1,77 @@
+import type { Graph } from "../../core/graph.js";
+import type { NodeId } from "../../types/index.js";
+/**
+ * BFS that tracks shortest path counts (for betweenness centrality)
+ *
+ * This variant of BFS computes:
+ * - Shortest distances from source to all reachable nodes
+ * - All predecessors on shortest paths
+ * - Number of shortest paths (sigma)
+ * - Stack of nodes in reverse BFS order
+ * @param graph - The input graph to traverse
+ * @param source - The source node to start BFS from
+ * @param options - Configuration options
+ * @param options.optimized - Whether to use CSR-optimized implementation for large graphs
+ * @returns Object containing distances, predecessors, path counts (sigma), and traversal stack
+ */
+export declare function bfsWithPathCounting(graph: Graph, source: NodeId, options?: {
+    optimized?: boolean;
+}): {
+    distances: Map<NodeId, number>;
+    predecessors: Map<NodeId, NodeId[]>;
+    sigma: Map<NodeId, number>;
+    stack: NodeId[];
+};
+/**
+ * BFS that only returns distances (for closeness centrality)
+ *
+ * Optimized variant that skips predecessor tracking
+ * @param graph - The input graph to traverse
+ * @param source - The source node to start BFS from
+ * @param cutoff - Maximum distance to explore (optional)
+ * @param options - Configuration options
+ * @param options.optimized - Whether to use CSR-optimized implementation for large graphs
+ * @returns Map of node IDs to their shortest distances from the source
+ */
+export declare function bfsDistancesOnly(graph: Graph, source: NodeId, cutoff?: number, options?: {
+    optimized?: boolean;
+}): Map<NodeId, number>;
+/**
+ * BFS for bipartite checking with partition sets
+ *
+ * Returns whether the graph is bipartite and the two partitions if it is
+ * @param graph - The input graph to check for bipartiteness
+ * @returns Object with bipartite status and optional partition sets
+ */
+export declare function bfsColoringWithPartitions(graph: Graph): {
+    isBipartite: boolean;
+    partitions?: [Set<NodeId>, Set<NodeId>];
+};
+/**
+ * BFS for finding augmenting paths (for flow algorithms)
+ *
+ * Finds a path from source to sink in a residual graph with positive capacity
+ * @param residualGraph - Map representing the residual graph with capacities
+ * @param source - The source node ID
+ * @param sink - The sink node ID
+ * @returns Object with path and capacity, or null if no path exists
+ */
+export declare function bfsAugmentingPath(residualGraph: Map<string, Map<string, number>>, source: string, sink: string): {
+    path: string[];
+    pathCapacity: number;
+} | null;
+/**
+ * BFS for weighted graphs using priority queue (simplified Dijkstra)
+ *
+ * Returns distances from source using edge weights
+ * @param graph - The input weighted graph to traverse
+ * @param source - The source node to start BFS from
+ * @param cutoff - Maximum distance to explore (optional)
+ * @param options - Configuration options
+ * @param options.optimized - Whether to use CSR-optimized implementation for large graphs
+ * @returns Map of node IDs to their shortest weighted distances from the source
+ */
+export declare function bfsWeightedDistances(graph: Graph, source: NodeId, cutoff?: number, options?: {
+    optimized?: boolean;
+}): Map<NodeId, number>;
+//# sourceMappingURL=bfs-variants.d.ts.map

package/dist/src/algorithms/traversal/bfs-variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bfs-variants.d.ts","sourceRoot":"","sources":["../../../../src/algorithms/traversal/bfs-variants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAKjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AASnD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAC/B,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GACtC;IACC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACpC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3B,KAAK,EAAE,MAAM,EAAE,CAAC;CACnB,CA0DA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC5B,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GACtC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAsCrB;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,KAAK,GAAG;IACrD,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;CAC3C,CA4CA;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC7B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC/C,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACb;IACC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;CACxB,GAAG,IAAI,CA8CP;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAChC,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GACtC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAqDrB"}