@graphty/algorithms 1.2.0 → 1.4.2

package/src/benchmark-all-algorithms.ts

@@ -0,0 +1,580 @@
+/* eslint-disable no-console */
+/**
+ * Comprehensive benchmark suite for ALL 98 algorithms in @graphty/algorithms
+ *
+ * Two modes:
+ * - Full benchmark: Completes in under 1 hour
+ * - Quick benchmark: Completes in under 2 minutes
+ */
+
+import * as algorithms from "./algorithms/index.js";
+import { Graph } from "./core/graph.js";
+
+interface BenchmarkResult {
+    algorithm: string;
+    category: string;
+    executionTime: number;
+    success: boolean;
+    error?: string;
+    nodeCount: number;
+    edgeCount: number;
+    mode: "quick" | "full";
+}
+
+const ALGORITHM_CATEGORIES = {
+    traversal: {
+        algorithms: [
+            "breadthFirstSearch",
+            "isBipartite",
+            "shortestPathBFS",
+            "singleSourceShortestPathBFS",
+            "depthFirstSearch",
+            "findStronglyConnectedComponents",
+            "hasCycleDFS",
+            "topologicalSort",
+        ],
+        config: {
+            name: "Traversal",
+            quick: { nodes: 1000, edges: 5000, runs: 3 },
+            full: { nodes: 10000, edges: 50000, runs: 10 },
+        },
+    },
+    shortestPath: {
+        algorithms: [
+            "bellmanFord",
+            "bellmanFordPath",
+            "hasNegativeCycle",
+            "allPairsShortestPath",
+            "dijkstra",
+            "dijkstraPath",
+            "singleSourceShortestPath",
+            "floydWarshall",
+            "floydWarshallPath",
+            "transitiveClosure",
+        ],
+        config: {
+            name: "Shortest Path",
+            quick: { nodes: 100, edges: 500, runs: 1 }, // Smaller for O(V³) algorithms
+            full: { nodes: 500, edges: 2500, runs: 3 },
+        },
+    },
+    centrality: {
+        algorithms: [
+            "betweennessCentrality",
+            "closenessCentrality",
+            "degreeCentrality",
+            "eigenvectorCentrality",
+            "hits",
+            "katzCentrality",
+            "pageRank",
+            "personalizedPageRank",
+        ],
+        config: {
+            name: "Centrality",
+            quick: { nodes: 500, edges: 2500, runs: 1 },
+            full: { nodes: 2000, edges: 10000, runs: 3 },
+        },
+    },
+    components: {
+        algorithms: [
+            "connectedComponents",
+            "connectedComponentsDFS",
+            "stronglyConnectedComponents",
+            "weaklyConnectedComponents",
+            "isConnected",
+            "isStronglyConnected",
+            "isWeaklyConnected",
+            "numberOfConnectedComponents",
+            "largestConnectedComponent",
+            "getConnectedComponent",
+        ],
+        config: {
+            name: "Components",
+            quick: { nodes: 2000, edges: 10000, runs: 3 },
+            full: { nodes: 10000, edges: 50000, runs: 10 },
+        },
+    },
+    mst: {
+        algorithms: ["kruskalMST", "primMST", "minimumSpanningTree"],
+        config: {
+            name: "Minimum Spanning Tree",
+            quick: { nodes: 1000, edges: 5000, runs: 5 },
+            full: { nodes: 5000, edges: 25000, runs: 10 },
+        },
+    },
+    community: {
+        algorithms: ["girvanNewman", "labelPropagation", "leiden", "louvain"],
+        config: {
+            name: "Community Detection",
+            quick: { nodes: 200, edges: 1000, runs: 1 }, // Very expensive algorithms
+            full: { nodes: 1000, edges: 5000, runs: 2 },
+        },
+    },
+    matching: {
+        algorithms: ["bipartitePartition", "greedyBipartiteMatching", "maximumBipartiteMatching"],
+        config: {
+            name: "Matching",
+            quick: { nodes: 500, edges: 1000, runs: 3 },
+            full: { nodes: 2000, edges: 4000, runs: 5 },
+        },
+    },
+} as const;
+
+/**
+ * Main benchmark runner
+ * @param mode - The benchmark mode: "quick" for fast tests or "full" for comprehensive tests
+ * @returns Array of benchmark results for all tested algorithms
+ */
+export function runAllAlgorithmsBenchmark(mode: "quick" | "full" = "full"): BenchmarkResult[] {
+    const startTime = Date.now();
+    const timeLimit = mode === "quick" ? 2 * 60 * 1000 : 60 * 60 * 1000; // 2 min or 1 hour
+
+    console.log(
+        `🚀 ${mode === "quick" ? "Quick" : "Comprehensive"} Benchmark - All ${String(getTotalAlgorithmCount())} Algorithms`,
+    );
+    console.log(`=${"=".repeat(60)}`);
+    console.log(`Time limit: ${mode === "quick" ? "2 minutes" : "1 hour"}`);
+    console.log(`Start time: ${new Date().toLocaleTimeString()}\n`);
+
+    const results: BenchmarkResult[] = [];
+    let totalTested = 0;
+    let totalPassed = 0;
+
+    for (const [categoryKey, categoryData] of Object.entries(ALGORITHM_CATEGORIES)) {
+        const elapsed = Date.now() - startTime;
+        if (elapsed > timeLimit) {
+            console.log("⏰ Time limit reached, stopping benchmark");
+            break;
+        }
+
+        console.log(`\n📊 ${categoryData.config.name} Algorithms`);
+        console.log("-".repeat(categoryData.config.name.length + 12));
+
+        const config = categoryData.config[mode];
+        const graph = createTestGraph(config.nodes, config.edges, categoryKey);
+
+        for (const algoName of categoryData.algorithms) {
+            const elapsed = Date.now() - startTime;
+            if (elapsed > timeLimit) {
+                console.log(`⏰ Time limit reached in category ${categoryData.config.name}`);
+                break;
+            }
+
+            const result = benchmarkAlgorithm(algoName, categoryData.config.name, graph, config.runs, mode);
+            results.push(result);
+            totalTested++;
+
+            if (result.success) {
+                totalPassed++;
+                console.log(`  ✅ ${algoName}: ${result.executionTime.toFixed(2)}ms`);
+            } else {
+                console.log(`  ❌ ${algoName}: ${result.error?.substring(0, 50) ?? "Failed"}`);
+            }
+        }
+    }
+
+    const totalTime = (Date.now() - startTime) / 1000;
+
+    console.log("\n📈 Benchmark Complete");
+    console.log("===================");
+    console.log(`Total time: ${totalTime.toFixed(1)}s`);
+    console.log(`Algorithms tested: ${String(totalTested)}`);
+    console.log(
+        `Success rate: ${String(totalPassed)}/${String(totalTested)} (${((totalPassed / totalTested) * 100).toFixed(1)}%)`,
+    );
+
+    if (mode === "full") {
+        displayDetailedResults(results);
+    }
+
+    return results;
+}
+
+/**
+ * Benchmark a single algorithm
+ * @param algoName - The name of the algorithm to benchmark
+ * @param category - The category the algorithm belongs to
+ * @param graph - The test graph to run the algorithm on
+ * @param runs - Number of times to run the algorithm for averaging
+ * @param mode - The benchmark mode (quick or full)
+ * @returns The benchmark result containing timing and success information
+ */
+function benchmarkAlgorithm(
+    algoName: string,
+    category: string,
+    graph: Graph,
+    runs: number,
+    mode: "quick" | "full",
+): BenchmarkResult {
+    const algo = (algorithms as Record<string, unknown>)[algoName];
+
+    if (!algo || typeof algo !== "function") {
+        return {
+            algorithm: algoName,
+            category,
+            executionTime: 0,
+            success: false,
+            error: "Algorithm not found or not a function",
+            nodeCount: graph.nodeCount,
+            edgeCount: graph.uniqueEdgeCount,
+            mode,
+        };
+    }
+
+    try {
+        const times: number[] = [];
+
+        for (let i = 0; i < runs; i++) {
+            const args = getAlgorithmArgs(algoName, graph);
+            const start = performance.now();
+
+            (algo as (...args: unknown[]) => unknown)(...args);
+
+            const time = performance.now() - start;
+            times.push(time);
+        }
+
+        // Use median time to avoid outliers
+        times.sort((a, b) => a - b);
+        const medianTime = times[Math.floor(times.length / 2)] ?? 0;
+
+        return {
+            algorithm: algoName,
+            category,
+            executionTime: medianTime,
+            success: true,
+            nodeCount: graph.nodeCount,
+            edgeCount: graph.uniqueEdgeCount,
+            mode,
+        };
+    } catch (error) {
+        return {
+            algorithm: algoName,
+            category,
+            executionTime: 0,
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+            nodeCount: graph.nodeCount,
+            edgeCount: graph.uniqueEdgeCount,
+            mode,
+        };
+    }
+}
+
+/**
+ * Get appropriate arguments for each algorithm
+ * @param algoName - The name of the algorithm to get arguments for
+ * @param graph - The base graph to use for generating arguments
+ * @returns Array of arguments to pass to the algorithm function
+ */
+function getAlgorithmArgs(algoName: string, graph: Graph): unknown[] {
+    // Get random nodes for algorithms that need them
+    const nodes = Array.from(graph.nodes()).map((n) => n.id);
+    const randomNode = nodes[Math.floor(Math.random() * nodes.length)];
+    const randomNode2 = nodes[Math.floor(Math.random() * nodes.length)];
+
+    // Algorithm-specific argument mapping
+    switch (algoName) {
+        // Single source algorithms
+        case "breadthFirstSearch":
+        case "depthFirstSearch":
+        case "singleSourceShortestPathBFS":
+        case "singleSourceShortestPath":
+        case "dijkstra":
+        case "bellmanFord":
+            return [graph, randomNode];
+
+        // PageRank algorithms need directed graph
+        case "pageRank": {
+            const directedForPR = createDirectedGraph(graph);
+            return [directedForPR];
+        }
+
+        case "personalizedPageRank": {
+            const directedForPPR = createDirectedGraph(graph);
+            const personalNodes = [randomNode]; // Array of nodes for personalization
+            return [directedForPPR, personalNodes];
+        }
+
+        // Two node algorithms
+        case "shortestPathBFS":
+        case "dijkstraPath":
+        case "bellmanFordPath":
+            return [graph, randomNode, randomNode2];
+
+        // Component-specific algorithms
+        case "getConnectedComponent":
+            return [graph, randomNode];
+
+        // Algorithms that need specific graph types
+        case "topologicalSort":
+        case "findStronglyConnectedComponents":
+        case "stronglyConnectedComponents":
+        case "weaklyConnectedComponents":
+        case "isStronglyConnected":
+        case "isWeaklyConnected": {
+            // Create a directed version of the graph for these algorithms
+            const directedGraph = createDirectedGraph(graph);
+            return [directedGraph];
+        }
+
+        // Bipartite algorithms need bipartite graphs
+        case "bipartitePartition":
+        case "greedyBipartiteMatching":
+        case "maximumBipartiteMatching": {
+            const bipartiteGraph = createBipartiteGraph(Math.floor(graph.nodeCount / 2));
+            return [bipartiteGraph];
+        }
+
+        // Community detection algorithms
+        case "labelPropagation":
+        case "leiden":
+        case "louvain":
+        case "girvanNewman":
+            return [graph, {}]; // Pass empty options
+
+        // Default: just the graph
+        default:
+            return [graph];
+    }
+}
+
+/**
+ * Create test graph appropriate for each algorithm category
+ * @param nodes - Number of nodes in the test graph
+ * @param edges - Target number of edges in the test graph
+ * @param category - The algorithm category to optimize the graph structure for
+ * @returns A new test graph with the specified structure
+ */
+function createTestGraph(nodes: number, edges: number, category: string): Graph {
+    const graph = new Graph();
+
+    // Add nodes
+    for (let i = 0; i < nodes; i++) {
+        graph.addNode(i);
+    }
+
+    // Create different graph structures for different algorithm categories
+    switch (category) {
+        case "shortestPath":
+            // Sparse connected graph for shortest path algorithms
+            createConnectedGraph(graph, Math.min(edges, nodes * 3));
+            break;
+
+        case "centrality":
+            // Small-world graph good for centrality analysis
+            createSmallWorldGraph(graph, Math.floor(edges / nodes));
+            break;
+
+        case "community":
+            // Graph with community structure
+            createCommunityGraph(graph, edges);
+            break;
+
+        default:
+            // Random connected graph
+            createConnectedGraph(graph, edges);
+    }
+
+    return graph;
+}
+
+/**
+ * Create a connected random graph
+ * @param graph - The graph to add edges to
+ * @param targetEdges - Target number of edges to create
+ */
+function createConnectedGraph(graph: Graph, targetEdges: number): void {
+    const nodes = graph.nodeCount;
+
+    // First create a spanning tree to ensure connectivity
+    for (let i = 1; i < nodes; i++) {
+        const parent = Math.floor(Math.random() * i);
+        graph.addEdge(parent, i);
+    }
+
+    // Add remaining edges randomly
+    let edgesAdded = nodes - 1;
+    while (edgesAdded < targetEdges) {
+        const source = Math.floor(Math.random() * nodes);
+        const target = Math.floor(Math.random() * nodes);
+
+        if (source !== target && !graph.hasEdge(source, target)) {
+            graph.addEdge(source, target);
+            edgesAdded++;
+        }
+    }
+}
+
+/**
+ * Create small-world graph (Watts-Strogatz model)
+ * @param graph - The graph to add edges to
+ * @param avgDegree - Target average degree for each node
+ */
+function createSmallWorldGraph(graph: Graph, avgDegree: number): void {
+    const nodes = graph.nodeCount;
+    const k = Math.floor(avgDegree / 2);
+
+    // Ring lattice
+    for (let i = 0; i < nodes; i++) {
+        for (let j = 1; j <= k; j++) {
+            const target = (i + j) % nodes;
+            graph.addEdge(i, target);
+        }
+    }
+
+    // Rewire some edges
+    const rewireProb = 0.1;
+    for (let i = 0; i < nodes; i++) {
+        for (let j = 1; j <= k; j++) {
+            if (Math.random() < rewireProb) {
+                const oldTarget = (i + j) % nodes;
+                const newTarget = Math.floor(Math.random() * nodes);
+                if (newTarget !== i && !graph.hasEdge(i, newTarget)) {
+                    graph.removeEdge(i, oldTarget);
+                    graph.addEdge(i, newTarget);
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Create graph with community structure
+ * @param graph - The graph to add edges to
+ * @param targetEdges - Target number of edges to create
+ */
+function createCommunityGraph(graph: Graph, targetEdges: number): void {
+    const nodes = graph.nodeCount;
+    const communities = Math.min(5, Math.floor(nodes / 20)); // 5 communities max
+    const communitySize = Math.floor(nodes / communities);
+
+    let edgesAdded = 0;
+
+    // Create dense connections within communities
+    for (let c = 0; c < communities; c++) {
+        const start = c * communitySize;
+        const end = Math.min((c + 1) * communitySize, nodes);
+
+        for (let i = start; i < end && edgesAdded < targetEdges; i++) {
+            for (let j = i + 1; j < end && edgesAdded < targetEdges; j++) {
+                if (Math.random() < 0.8) {
+                    // High probability within community
+                    graph.addEdge(i, j);
+                    edgesAdded++;
+                }
+            }
+        }
+    }
+
+    // Add sparse connections between communities
+    while (edgesAdded < targetEdges) {
+        const source = Math.floor(Math.random() * nodes);
+        const target = Math.floor(Math.random() * nodes);
+
+        if (source !== target && !graph.hasEdge(source, target)) {
+            graph.addEdge(source, target);
+            edgesAdded++;
+        }
+    }
+}
+
+/**
+ * Create directed version of graph
+ * @param undirectedGraph - The undirected graph to convert
+ * @returns A new directed graph with the same nodes and edges
+ */
+function createDirectedGraph(undirectedGraph: Graph): Graph {
+    const directedGraph = new Graph({ directed: true });
+
+    // Copy nodes
+    for (const node of undirectedGraph.nodes()) {
+        directedGraph.addNode(node.id);
+    }
+
+    // Copy edges as directed
+    for (const edge of undirectedGraph.edges()) {
+        directedGraph.addEdge(edge.source, edge.target);
+    }
+
+    return directedGraph;
+}
+
+/**
+ * Create bipartite graph
+ * @param nodesPerPartition - Number of nodes in each partition
+ * @returns A new bipartite graph with sparse connections between partitions
+ */
+function createBipartiteGraph(nodesPerPartition: number): Graph {
+    const graph = new Graph();
+
+    // Add nodes (0 to n-1 in first partition, n to 2n-1 in second)
+    for (let i = 0; i < nodesPerPartition * 2; i++) {
+        graph.addNode(i);
+    }
+
+    // Add edges only between partitions
+    for (let i = 0; i < nodesPerPartition; i++) {
+        for (let j = nodesPerPartition; j < nodesPerPartition * 2; j++) {
+            if (Math.random() < 0.3) {
+                // Sparse bipartite graph
+                graph.addEdge(i, j);
+            }
+        }
+    }
+
+    return graph;
+}
+
+/**
+ * Get total algorithm count
+ * @returns The total number of algorithms across all categories
+ */
+function getTotalAlgorithmCount(): number {
+    return Object.values(ALGORITHM_CATEGORIES).reduce((total, category) => total + category.algorithms.length, 0);
+}
+
+/**
+ * Display detailed results for full benchmark
+ * @param results - Array of benchmark results to display
+ */
+function displayDetailedResults(results: BenchmarkResult[]): void {
+    console.log("\n📊 Detailed Results");
+    console.log("==================");
+
+    const categories = new Map<string, BenchmarkResult[]>();
+
+    for (const result of results) {
+        if (!categories.has(result.category)) {
+            categories.set(result.category, []);
+        }
+
+        categories.get(result.category)?.push(result);
+    }
+
+    for (const [category, categoryResults] of categories) {
+        console.log(`\n${category}:`);
+        console.log("-".repeat(category.length + 1));
+
+        const successful = categoryResults.filter((r) => r.success);
+        const failed = categoryResults.filter((r) => !r.success);
+
+        if (successful.length > 0) {
+            const avgTime = successful.reduce((sum, r) => sum + r.executionTime, 0) / successful.length;
+            console.log(`  Average time: ${avgTime.toFixed(2)}ms`);
+            const minTime = Math.min(...successful.map((r) => r.executionTime));
+            const maxTime = Math.max(...successful.map((r) => r.executionTime));
+            console.log(`  Range: ${minTime.toFixed(2)}ms - ${maxTime.toFixed(2)}ms`);
+        }
+
+        if (failed.length > 0) {
+            console.log(`  Failed algorithms: ${failed.map((r) => r.algorithm).join(", ")}`);
+        }
+    }
+}
+
+// Run benchmark if called directly
+if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1] ?? ""}`) {
+    const mode = process.argv.includes("--quick") ? "quick" : "full";
+    runAllAlgorithmsBenchmark(mode);
+}