@graphty/algorithms 2.1.1 → 2.2.0

package/src/algorithms/components/connected.ts

@@ -1,5 +1,9 @@
 import type { Graph } from "../../core/graph.js";
-import { UnionFind } from "../../data-structures/union-find.js";
+import { weaklyConnectedComponents as indexedWeaklyConnectedComponents } from "../../indexed/components.js";
+import { depthFirstSearch } from "../../indexed/dfs.js";
+import { labelsToGroups } from "../../indexed/facade.js";
+import { tarjan } from "../../indexed/scc.js";
+import { legacyArcOrder, toTopologySnapshot } from "../../indexed/to-snapshot.js";
 import type { NodeId } from "../../types/index.js";
 
 /**
@@ -21,20 +25,19 @@ export function connectedComponents(graph: Graph): NodeId[][] {
         );
     }
 
-    const nodes = Array.from(graph.nodes()).map((node) => node.id);
-
-    if (nodes.length === 0) {
-        return [];
-    }
-
-    const unionFind = new UnionFind(nodes);
-
-    // Union connected nodes
-    for (const edge of Array.from(graph.edges())) {
-        unionFind.union(edge.source, edge.target);
-    }
+    return componentGroups(graph);
+}
 
-    return unionFind.getAllComponents();
+/**
+ * The weakly connected components as legacy lists them: one group per component in the order of its
+ * first node, members in node order.
+ * @param graph - The input graph
+ * @returns The components
+ */
+function componentGroups(graph: Graph): NodeId[][] {
+    const s = toTopologySnapshot(graph);
+    const { labels, count } = indexedWeaklyConnectedComponents(s);
+    return labelsToGroups(s.ids, labels, count);
 }
 
 /**
@@ -127,12 +130,10 @@ export function getConnectedComponent(graph: Graph, nodeId: NodeId): NodeId[] {
         throw new Error("Connected components algorithm requires an undirected graph");
     }
 
-    const visited = new Set<NodeId>();
-    const component: NodeId[] = [];
-
-    dfsComponent(graph, nodeId, visited, component);
-
-    return component;
+    // The members in depth-first discovery order, neighbours in insertion order.
+    const s = toTopologySnapshot(graph);
+    const { order } = depthFirstSearch(s, s.ids.indexOf(nodeId), { arcOrder: legacyArcOrder(graph, s) });
+    return Array.from(order, (i) => s.ids.idOf(i));
 }
 
 /**
@@ -145,68 +146,13 @@ export function stronglyConnectedComponents(graph: Graph): NodeId[][] {
         throw new Error("Strongly connected components require a directed graph");
     }
 
-    const nodes = Array.from(graph.nodes()).map((node) => node.id);
-    const components: NodeId[][] = [];
-    const indices = new Map<NodeId, number>();
-    const lowLinks = new Map<NodeId, number>();
-    const onStack = new Set<NodeId>();
-    const stack: NodeId[] = [];
-    let index = 0;
-
-    function tarjanSCC(nodeId: NodeId): void {
-        // Set the depth index for this node
-        indices.set(nodeId, index);
-        lowLinks.set(nodeId, index);
-        index++;
-        stack.push(nodeId);
-        onStack.add(nodeId);
-
-        // Consider successors
-        for (const neighbor of Array.from(graph.neighbors(nodeId))) {
-            if (!indices.has(neighbor)) {
-                // Successor has not yet been visited; recurse on it
-                tarjanSCC(neighbor);
-                const nodeLL = lowLinks.get(nodeId) ?? 0;
-                const neighborLL = lowLinks.get(neighbor) ?? 0;
-                lowLinks.set(nodeId, Math.min(nodeLL, neighborLL));
-            } else if (onStack.has(neighbor)) {
-                // Successor is in stack and hence in the current SCC
-                const nodeLL = lowLinks.get(nodeId) ?? 0;
-                const neighborIndex = indices.get(neighbor) ?? 0;
-                lowLinks.set(nodeId, Math.min(nodeLL, neighborIndex));
-            }
-        }
-
-        // If nodeId is a root node, pop the stack and create an SCC
-        const nodeIndex = indices.get(nodeId) ?? 0;
-        const nodeLowLink = lowLinks.get(nodeId) ?? 0;
-
-        if (nodeLowLink === nodeIndex) {
-            const component: NodeId[] = [];
-            let w: NodeId;
-
-            do {
-                const popped = stack.pop();
-                if (popped === undefined) {
-                    break;
-                }
-
-                w = popped;
-
-                onStack.delete(w);
-                component.push(w);
-            } while (w !== nodeId);
-
-            components.push(component);
-        }
-    }
-
-    for (const nodeId of nodes) {
-        if (!indices.has(nodeId)) {
-            tarjanSCC(nodeId);
-        }
+    // Tarjan's pop order lists each component as one run, in component order.
+    const s = toTopologySnapshot(graph);
+    const { labels, count, popped } = tarjan(s, { arcOrder: legacyArcOrder(graph, s) });
+    const components: NodeId[][] = Array.from({ length: count }, () => []);
+    for (const i of popped) {
+        components[labels[i]].push(s.ids.idOf(i));
     }
-
     return components;
 }
 
@@ -237,20 +183,7 @@ export function weaklyConnectedComponents(graph: Graph): NodeId[][] {
         );
     }
 
-    const nodes = Array.from(graph.nodes()).map((node) => node.id);
-
-    if (nodes.length === 0) {
-        return [];
-    }
-
-    const unionFind = new UnionFind(nodes);
-
-    // Union nodes connected by edges (ignore direction)
-    for (const edge of Array.from(graph.edges())) {
-        unionFind.union(edge.source, edge.target);
-    }
-
-    return unionFind.getAllComponents();
+    return componentGroups(graph);
 }
 
 /**

package/src/algorithms/mst/kruskal.ts

@@ -1,5 +1,8 @@
 import { Graph } from "../../core/graph.js";
 import { UnionFind } from "../../data-structures/union-find.js";
+import { exactArcWeights } from "../../indexed/facade.js";
+import { kruskalMST as indexedKruskalMST } from "../../indexed/mst.js";
+import { toSnapshotOrNull } from "../../indexed/to-snapshot.js";
 import type { Edge } from "../../types/index.js";
 
 export interface MSTResult {
@@ -20,14 +23,72 @@ export function kruskalMST(graph: Graph): MSTResult {
         throw new Error("Kruskal's algorithm requires an undirected graph");
     }
 
+    // A NaN weight makes the legacy sort order depend on the sort's own internals, and legacy drops
+    // an edge whose key string another edge already spells (1-2 and "1"-"2"): keep that walk for both.
+    const s = legacyDropsAnEdge(graph) ? null : toSnapshotOrNull(graph);
+    if (s === null) {
+        return kruskalMSTLegacy(graph);
+    }
+
+    const { edges: accepted, totalWeight } = indexedKruskalMST(s, { weights: exactArcWeights(s) });
+    const { src, dst } = s.edgeList();
+    const edges: Edge[] = [];
+    for (const e of accepted) {
+        // The graph's own edge object, as legacy returned it.
+        const edge = graph.getEdge(s.ids.idOf(src[e]), s.ids.idOf(dst[e]));
+        if (edge !== undefined) {
+            edges.push(edge);
+        }
+    }
+
+    if (edges.length !== graph.nodeCount - 1) {
+        throw new Error("Graph is not connected");
+    }
+
+    return { edges, totalWeight };
+}
+
+/**
+ * The key legacy Kruskal dedups edges by: both ids as strings, lesser first.
+ * @param edge - The edge
+ * @returns Its key
+ */
+function legacyEdgeKey(edge: Edge): string {
+    return edge.source < edge.target
+        ? `${String(edge.source)}-${String(edge.target)}`
+        : `${String(edge.target)}-${String(edge.source)}`;
+}
+
+/**
+ * Whether legacy Kruskal would ignore one of the graph's edges.
+ * @param graph - The undirected graph
+ * @returns True if two of its edges share a legacy key, so legacy Kruskal ignores one of them
+ */
+function legacyDropsAnEdge(graph: Graph): boolean {
+    const keys = new Set<string>();
+    for (const edge of graph.edges()) {
+        const key = legacyEdgeKey(edge);
+        if (keys.has(key)) {
+            return true;
+        }
+        keys.add(key);
+    }
+    return false;
+}
+
+/**
+ * The legacy Kruskal behind {@link kruskalMST}, for a graph with a NaN weight or two edges whose
+ * keys collide.
+ * @param graph - The undirected graph to compute the MST for
+ * @returns The minimum spanning tree as a set of edges and the total weight
+ * @throws Error if the graph is not connected
+ */
+function kruskalMSTLegacy(graph: Graph): MSTResult {
     const edges: Edge[] = [];
     const visitedEdges = new Set<string>();
 
     for (const edge of Array.from(graph.edges())) {
-        const edgeKey =
-            edge.source < edge.target
-                ? `${String(edge.source)}-${String(edge.target)}`
-                : `${String(edge.target)}-${String(edge.source)}`;
+        const edgeKey = legacyEdgeKey(edge);
 
         if (!visitedEdges.has(edgeKey)) {
             visitedEdges.add(edgeKey);

package/src/algorithms/shortest-path/bellman-ford.ts

@@ -1,4 +1,7 @@
 import type { Graph } from "../../core/graph.js";
+import { bellmanFord as indexedBellmanFord } from "../../indexed/bellman-ford.js";
+import { exactArcWeights } from "../../indexed/facade.js";
+import { toSnapshotOrNull } from "../../indexed/to-snapshot.js";
 import type { NodeId, ShortestPathResult } from "../../types/index.js";
 import { reconstructPath } from "../../utils/graph-utilities.js";
 
@@ -210,6 +213,52 @@ export function bellmanFordPath(graph: Graph, source: NodeId, target: NodeId): S
  * @returns True if the graph contains a negative cycle
  */
 export function hasNegativeCycle(graph: Graph): boolean {
+    // A -Infinity weight: legacy's answer depends on where its |V| - 1 rounds stopped, so keep that walk.
+    const s = hasMinusInfinityWeight(graph) ? null : toSnapshotOrNull(graph);
+    if (s === null) {
+        return hasNegativeCycleLegacy(graph);
+    }
+
+    // One search from each node no earlier search reached, as a cycle reachable from a reached node
+    // was reachable from that search's source too.
+    const weights = exactArcWeights(s);
+    const reached = new Uint8Array(s.nodeCount);
+    for (let source = 0; source < s.nodeCount; source++) {
+        if (reached[source] === 0) {
+            const { dist, hasNegativeCycle: found } = indexedBellmanFord(s, source, { weights });
+            if (found) {
+                return true;
+            }
+            for (let v = 0; v < s.nodeCount; v++) {
+                if (dist[v] !== Infinity) {
+                    reached[v] = 1;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+/**
+ * Whether any edge of the graph weighs -Infinity.
+ * @param graph - The graph to scan
+ * @returns True if any edge weighs -Infinity
+ */
+function hasMinusInfinityWeight(graph: Graph): boolean {
+    for (const edge of graph.edges()) {
+        if (edge.weight === -Infinity) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * The legacy check behind {@link hasNegativeCycle}, for a graph with a NaN or -Infinity weight.
+ * @param graph - The graph to check for negative cycles
+ * @returns True if the graph contains a negative cycle
+ */
+function hasNegativeCycleLegacy(graph: Graph): boolean {
     const nodes = Array.from(graph.nodes());
 
     if (nodes.length === 0) {

package/src/algorithms/shortest-path/dijkstra.ts

@@ -1,5 +1,8 @@
 import type { Graph } from "../../core/graph.js";
 import { PriorityQueue } from "../../data-structures/priority-queue.js";
+import { dijkstra as indexedDijkstra } from "../../indexed/dijkstra.js";
+import { exactArcWeights } from "../../indexed/facade.js";
+import { toSnapshotOrNull } from "../../indexed/to-snapshot.js";
 import type { DijkstraOptions, NodeId, ShortestPathResult } from "../../types/index.js";
 import { reconstructPath } from "../../utils/graph-utilities.js";
 import { BidirectionalDijkstra } from "./bidirectional-dijkstra.js";
@@ -174,6 +177,32 @@ export function singleSourceShortestPath(graph: Graph, source: NodeId, cutoff?:
         throw new Error(`Source node ${String(source)} not found in graph`);
     }
 
+    const s = toSnapshotOrNull(graph);
+    const weights = s === null ? undefined : (exactArcWeights(s) ?? s.weights ?? undefined);
+    // Dijkstra's answer with a negative or NaN weight depends on the order the legacy walk settled
+    // nodes in, which the port does not share: those graphs keep the legacy walk.
+    if (s === null || weights?.some((w) => w < 0) === true) {
+        return singleSourceShortestPathLegacy(graph, source, cutoff);
+    }
+
+    const { dist } = indexedDijkstra(s, s.ids.indexOf(source), { cutoff, weights });
+    const result = new Map<NodeId, number>();
+    for (let i = 0; i < s.nodeCount; i++) {
+        if (dist[i] < Infinity && (cutoff === undefined || dist[i] <= cutoff)) {
+            result.set(s.ids.idOf(i), dist[i]);
+        }
+    }
+    return result;
+}
+
+/**
+ * The legacy walk behind {@link singleSourceShortestPath}, for graphs with a negative or NaN weight.
+ * @param graph - The graph to search
+ * @param source - The starting node for the search, known to be in the graph
+ * @param cutoff - Optional maximum distance to search
+ * @returns A map of node IDs to their distances from the source
+ */
+function singleSourceShortestPathLegacy(graph: Graph, source: NodeId, cutoff?: number): Map<NodeId, number> {
     const distances = new Map<NodeId, number>();
     const visited = new Set<NodeId>();
     const pq = new PriorityQueue<NodeId>();

package/src/algorithms/shortest-path/floyd-warshall.ts

@@ -1,5 +1,10 @@
-import { Graph } from "../../core/graph.js";
-import type { NodeId } from "../../types/index.js";
+import { INVALID_INDEX } from "@graphty/graph-format";
+
+import type { Graph } from "../../core/graph.js";
+import { allPairsShortestPath } from "../../indexed/all-pairs.js";
+import { exactArcWeights } from "../../indexed/facade.js";
+import { toSnapshot } from "../../indexed/to-snapshot.js";
+import type { Edge, NodeId } from "../../types/index.js";
 
 export interface FloydWarshallResult {
     distances: Map<NodeId, Map<NodeId, number>>;
@@ -8,106 +13,91 @@ export interface FloydWarshallResult {
 }
 
 /**
- * Computes all-pairs shortest paths using the Floyd-Warshall algorithm
+ * The graph without its +Infinity edges, which the port refuses and which never shortened a path
+ * (`x + Infinity < d` is false), and those edges. A NaN or -Infinity weight has no such reading, so it
+ * throws.
+ * @param graph - The legacy graph
+ * @param name - The calling function, for the error message
+ * @returns The graph to run on (the input itself when every weight is finite) and the removed edges,
+ * each in both orientations on an undirected graph
+ * @throws RangeError on a NaN or -Infinity edge weight
+ */
+function withoutInfinite(graph: Graph, name: string): { finite: Graph; removed: Edge[] } {
+    const removed: Edge[] = [];
+    for (const e of graph.edges()) {
+        const w = e.weight ?? 1;
+        if (Number.isNaN(w) || w === -Infinity) {
+            throw new RangeError(
+                `${name}: the edge ${String(e.source)} -> ${String(e.target)} has weight ${String(w)}; weights must be numbers or +Infinity (no edge)`,
+            );
+        }
+        if (w === Infinity) {
+            removed.push(e);
+        }
+    }
+    if (removed.length === 0) {
+        return { finite: graph, removed };
+    }
+    const finite = graph.clone();
+    for (const e of removed) {
+        finite.removeEdge(e.source, e.target);
+    }
+    const reversed = graph.isDirected ? [] : removed.map((e) => ({ ...e, source: e.target, target: e.source }));
+    return { finite, removed: [...removed, ...reversed] };
+}
+
+/**
+ * Computes all-pairs shortest paths using the Floyd-Warshall algorithm: the port's sweep in node order
+ * over the exact f64 weights, with no node bound. A self-loop never changes a node's distance to itself
+ * (0); its predecessor on the diagonal is the node. Under a negative cycle (a negative undirected edge is
+ * one) every distance is NaN and every predecessor null. An infinite edge weight counts as no edge
+ * (its predecessor entry is its source while nothing reaches the target); a NaN weight leaves its own
+ * entry NaN and shortens nothing.
  * @param graph - The graph to compute shortest paths for
  * @returns The distances, predecessors, and negative cycle detection result
+ * @throws RangeError on a NaN or -Infinity edge weight
  */
 export function floydWarshall(graph: Graph): FloydWarshallResult {
-    const nodes = Array.from(graph.nodes()).map((n) => n.id);
+    const { finite, removed } = withoutInfinite(graph, "floydWarshall");
+    const s = toSnapshot(finite);
+    const { dist, n, predArc, hasNegativeCycle } = allPairsShortestPath(s, {
+        weights: exactArcWeights(s),
+        method: "floyd-warshall",
+        paths: true,
+        maxNodes: Infinity,
+    });
     const distances = new Map<NodeId, Map<NodeId, number>>();
     const predecessors = new Map<NodeId, Map<NodeId, NodeId | null>>();
-
-    for (const node of nodes) {
-        distances.set(node, new Map());
-        predecessors.set(node, new Map());
-
-        const nodeDistances = distances.get(node);
-        const nodePredecessors = predecessors.get(node);
-
-        if (!nodeDistances || !nodePredecessors) {
-            continue;
-        }
-
-        for (const other of nodes) {
-            if (node === other) {
-                nodeDistances.set(other, 0);
-                nodePredecessors.set(other, null);
-            } else {
-                nodeDistances.set(other, Infinity);
-                nodePredecessors.set(other, null);
-            }
+    for (let i = 0; i < n; i++) {
+        const row = new Map<NodeId, number>();
+        const predRow = new Map<NodeId, NodeId | null>();
+        for (let j = 0; j < n; j++) {
+            const id = s.ids.idOf(j);
+            row.set(id, dist[i * n + j]);
+            const arc = predArc?.[i * n + j];
+            predRow.set(
+                id,
+                hasNegativeCycle || arc === undefined || i === j || dist[i * n + j] === Infinity
+                    ? null
+                    : s.ids.idOf(s.arcSource(arc)),
+            );
         }
+        distances.set(s.ids.idOf(i), row);
+        predecessors.set(s.ids.idOf(i), predRow);
     }
-
-    for (const edge of Array.from(graph.edges())) {
-        const weight = edge.weight ?? 1;
-        const sourceDistances = distances.get(edge.source);
-        const sourcePredecessors = predecessors.get(edge.source);
-
-        if (sourceDistances && sourcePredecessors) {
-            sourceDistances.set(edge.target, weight);
-            sourcePredecessors.set(edge.target, edge.source);
-        }
-
-        if (!graph.isDirected) {
-            const targetDistances = distances.get(edge.target);
-            const targetPredecessors = predecessors.get(edge.target);
-
-            if (targetDistances && targetPredecessors) {
-                targetDistances.set(edge.source, weight);
-                targetPredecessors.set(edge.source, edge.target);
+    if (!hasNegativeCycle) {
+        for (const e of graph.edges()) {
+            if (e.source === e.target) {
+                predecessors.get(e.source)?.set(e.source, e.source);
             }
         }
-    }
-
-    for (const k of nodes) {
-        for (const i of nodes) {
-            for (const j of nodes) {
-                const distancesI = distances.get(i);
-                const distancesK = distances.get(k);
-                const predecessorsI = predecessors.get(i);
-                const predecessorsK = predecessors.get(k);
-
-                if (!distancesI || !distancesK || !predecessorsI || !predecessorsK) {
-                    continue;
-                }
-
-                const distIK = distancesI.get(k);
-                const distKJ = distancesK.get(j);
-                const distIJ = distancesI.get(j);
-
-                if (distIK === undefined || distKJ === undefined || distIJ === undefined) {
-                    continue;
-                }
-
-                if (distIK + distKJ < distIJ) {
-                    distancesI.set(j, distIK + distKJ);
-                    const predKJ = predecessorsK.get(j);
-                    predecessorsI.set(j, predKJ ?? null);
-                }
+        for (const { source, target } of removed) {
+            if (distances.get(source)?.get(target) === Infinity) {
+                predecessors.get(source)?.set(target, source);
             }
         }
     }
-
-    let hasNegativeCycle = false;
-    for (const node of nodes) {
-        const nodeDistances = distances.get(node);
-        if (!nodeDistances) {
-            continue;
-        }
-
-        const selfDistance = nodeDistances.get(node);
-        if (selfDistance !== undefined && selfDistance < 0) {
-            hasNegativeCycle = true;
-            break;
-        }
-    }
-
-    return {
-        distances,
-        predecessors,
-        hasNegativeCycle,
-    };
+    return { distances, predecessors, hasNegativeCycle };
 }
 
 /**
@@ -115,73 +105,53 @@ export function floydWarshall(graph: Graph): FloydWarshallResult {
  * @param graph - The graph to search
  * @param source - The starting node for the path
  * @param target - The destination node for the path
- * @returns The path and distance or null if no path exists
+ * @returns The path and distance, or null if either node is missing, no path exists, or the graph
+ * has a negative cycle
+ * @throws RangeError on a NaN or -Infinity edge weight
  */
 export function floydWarshallPath(
     graph: Graph,
     source: NodeId,
     target: NodeId,
 ): { path: NodeId[]; distance: number } | null {
-    const result = floydWarshall(graph);
-
-    if (!graph.hasNode(source) || !graph.hasNode(target)) {
-        return null;
-    }
-
-    const sourceDistances = result.distances.get(source);
-    if (!sourceDistances) {
+    const s = toSnapshot(withoutInfinite(graph, "floydWarshallPath").finite);
+    const i = s.ids.indexOf(source);
+    const j = s.ids.indexOf(target);
+    if (i === INVALID_INDEX || j === INVALID_INDEX) {
         return null;
     }
-
-    const distance = sourceDistances.get(target);
-    if (distance === undefined || distance === Infinity) {
+    const result = allPairsShortestPath(s, {
+        weights: exactArcWeights(s),
+        method: "floyd-warshall",
+        paths: true,
+        maxNodes: Infinity,
+    });
+    const distance = result.dist[i * result.n + j];
+    if (result.hasNegativeCycle || distance === Infinity) {
         return null;
     }
-
-    const path: NodeId[] = [];
-    let current: NodeId | null = target;
-
-    while (current !== null && current !== source) {
-        path.unshift(current);
-
-        const sourcePredecessors = result.predecessors.get(source);
-        if (!sourcePredecessors) {
-            return null;
-        }
-
-        current = sourcePredecessors.get(current) ?? null;
-
-        if (path.length > graph.nodeCount) {
-            return null;
-        }
-    }
-
-    if (current === source) {
-        path.unshift(source);
-        return { path, distance };
-    }
-
-    return null;
+    return { path: Array.from(result.pathTo(i, j), (k) => s.ids.idOf(k)), distance };
 }
 
 /**
- * Computes the transitive closure of a graph using Floyd-Warshall
+ * Computes the transitive closure of a graph: one breadth-first search per node, edge weights
+ * ignored except that a +Infinity edge counts as no edge.
  * @param graph - The graph to compute transitive closure for
- * @returns A map of each node to the set of nodes reachable from it
+ * @returns A map of each node to the set of nodes reachable from it, itself included, in node order
+ * @throws RangeError on a NaN or -Infinity edge weight
  */
 export function transitiveClosure(graph: Graph): Map<NodeId, Set<NodeId>> {
-    const result = floydWarshall(graph);
+    const s = toSnapshot(withoutInfinite(graph, "transitiveClosure").finite);
+    const { dist, n } = allPairsShortestPath(s, { weighted: false, maxNodes: Infinity });
     const closure = new Map<NodeId, Set<NodeId>>();
-
-    for (const [source, distances] of Array.from(result.distances)) {
+    for (let i = 0; i < n; i++) {
         const reachable = new Set<NodeId>();
-        for (const [target, distance] of Array.from(distances)) {
-            if (distance < Infinity) {
-                reachable.add(target);
+        for (let j = 0; j < n; j++) {
+            if (dist[i * n + j] < Infinity) {
+                reachable.add(s.ids.idOf(j));
             }
         }
-        closure.set(source, reachable);
+        closure.set(s.ids.idOf(i), reachable);
     }
-
     return closure;
 }