@graphty/algorithms 1.3.1 → 1.5.0

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

@@ -1,5 +1,5 @@
-import type {Graph} from "../../core/graph.js";
-import type {CommunityResult, NodeId} from "../../types/index.js";
+import type { Graph } from "../../core/graph.js";
+import type { CommunityResult, NodeId } from "../../types/index.js";
 
 /**
  * Optimized Louvain community detection algorithm with early pruning and threshold cycling
@@ -50,6 +50,9 @@ interface PruningStats {
     stableNodesPruned: number;
 }
 
+/**
+ * Optimized Louvain implementation with early pruning and threshold cycling
+ */
 export class OptimizedLouvain {
     private graph: Graph;
     private communities: Map<NodeId, number>;
@@ -59,6 +62,10 @@ export class OptimizedLouvain {
     private totalWeight: number;
     private pruningStats: PruningStats;
 
+    /**
+     * Create an optimized Louvain detector for the given graph
+     * @param graph - The input graph to detect communities in
+     */
     constructor(graph: Graph) {
         this.graph = graph;
         this.communities = new Map();
@@ -75,6 +82,8 @@ export class OptimizedLouvain {
 
     /**
      * Run optimized Louvain algorithm
+     * @param options - Algorithm configuration options
+     * @returns Community detection result with communities, modularity, and iterations
      */
     public detectCommunities(options: OptimizedLouvainOptions = {}): CommunityResult {
         const {
@@ -95,14 +104,12 @@ export class OptimizedLouvain {
 
         while (iteration < maxIterations && improved) {
             // Get nodes in optimal processing order
-            const orderedNodes = importanceOrdering ?
-                this.getNodesInImportanceOrder() :
-                Array.from(this.graph.nodes()).map((n) => n.id);
+            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;
+            const threshold = thresholdCycling ? this.getAdaptiveThreshold(iteration, pruningThreshold) : 0;
 
             // Perform local optimization
             improved = this.performLocalMoving(orderedNodes, {
@@ -193,6 +200,7 @@ export class OptimizedLouvain {
 
     /**
      * Get nodes ordered by importance (degree * log(weight))
+     * @returns Array of node IDs sorted by descending importance
      */
     private getNodesInImportanceOrder(): NodeId[] {
         const nodeImportance = new Map<NodeId, number>();
@@ -213,6 +221,12 @@ export class OptimizedLouvain {
 
     /**
      * 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[],
@@ -222,7 +236,7 @@ export class OptimizedLouvain {
             resolution: number;
         },
     ): boolean {
-        const {pruneLeaves, threshold, resolution} = options;
+        const { pruneLeaves, threshold, resolution } = options;
         let improvement = false;
         let hasChanged = true;
 
@@ -284,6 +298,8 @@ export class OptimizedLouvain {
 
     /**
      * 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;
@@ -292,6 +308,9 @@ export class OptimizedLouvain {
 
     /**
      * 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
@@ -301,12 +320,12 @@ export class OptimizedLouvain {
 
     /**
      * 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
      */
-    private calculateModularityGain(
-        nodeId: NodeId,
-        targetCommunity: number,
-        resolution: number,
-    ): number {
+    private calculateModularityGain(nodeId: NodeId, targetCommunity: number, resolution: number): number {
         const nodeWeight = this.nodeWeights.get(nodeId) ?? 0;
 
         // Sum of weights from node to target community
@@ -333,13 +352,16 @@ export class OptimizedLouvain {
         const targetWeight = this.communityWeights.get(targetCommunity) ?? 0;
 
         // Modularity gain formula
-        const gain = (weightToTarget - ((resolution * nodeWeight * targetWeight) / (2 * this.totalWeight))) / this.totalWeight;
+        const gain =
+            (weightToTarget - (resolution * nodeWeight * targetWeight) / (2 * this.totalWeight)) / this.totalWeight;
 
         return gain;
     }
 
     /**
      * 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;
@@ -349,6 +371,8 @@ export class OptimizedLouvain {
 
     /**
      * 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;
@@ -358,6 +382,8 @@ export class OptimizedLouvain {
 
     /**
      * 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>();
@@ -384,6 +410,8 @@ export class OptimizedLouvain {
 
     /**
      * 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) {
@@ -427,19 +455,20 @@ export class OptimizedLouvain {
 
     /**
      * Get pruning statistics
+     * @returns Statistics about nodes pruned during optimization
      */
     public getPruningStats(): PruningStats {
-        return {... this.pruningStats};
+        return { ...this.pruningStats };
     }
 }
 
 /**
  * Optimized Louvain algorithm with automatic optimization selection
+ * @param graph - The input graph to detect communities in
+ * @param options - Algorithm configuration options
+ * @returns Community detection result with communities, modularity, and iterations
  */
-export function louvainOptimized(
-    graph: Graph,
-    options: OptimizedLouvainOptions = {},
-): CommunityResult {
+export function louvainOptimized(graph: Graph, options: OptimizedLouvainOptions = {}): CommunityResult {
     const optimizer = new OptimizedLouvain(graph);
     return optimizer.detectCommunities(options);
 }

package/src/algorithms/community/louvain.ts

@@ -1,12 +1,7 @@
-import {Graph} from "../../core/graph.js";
-import type {CommunityResult, LouvainOptions, NodeId} from "../../types/index.js";
-import {louvainOptimized} from "./louvain-optimized.js";
-import {
-    calculateModularity,
-    getNeighborCommunities,
-    getNodeDegree,
-    getTotalEdgeWeight,
-} from "./modularity-utils.js";
+import { Graph } from "../../core/graph.js";
+import type { CommunityResult, LouvainOptions, NodeId } from "../../types/index.js";
+import { louvainOptimized } from "./louvain-optimized.js";
+import { calculateModularity, getNeighborCommunities, getNodeDegree, getTotalEdgeWeight } from "./modularity-utils.js";
 
 /**
  * Louvain community detection algorithm
@@ -16,17 +11,13 @@ import {
  *
  * References:
  * - Blondel, V. D., Guillaume, J. L., Lambiotte, R., & Lefebvre, E. (2008).
- *   Fast unfolding of communities in large networks.
- *   Journal of statistical mechanics: theory and experiment, 2008(10), P10008.
- *
+ * Fast unfolding of communities in large networks.
+ * Journal of statistical mechanics: theory and experiment, 2008(10), P10008.
  * @param graph - The input graph
  * @param options - Algorithm options
  * @returns Community detection result with communities, modularity, and iterations
  */
-export function louvain(
-    graph: Graph,
-    options: LouvainOptions = {},
-): CommunityResult {
+export function louvain(graph: Graph, options: LouvainOptions = {}): CommunityResult {
     const resolution = options.resolution ?? 1.0;
     const maxIterations = options.maxIterations ?? 100;
     const tolerance = options.tolerance ?? 1e-6;
@@ -62,7 +53,7 @@ export function louvain(
             const newModularity = calculateModularity(graph, communities, resolution);
 
             // Check for convergence
-            if ((newModularity - modularity) < tolerance) {
+            if (newModularity - modularity < tolerance) {
                 break;
             }
 
@@ -80,6 +71,8 @@ export function louvain(
 
 /**
  * Initialize communities: each node in its own community
+ * @param graph - The input graph
+ * @returns Map of node IDs to their initial community IDs
  */
 function initializeCommunities(graph: Graph): Map<NodeId, number> {
     const communities = new Map<NodeId, number>();
@@ -96,12 +89,12 @@ function initializeCommunities(graph: Graph): Map<NodeId, number> {
  * Phase 1 of Louvain algorithm: Local optimization
  * For each node, try moving to neighboring communities and keep the move
  * that provides the best modularity gain.
+ * @param graph - The input graph
+ * @param communities - Map of node IDs to community IDs
+ * @param resolution - Resolution parameter for modularity calculation
+ * @returns True if any improvement was made, false otherwise
  */
-function louvainPhase1(
-    graph: Graph,
-    communities: Map<NodeId, number>,
-    resolution: number,
-): boolean {
+function louvainPhase1(graph: Graph, communities: Map<NodeId, number>, resolution: number): boolean {
     let globalImprovement = false;
     let localImprovement = true;
 
@@ -118,7 +111,11 @@ function louvainPhase1(
 
             // Calculate current modularity contribution
             const currentModularity = nodeModularityContribution(
-                graph, nodeId, currentCommunity, communities, resolution,
+                graph,
+                nodeId,
+                currentCommunity,
+                communities,
+                resolution,
             );
 
             let bestCommunity = currentCommunity;
@@ -133,7 +130,11 @@ function louvainPhase1(
                 }
 
                 const newModularity = nodeModularityContribution(
-                    graph, nodeId, neighborCommunity, communities, resolution,
+                    graph,
+                    nodeId,
+                    neighborCommunity,
+                    communities,
+                    resolution,
                 );
 
                 if (newModularity > bestModularity) {
@@ -156,6 +157,12 @@ function louvainPhase1(
 
 /**
  * Calculate modularity contribution of a node to a specific community
+ * @param graph - The input graph
+ * @param nodeId - The node ID to evaluate
+ * @param community - The community to measure contribution to
+ * @param communities - Map of all node IDs to community IDs
+ * @param resolution - Resolution parameter for modularity calculation
+ * @returns The modularity contribution of the node to the specified community
  */
 function nodeModularityContribution(
     graph: Graph,
@@ -192,13 +199,16 @@ function nodeModularityContribution(
     }
 
     // Modularity formula: Q = (1/2m) * Σ[A_ij - (k_i * k_j)/(2m)] * δ(c_i, c_j)
-    const modularityIncrease = (internalLinks - ((resolution * nodeDegree * communityDegree) / (2 * totalEdgeWeight))) / totalEdgeWeight;
+    const modularityIncrease =
+        (internalLinks - (resolution * nodeDegree * communityDegree) / (2 * totalEdgeWeight)) / totalEdgeWeight;
 
     return modularityIncrease;
 }
 
 /**
  * Extract final community structure
+ * @param communities - Map of node IDs to community IDs
+ * @returns Array of communities (each is an array of node IDs)
  */
 function extractCommunities(communities: Map<NodeId, number>): NodeId[][] {
     const communityMap = new Map<number, NodeId[]>();

package/src/algorithms/community/modularity-utils.ts

@@ -3,15 +3,14 @@
  *
  * Used by: Louvain, Leiden, Girvan-Newman
  */
-import type {Graph} from "../../core/graph.js";
-import type {NodeId} from "../../types/index.js";
+import type { Graph } from "../../core/graph.js";
+import type { NodeId } from "../../types/index.js";
 
 /**
  * Calculate total edge weight in the graph
  *
  * For undirected graphs, each edge is counted once.
  * For directed graphs, each directed edge is counted once.
- *
  * @param graph - The input graph
  * @returns Total sum of edge weights (default weight is 1)
  */
@@ -29,7 +28,6 @@ export function getTotalEdgeWeight(graph: Graph): number {
  * Get the total degree (sum of edge weights) for a node
  *
  * Computes the weighted degree by summing all edge weights incident to the node.
- *
  * @param graph - The input graph
  * @param nodeId - The node ID to compute degree for
  * @returns The weighted degree of the node
@@ -49,17 +47,12 @@ export function getNodeDegree(graph: Graph, nodeId: NodeId): number {
  * Get communities of neighboring nodes
  *
  * Returns the set of community IDs that neighbors of the given node belong to.
- *
  * @param graph - The input graph
  * @param nodeId - The node to get neighbor communities for
  * @param communities - Map from node IDs to community IDs
  * @returns Set of community IDs that neighbors belong to
  */
-export function getNeighborCommunities(
-    graph: Graph,
-    nodeId: NodeId,
-    communities: Map<NodeId, number>,
-): Set<number> {
+export function getNeighborCommunities(graph: Graph, nodeId: NodeId, communities: Map<NodeId, number>): Set<number> {
     const neighborCommunities = new Set<number>();
 
     for (const neighbor of graph.neighbors(nodeId)) {
@@ -85,17 +78,12 @@ export function getNeighborCommunities(
  * - k_i, k_j = degrees of nodes i and j
  * - γ = resolution parameter (higher values favor smaller communities)
  * - δ = Kronecker delta (1 if same community, 0 otherwise)
- *
  * @param graph - The input graph
  * @param communities - Map from node IDs to community IDs
  * @param resolution - Resolution parameter (default: 1.0)
  * @returns Modularity score (range typically -0.5 to 1.0)
  */
-export function calculateModularity(
-    graph: Graph,
-    communities: Map<NodeId, number>,
-    resolution = 1.0,
-): number {
+export function calculateModularity(graph: Graph, communities: Map<NodeId, number>, resolution = 1.0): number {
     const totalEdgeWeight = getTotalEdgeWeight(graph);
     if (totalEdgeWeight === 0) {
         return 0;
@@ -137,7 +125,7 @@ export function calculateModularity(
                 const degreeI = getNodeDegree(graph, nodeI.id);
                 const degreeJ = getNodeDegree(graph, nodeJ.id);
 
-                modularity += edgeWeight - ((resolution * degreeI * degreeJ) / (2 * totalEdgeWeight));
+                modularity += edgeWeight - (resolution * degreeI * degreeJ) / (2 * totalEdgeWeight);
             }
         }
     }

package/src/algorithms/components/connected.ts

@@ -1,6 +1,6 @@
-import type {Graph} from "../../core/graph.js";
-import {UnionFind} from "../../data-structures/union-find.js";
-import type {NodeId} from "../../types/index.js";
+import type { Graph } from "../../core/graph.js";
+import { UnionFind } from "../../data-structures/union-find.js";
+import type { NodeId } from "../../types/index.js";
 
 /**
  * Connected components algorithms
@@ -11,10 +11,14 @@ import type {NodeId} from "../../types/index.js";
 
 /**
  * Find connected components in an undirected graph using Union-Find
+ * @param graph - The input graph (must be undirected)
+ * @returns Array of connected components, each containing an array of node IDs
  */
 export function connectedComponents(graph: Graph): NodeId[][] {
     if (graph.isDirected) {
-        throw new Error("Connected components algorithm requires an undirected graph. Use stronglyConnectedComponents for directed graphs.");
+        throw new Error(
+            "Connected components algorithm requires an undirected graph. Use stronglyConnectedComponents for directed graphs.",
+        );
     }
 
     const nodes = Array.from(graph.nodes()).map((node) => node.id);
@@ -35,6 +39,8 @@ export function connectedComponents(graph: Graph): NodeId[][] {
 
 /**
  * Find connected components using DFS (alternative implementation)
+ * @param graph - The input graph (must be undirected)
+ * @returns Array of connected components, each containing an array of node IDs
  */
 export function connectedComponentsDFS(graph: Graph): NodeId[][] {
     if (graph.isDirected) {
@@ -57,13 +63,12 @@ export function connectedComponentsDFS(graph: Graph): NodeId[][] {
 
 /**
  * DFS helper for connected components
+ * @param graph - The input graph
+ * @param nodeId - The starting node ID
+ * @param visited - Set of already visited node IDs
+ * @param component - Array to accumulate component members
  */
-function dfsComponent(
-    graph: Graph,
-    nodeId: NodeId,
-    visited: Set<NodeId>,
-    component: NodeId[],
-): void {
+function dfsComponent(graph: Graph, nodeId: NodeId, visited: Set<NodeId>, component: NodeId[]): void {
     visited.add(nodeId);
     component.push(nodeId);
 
@@ -76,6 +81,8 @@ function dfsComponent(
 
 /**
  * Find the number of connected components
+ * @param graph - The input graph (must be undirected)
+ * @returns The number of connected components in the graph
  */
 export function numberOfConnectedComponents(graph: Graph): number {
     return connectedComponents(graph).length;
@@ -83,6 +90,8 @@ export function numberOfConnectedComponents(graph: Graph): number {
 
 /**
  * Check if the graph is connected (has exactly one connected component)
+ * @param graph - The input graph (must be undirected)
+ * @returns True if the graph is connected, false otherwise
  */
 export function isConnected(graph: Graph): boolean {
     return numberOfConnectedComponents(graph) <= 1;
@@ -90,6 +99,8 @@ export function isConnected(graph: Graph): boolean {
 
 /**
  * Find the largest connected component
+ * @param graph - The input graph (must be undirected)
+ * @returns Array of node IDs in the largest connected component
  */
 export function largestConnectedComponent(graph: Graph): NodeId[] {
     const components = connectedComponents(graph);
@@ -98,13 +109,14 @@ export function largestConnectedComponent(graph: Graph): NodeId[] {
         return [];
     }
 
-    return components.reduce((largest, current) =>
-        current.length > largest.length ? current : largest,
-    );
+    return components.reduce((largest, current) => (current.length > largest.length ? current : largest));
 }
 
 /**
  * Get the connected component containing a specific node
+ * @param graph - The input graph (must be undirected)
+ * @param nodeId - The node ID to find the component for
+ * @returns Array of node IDs in the same component as the specified node
  */
 export function getConnectedComponent(graph: Graph, nodeId: NodeId): NodeId[] {
     if (!graph.hasNode(nodeId)) {
@@ -125,6 +137,8 @@ export function getConnectedComponent(graph: Graph, nodeId: NodeId): NodeId[] {
 
 /**
  * Find strongly connected components using Tarjan's algorithm
+ * @param graph - The input graph (must be directed)
+ * @returns Array of strongly connected components, each containing an array of node IDs
  */
 export function stronglyConnectedComponents(graph: Graph): NodeId[][] {
     if (!graph.isDirected) {
@@ -198,6 +212,8 @@ export function stronglyConnectedComponents(graph: Graph): NodeId[][] {
 
 /**
  * Check if a directed graph is strongly connected
+ * @param graph - The input graph (must be directed)
+ * @returns True if the graph is strongly connected, false otherwise
  */
 export function isStronglyConnected(graph: Graph): boolean {
     if (!graph.isDirected) {
@@ -211,10 +227,14 @@ export function isStronglyConnected(graph: Graph): boolean {
 /**
  * Find weakly connected components in a directed graph
  * (treat the graph as undirected for connectivity)
+ * @param graph - The input graph (must be directed)
+ * @returns Array of weakly connected components, each containing an array of node IDs
  */
 export function weaklyConnectedComponents(graph: Graph): NodeId[][] {
     if (!graph.isDirected) {
-        throw new Error("Weakly connected components are for directed graphs. Use connectedComponents for undirected graphs.");
+        throw new Error(
+            "Weakly connected components are for directed graphs. Use connectedComponents for undirected graphs.",
+        );
     }
 
     const nodes = Array.from(graph.nodes()).map((node) => node.id);
@@ -235,6 +255,8 @@ export function weaklyConnectedComponents(graph: Graph): NodeId[][] {
 
 /**
  * Check if a directed graph is weakly connected
+ * @param graph - The input graph (must be directed)
+ * @returns True if the graph is weakly connected, false otherwise
  */
 export function isWeaklyConnected(graph: Graph): boolean {
     if (!graph.isDirected) {
@@ -246,6 +268,8 @@ export function isWeaklyConnected(graph: Graph): boolean {
 
 /**
  * Find condensation graph (quotient graph of strongly connected components)
+ * @param graph - The input graph (must be directed)
+ * @returns Object containing the condensed graph, component map, and component arrays
  */
 export function condensationGraph(graph: Graph): {
     condensedGraph: Graph;
@@ -258,7 +282,7 @@ export function condensationGraph(graph: Graph): {
 
     const components = stronglyConnectedComponents(graph);
     const componentMap = new Map<NodeId, number>();
-    const condensedGraph = new (graph.constructor as new (config: {directed: boolean}) => Graph)({directed: true});
+    const condensedGraph = new (graph.constructor as new (config: { directed: boolean }) => Graph)({ directed: true });
 
     // Map each node to its component index
     for (let i = 0; i < components.length; i++) {
@@ -279,8 +303,7 @@ export function condensationGraph(graph: Graph): {
         const sourceComponent = componentMap.get(edge.source);
         const targetComponent = componentMap.get(edge.target);
 
-        if (sourceComponent !== undefined && targetComponent !== undefined &&
-            sourceComponent !== targetComponent) {
+        if (sourceComponent !== undefined && targetComponent !== undefined && sourceComponent !== targetComponent) {
             const edgeKey = `${String(sourceComponent)}-${String(targetComponent)}`;
 
             if (!addedEdges.has(edgeKey)) {

package/src/algorithms/matching/bipartite.ts

@@ -1,6 +1,6 @@
-import type {Graph} from "../../core/graph.js";
-import type {NodeId} from "../../types/index.js";
-import {bfsColoringWithPartitions} from "../traversal/bfs-variants.js";
+import type { Graph } from "../../core/graph.js";
+import type { NodeId } from "../../types/index.js";
+import { bfsColoringWithPartitions } from "../traversal/bfs-variants.js";
 
 /**
  * Maximum Bipartite Matching implementation using Hopcroft-Karp algorithm
@@ -25,13 +25,17 @@ export interface BipartiteMatchingOptions {
 /**
  * Find maximum matching in a bipartite graph using augmenting path algorithm
  * (simplified implementation that's more reliable than Hopcroft-Karp for this context)
+ * @param graph - The bipartite graph to find maximum matching for
+ * @param options - Optional configuration including left and right node partitions
+ * @returns The maximum matching as a map from left nodes to right nodes and the matching size
+ * @throws Error if the graph is not bipartite
  */
 export function maximumBipartiteMatching(
     graph: Graph,
     options: BipartiteMatchingOptions = {},
 ): BipartiteMatchingResult {
     // If partitions not provided, try to infer them
-    let {leftNodes, rightNodes} = options;
+    let { leftNodes, rightNodes } = options;
 
     if (!leftNodes || !rightNodes) {
         const partition = bipartitePartition(graph);
@@ -87,8 +91,10 @@ export function maximumBipartiteMatching(
 
 /**
  * Check if graph is bipartite and return the partition
+ * @param graph - The graph to check for bipartiteness
+ * @returns An object with left and right node sets if bipartite, or null if not bipartite
  */
-export function bipartitePartition(graph: Graph): {left: Set<NodeId>, right: Set<NodeId>} | null {
+export function bipartitePartition(graph: Graph): { left: Set<NodeId>; right: Set<NodeId> } | null {
     const result = bfsColoringWithPartitions(graph);
 
     if (!result.isBipartite || !result.partitions) {
@@ -104,12 +110,13 @@ export function bipartitePartition(graph: Graph): {left: Set<NodeId>, right: Set
 /**
  * Simple greedy bipartite matching algorithm
  * Useful for comparison or when Hopcroft-Karp is overkill
+ * @param graph - The bipartite graph to find matching for
+ * @param options - Optional configuration including left and right node partitions
+ * @returns The matching as a map from left nodes to right nodes and the matching size
+ * @throws Error if the graph is not bipartite
  */
-export function greedyBipartiteMatching(
-    graph: Graph,
-    options: BipartiteMatchingOptions = {},
-): BipartiteMatchingResult {
-    let {leftNodes, rightNodes} = options;
+export function greedyBipartiteMatching(graph: Graph, options: BipartiteMatchingOptions = {}): BipartiteMatchingResult {
+    let { leftNodes, rightNodes } = options;
 
     if (!leftNodes || !rightNodes) {
         const partition = bipartitePartition(graph);

package/src/algorithms/matching/index.ts

@@ -2,7 +2,7 @@
  * Graph matching algorithms
  */
 
-export type {BipartiteMatchingOptions, BipartiteMatchingResult} from "./bipartite.js";
-export {bipartitePartition, greedyBipartiteMatching, maximumBipartiteMatching} from "./bipartite.js";
-export type {IsomorphismOptions, IsomorphismResult} from "./isomorphism.js";
-export {findAllIsomorphisms, isGraphIsomorphic} from "./isomorphism.js";
+export type { BipartiteMatchingOptions, BipartiteMatchingResult } from "./bipartite.js";
+export { bipartitePartition, greedyBipartiteMatching, maximumBipartiteMatching } from "./bipartite.js";
+export type { IsomorphismOptions, IsomorphismResult } from "./isomorphism.js";
+export { findAllIsomorphisms, isGraphIsomorphic } from "./isomorphism.js";