@graphty/algorithms 1.3.1 → 1.5.0

package/src/benchmark-all-algorithms.ts

@@ -8,7 +8,7 @@
  */
 
 import * as algorithms from "./algorithms/index.js";
-import {Graph} from "./core/graph.js";
+import { Graph } from "./core/graph.js";
 
 interface BenchmarkResult {
     algorithm: string;
@@ -35,8 +35,8 @@ const ALGORITHM_CATEGORIES = {
         ],
         config: {
             name: "Traversal",
-            quick: {nodes: 1000, edges: 5000, runs: 3},
-            full: {nodes: 10000, edges: 50000, runs: 10},
+            quick: { nodes: 1000, edges: 5000, runs: 3 },
+            full: { nodes: 10000, edges: 50000, runs: 10 },
         },
     },
     shortestPath: {
@@ -54,8 +54,8 @@ const ALGORITHM_CATEGORIES = {
         ],
         config: {
             name: "Shortest Path",
-            quick: {nodes: 100, edges: 500, runs: 1}, // Smaller for O(V³) algorithms
-            full: {nodes: 500, edges: 2500, runs: 3},
+            quick: { nodes: 100, edges: 500, runs: 1 }, // Smaller for O(V³) algorithms
+            full: { nodes: 500, edges: 2500, runs: 3 },
         },
     },
     centrality: {
@@ -71,8 +71,8 @@ const ALGORITHM_CATEGORIES = {
         ],
         config: {
             name: "Centrality",
-            quick: {nodes: 500, edges: 2500, runs: 1},
-            full: {nodes: 2000, edges: 10000, runs: 3},
+            quick: { nodes: 500, edges: 2500, runs: 1 },
+            full: { nodes: 2000, edges: 10000, runs: 3 },
         },
     },
     components: {
@@ -90,44 +90,48 @@ const ALGORITHM_CATEGORIES = {
         ],
         config: {
             name: "Components",
-            quick: {nodes: 2000, edges: 10000, runs: 3},
-            full: {nodes: 10000, edges: 50000, runs: 10},
+            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},
+            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},
+            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},
+            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(
+        `🚀 ${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`);
@@ -175,7 +179,9 @@ export function runAllAlgorithmsBenchmark(mode: "quick" | "full" = "full"): Benc
     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)}%)`);
+    console.log(
+        `Success rate: ${String(totalPassed)}/${String(totalTested)} (${((totalPassed / totalTested) * 100).toFixed(1)}%)`,
+    );
 
     if (mode === "full") {
         displayDetailedResults(results);
@@ -186,6 +192,12 @@ export function runAllAlgorithmsBenchmark(mode: "quick" | "full" = "full"): Benc
 
 /**
  * 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,
@@ -216,7 +228,7 @@ function benchmarkAlgorithm(
             const args = getAlgorithmArgs(algoName, graph);
             const start = performance.now();
 
-            (algo as (... args: unknown[]) => unknown)(... args);
+            (algo as (...args: unknown[]) => unknown)(...args);
 
             const time = performance.now() - start;
             times.push(time);
@@ -251,6 +263,9 @@ function benchmarkAlgorithm(
 
 /**
  * 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
@@ -326,6 +341,10 @@ function getAlgorithmArgs(algoName: string, graph: Graph): unknown[] {
 
 /**
  * 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();
@@ -362,6 +381,8 @@ function createTestGraph(nodes: number, edges: number, category: string): 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;
@@ -387,6 +408,8 @@ function createConnectedGraph(graph: Graph, targetEdges: number): void {
 
 /**
  * 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;
@@ -418,6 +441,8 @@ function createSmallWorldGraph(graph: Graph, avgDegree: number): void {
 
 /**
  * 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;
@@ -433,7 +458,8 @@ function createCommunityGraph(graph: Graph, targetEdges: number): void {
 
         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
+                if (Math.random() < 0.8) {
+                    // High probability within community
                     graph.addEdge(i, j);
                     edgesAdded++;
                 }
@@ -455,9 +481,11 @@ function createCommunityGraph(graph: Graph, targetEdges: number): void {
 
 /**
  * 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});
+    const directedGraph = new Graph({ directed: true });
 
     // Copy nodes
     for (const node of undirectedGraph.nodes()) {
@@ -474,6 +502,8 @@ function createDirectedGraph(undirectedGraph: Graph): Graph {
 
 /**
  * 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();
@@ -486,7 +516,8 @@ function createBipartiteGraph(nodesPerPartition: number): Graph {
     // 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
+            if (Math.random() < 0.3) {
+                // Sparse bipartite graph
                 graph.addEdge(i, j);
             }
         }
@@ -497,14 +528,15 @@ function createBipartiteGraph(nodesPerPartition: number): 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);
+    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");
@@ -530,8 +562,8 @@ function displayDetailedResults(results: BenchmarkResult[]): void {
         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));
+            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`);
         }
 

package/src/clustering/hierarchical.ts

@@ -6,10 +6,12 @@
  * structure in graphs.
  */
 
-import type {Graph} from "../core/graph.js";
+import type { Graph } from "../core/graph.js";
 
 /**
  * Convert Graph to adjacency set representation for clustering
+ * @param graph - The input graph to convert
+ * @returns Map of node IDs to sets of neighbor node IDs
  */
 function graphToAdjacencySet(graph: Graph): Map<string, Set<string>> {
     const adjacency = new Map<string, Set<string>>();
@@ -62,11 +64,10 @@ export type LinkageMethod = "single" | "complete" | "average" | "ward";
 
 /**
  * Compute distance between two nodes based on graph structure
+ * @param graph - Adjacency map representation of the graph
+ * @param distances - Map to store computed distances between nodes
  */
-function computeGraphDistance<T>(
-    graph: Map<T, Set<T>>,
-    distances: Map<T, Map<T, number>>,
-): void {
+function computeGraphDistance<T>(graph: Map<T, Set<T>>, distances: Map<T, Map<T, number>>): void {
     // Use BFS to compute shortest path distances
     for (const start of graph.keys()) {
         const dist = new Map<T, number>();
@@ -97,6 +98,11 @@ function computeGraphDistance<T>(
 
 /**
  * Compute distance between two clusters based on linkage method
+ * @param cluster1 - First cluster node
+ * @param cluster2 - Second cluster node
+ * @param distances - Precomputed distance matrix between nodes
+ * @param linkage - Linkage method to use for computing cluster distance
+ * @returns The distance between the two clusters
  */
 function clusterDistance<T>(
     cluster1: ClusterNode<T>,
@@ -126,9 +132,9 @@ function clusterDistance<T>(
 
     switch (linkage) {
         case "single":
-            return Math.min(... allDistances);
+            return Math.min(...allDistances);
         case "complete":
-            return Math.max(... allDistances);
+            return Math.max(...allDistances);
         case "average":
             return allDistances.reduce((a, b) => a + b, 0) / allDistances.length;
         case "ward": {
@@ -139,12 +145,15 @@ function clusterDistance<T>(
             return avgDist * ((size1 * size2) / (size1 + size2));
         }
         default:
-            return Math.min(... allDistances);
+            return Math.min(...allDistances);
     }
 }
 
 /**
  * Internal implementation of agglomerative hierarchical clustering
+ * @param graph - Adjacency map representation of the graph
+ * @param linkage - Linkage method for cluster distance computation
+ * @returns Hierarchical clustering result with dendrogram and cluster assignments
  */
 function hierarchicalClusteringImpl<T>(
     graph: Map<T, Set<T>>,
@@ -155,7 +164,7 @@ function hierarchicalClusteringImpl<T>(
 
     if (n === 0) {
         return {
-            root: {id: "empty", members: new Set(), distance: 0, height: 0},
+            root: { id: "empty", members: new Set(), distance: 0, height: 0 },
             dendrogram: [],
             clusters: new Map(),
         };
@@ -173,7 +182,7 @@ function hierarchicalClusteringImpl<T>(
         height: 0,
     }));
 
-    const dendrogram: ClusterNode<T>[] = [... clusters];
+    const dendrogram: ClusterNode<T>[] = [...clusters];
     let clusterCount = n;
 
     // Distance matrix between clusters
@@ -220,9 +229,8 @@ function hierarchicalClusteringImpl<T>(
                     continue;
                 }
 
-                const dist = distMap.get(cluster2.id) ??
-                    clusterDistances.get(cluster2.id)?.get(cluster1.id) ??
-                    Infinity;
+                const dist =
+                    distMap.get(cluster2.id) ?? clusterDistances.get(cluster2.id)?.get(cluster1.id) ?? Infinity;
 
                 if (dist < minDist) {
                     minDist = dist;
@@ -239,7 +247,7 @@ function hierarchicalClusteringImpl<T>(
                 id: `forest-${String(clusterCount++)}`,
                 members: new Set(nodes),
                 distance: Infinity,
-                height: Math.max(... trees.map((t) => t.height)) + 1,
+                height: Math.max(...trees.map((t) => t.height)) + 1,
                 trees,
             };
             dendrogram.push(forestRoot);
@@ -251,7 +259,7 @@ function hierarchicalClusteringImpl<T>(
         // Create new cluster
         const newCluster: ClusterNode<T> = {
             id: `cluster-${String(clusterCount++)}`,
-            members: new Set([... mergeCluster1.members, ... mergeCluster2.members]),
+            members: new Set([...mergeCluster1.members, ...mergeCluster2.members]),
             left: mergeCluster1,
             right: mergeCluster2,
             distance: minDist,
@@ -301,7 +309,7 @@ function hierarchicalClusteringImpl<T>(
 
     if (!root) {
         return {
-            root: {id: "empty", members: new Set(), distance: 0, height: 0},
+            root: { id: "empty", members: new Set(), distance: 0, height: 0 },
             dendrogram: [],
             clusters: new Map(),
         };
@@ -320,11 +328,11 @@ function hierarchicalClusteringImpl<T>(
 
 /**
  * Cut dendrogram at specific height to get clusters
+ * @param root - Root node of the dendrogram
+ * @param height - Height at which to cut the dendrogram
+ * @returns Array of sets representing clusters at the specified height
  */
-export function cutDendrogram<T>(
-    root: ClusterNode<T>,
-    height: number,
-): Set<T>[] {
+export function cutDendrogram<T>(root: ClusterNode<T>, height: number): Set<T>[] {
     const clusters: Set<T>[] = [];
 
     function traverse(node: ClusterNode<T>): void {
@@ -354,11 +362,11 @@ export function cutDendrogram<T>(
 
 /**
  * Cut dendrogram to get exactly k clusters
+ * @param root - Root node of the dendrogram
+ * @param k - Target number of clusters
+ * @returns Array of sets representing exactly k clusters
  */
-export function cutDendrogramKClusters<T>(
-    root: ClusterNode<T>,
-    k: number,
-): Set<T>[] {
+export function cutDendrogramKClusters<T>(root: ClusterNode<T>, k: number): Set<T>[] {
     if (k <= 0) {
         return [];
     }
@@ -390,17 +398,17 @@ export function cutDendrogramKClusters<T>(
 /**
  * Compute modularity-based hierarchical clustering
  * Uses modularity gain to decide merges
+ * @param graph - The input graph to cluster
+ * @returns Hierarchical clustering result with dendrogram and cluster assignments
  */
-export function modularityHierarchicalClustering(
-    graph: Graph,
-): HierarchicalClusteringResult<string> {
+export function modularityHierarchicalClustering(graph: Graph): HierarchicalClusteringResult<string> {
     const adjacencySet = graphToAdjacencySet(graph);
     const nodes = Array.from(adjacencySet.keys());
     const n = nodes.length;
 
     if (n === 0) {
         return {
-            root: {id: "empty", members: new Set(), distance: 0, height: 0},
+            root: { id: "empty", members: new Set(), distance: 0, height: 0 },
             dendrogram: [],
             clusters: new Map(),
         };
@@ -426,7 +434,7 @@ export function modularityHierarchicalClustering(
         height: 0,
     }));
 
-    const dendrogram: ClusterNode<string>[] = [... clusters];
+    const dendrogram: ClusterNode<string>[] = [...clusters];
     let clusterCount = n;
 
     // Active clusters
@@ -466,8 +474,7 @@ export function modularityHierarchicalClustering(
                     }
                 }
 
-                const gain = (edgesBetween / totalEdges) -
-                    (degreeProduct / (4 * totalEdges * totalEdges));
+                const gain = edgesBetween / totalEdges - degreeProduct / (4 * totalEdges * totalEdges);
 
                 if (gain > maxGain) {
                     maxGain = gain;
@@ -484,7 +491,7 @@ export function modularityHierarchicalClustering(
         // Create new cluster
         const newCluster: ClusterNode<string> = {
             id: `cluster-${String(clusterCount++)}`,
-            members: new Set([... mergeCluster1.members, ... mergeCluster2.members]),
+            members: new Set([...mergeCluster1.members, ...mergeCluster2.members]),
             left: mergeCluster1,
             right: mergeCluster2,
             distance: -maxGain, // Use negative gain as distance
@@ -507,7 +514,7 @@ export function modularityHierarchicalClustering(
 
     if (!root) {
         return {
-            root: {id: "empty", members: new Set(), distance: 0, height: 0},
+            root: { id: "empty", members: new Set(), distance: 0, height: 0 },
             dendrogram: [],
             clusters: new Map(),
         };
@@ -527,7 +534,6 @@ export function modularityHierarchicalClustering(
 /**
  * Agglomerative hierarchical clustering
  * Builds clusters bottom-up by merging closest pairs
- *
  * @param graph - Undirected graph - accepts Graph class or Map<T, Set<T>>
  * @param linkage - Linkage method for cluster distance
  * @returns Hierarchical clustering result

package/src/clustering/index.ts

@@ -1,8 +1,8 @@
-export type {ClusterNode, HierarchicalClusteringResult, LinkageMethod} from "./hierarchical.js";
-export {hierarchicalClustering} from "./hierarchical.js";
-export type {KCoreResult} from "./k-core.js";
-export {getKCore, kCoreDecomposition} from "./k-core.js";
-export type {MCLOptions, MCLResult} from "./mcl.js";
-export {calculateMCLModularity, markovClustering} from "./mcl.js";
-export type {SpectralClusteringOptions, SpectralClusteringResult} from "./spectral.js";
-export {spectralClustering} from "./spectral.js";
+export type { ClusterNode, HierarchicalClusteringResult, LinkageMethod } from "./hierarchical.js";
+export { hierarchicalClustering } from "./hierarchical.js";
+export type { KCoreResult } from "./k-core.js";
+export { getKCore, kCoreDecomposition } from "./k-core.js";
+export type { MCLOptions, MCLResult } from "./mcl.js";
+export { calculateMCLModularity, markovClustering } from "./mcl.js";
+export type { SpectralClusteringOptions, SpectralClusteringResult } from "./spectral.js";
+export { spectralClustering } from "./spectral.js";

package/src/clustering/k-core.ts

@@ -6,10 +6,12 @@
  * understanding graph structure.
  */
 
-import type {Graph} from "../core/graph.js";
+import type { Graph } from "../core/graph.js";
 
 /**
  * Convert Graph to adjacency set representation
+ * @param graph - The input graph to convert
+ * @returns Map of node IDs to sets of neighbor node IDs
  */
 function graphToAdjacencySet(graph: Graph): Map<string, Set<string>> {
     const adjacency = new Map<string, Set<string>>();
@@ -49,12 +51,12 @@ export interface KCoreResult<T> {
 
 /**
  * Internal implementation of K-Core decomposition algorithm
+ * @param graph - Adjacency map representation of the graph
+ * @returns K-core decomposition result with cores, coreness values, and maximum core number
  */
-function kCoreDecompositionImpl<T>(
-    graph: Map<T, Set<T>>,
-): KCoreResult<T> {
+function kCoreDecompositionImpl<T>(graph: Map<T, Set<T>>): KCoreResult<T> {
     if (graph.size === 0) {
-        return {cores: new Map(), coreness: new Map(), maxCore: 0};
+        return { cores: new Map(), coreness: new Map(), maxCore: 0 };
     }
 
     const n = graph.size;
@@ -208,22 +210,18 @@ function kCoreDecompositionImpl<T>(
         maxCore = Math.max(maxCore, core);
     }
 
-    return {cores, coreness, maxCore};
+    return { cores, coreness, maxCore };
 }
 
 /**
  * Extract the k-core subgraph
  * Returns nodes that belong to k-core or higher
- *
  * @param graph - Undirected graph
  * @param k - Core number
  * @returns Set of nodes in k-core or higher
  */
-export function getKCore(
-    graph: Graph,
-    k: number,
-): Set<string> {
-    const {coreness} = kCoreDecomposition(graph);
+export function getKCore(graph: Graph, k: number): Set<string> {
+    const { coreness } = kCoreDecomposition(graph);
     const kCore = new Set<string>();
 
     for (const [node, core] of coreness) {
@@ -238,15 +236,11 @@ export function getKCore(
 /**
  * Get the induced subgraph for k-core
  * Returns the actual subgraph containing only k-core nodes
- *
  * @param graph - Original graph
  * @param k - Core number
  * @returns K-core subgraph
  */
-export function getKCoreSubgraph(
-    graph: Graph,
-    k: number,
-): Map<string, Set<string>> {
+export function getKCoreSubgraph(graph: Graph, k: number): Map<string, Set<string>> {
     const kCoreNodes = getKCore(graph, k);
     const adjacencySet = graphToAdjacencySet(graph);
     const subgraph = new Map<string, Set<string>>();
@@ -270,13 +264,10 @@ export function getKCoreSubgraph(
 /**
  * Degeneracy ordering of the graph
  * Orders nodes by their coreness values
- *
  * @param graph - Undirected graph
  * @returns Array of nodes ordered by degeneracy
  */
-export function degeneracyOrdering(
-    graph: Graph,
-): string[] {
+export function degeneracyOrdering(graph: Graph): string[] {
     const adjacencySet = graphToAdjacencySet(graph);
     const degree = new Map<string, number>();
     const remaining = new Map<string, Set<string>>();
@@ -290,7 +281,7 @@ export function degeneracyOrdering(
 
     // Build ordering
     while (ordering.length < adjacencySet.size) {
-    // Find minimum degree node
+        // Find minimum degree node
         let minDegree = Infinity;
         let minNode: string | undefined;
 
@@ -327,15 +318,11 @@ export function degeneracyOrdering(
 /**
  * Find k-truss subgraph (triangular k-cores)
  * Each edge must be part of at least k-2 triangles
- *
  * @param graph - Undirected graph
  * @param k - Truss number (k >= 2)
  * @returns Edges in k-truss
  */
-export function kTruss(
-    graph: Graph,
-    k: number,
-): Set<string> {
+export function kTruss(graph: Graph, k: number): Set<string> {
     if (k < 2) {
         throw new Error("k must be at least 2 for k-truss");
     }
@@ -349,8 +336,9 @@ export function kTruss(
     // Initialize edges
     for (const [u, neighbors] of adjacencySet) {
         for (const v of neighbors) {
-            if (u < v) { // Avoid duplicates
-                const edge = `${String(u)},${String(v)}`;
+            if (u < v) {
+                // Avoid duplicates
+                const edge = `${u},${v}`;
                 edges.add(edge);
                 edgeTriangles.set(edge, 0);
             }
@@ -367,9 +355,9 @@ export function kTruss(
                     for (const w of uNeighbors) {
                         if (v < w && vNeighbors.has(w)) {
                             // Triangle found: u-v-w
-                            const edge1 = `${String(u)},${String(v)}`;
-                            const edge2 = `${String(u)},${String(w)}`;
-                            const edge3 = `${String(v)},${String(w)}`;
+                            const edge1 = `${u},${v}`;
+                            const edge2 = `${u},${w}`;
+                            const edge3 = `${v},${w}`;
 
                             const edge1Count = edgeTriangles.get(edge1);
                             const edge2Count = edgeTriangles.get(edge2);
@@ -428,8 +416,8 @@ export function kTruss(
             if (uNeighbors && vNeighbors) {
                 for (const w of uNeighbors) {
                     if (vNeighbors.has(w)) {
-                        const edge1 = u < w ? `${String(u)},${String(w)}` : `${String(w)},${String(u)}`;
-                        const edge2 = v < w ? `${String(v)},${String(w)}` : `${String(w)},${String(v)}`;
+                        const edge1 = u < w ? `${u},${w}` : `${w},${u}`;
+                        const edge2 = v < w ? `${v},${w}` : `${w},${v}`;
 
                         if (kTrussEdges.has(edge1)) {
                             const edge1Count = edgeTriangles.get(edge1);
@@ -455,10 +443,10 @@ export function kTruss(
 
 /**
  * Convert directed graph to undirected for k-core analysis
+ * @param directedGraph - Directed graph represented as adjacency map with edge weights
+ * @returns Undirected graph represented as adjacency map with neighbor sets
  */
-export function toUndirected<T>(
-    directedGraph: Map<T, Map<T, number>>,
-): Map<T, Set<T>> {
+export function toUndirected<T>(directedGraph: Map<T, Map<T, number>>): Map<T, Set<T>> {
     const undirected = new Map<T, Set<T>>();
 
     // Initialize all nodes
@@ -491,18 +479,14 @@ export function toUndirected<T>(
 /**
  * K-Core decomposition algorithm
  * Finds all k-cores in the graph and assigns coreness values to nodes
- *
  * @param graph - Undirected graph - accepts Graph class or Map<T, Set<T>>
  * @returns K-core decomposition results
  *
  * Time Complexity: O(V + E)
  * Space Complexity: O(V)
  */
-export function kCoreDecomposition(
-    graph: Graph,
-): KCoreResult<string> {
+export function kCoreDecomposition(graph: Graph): KCoreResult<string> {
     // Convert Graph to adjacency set representation
     const adjacencySet = graphToAdjacencySet(graph);
     return kCoreDecompositionImpl(adjacencySet);
 }
-