@graphty/algorithms 1.0.1 → 1.1.0

package/src/pathfinding/astar.ts

@@ -0,0 +1,229 @@
+import {graphNode} from "../utils/graphNode.js";
+import {MinPriorityQueue} from "../utils/priorityQueue.js";
+import {pathfindingUtils} from "./utils.js";
+
+/**
+ * A* pathfinding algorithm
+ * Finds the shortest path from start to goal using a heuristic function
+ *
+ * @param graph - The graph represented as an adjacency list
+ * @param start - The starting node
+ * @param goal - The goal node
+ * @param heuristic - Heuristic function that estimates distance from node to goal
+ * @returns Object containing the shortest path and its cost, or null if no path exists
+ *
+ * Time Complexity: O(E) with good heuristic, O(b^d) worst case
+ * Space Complexity: O(V)
+ */
+export function astar<T>(
+    graph: Map<T, Map<T, number>>,
+    start: T,
+    goal: T,
+    heuristic: (node: T, goal: T) => number,
+): {path: T[], cost: number} | null {
+    if (!graph.has(start) || !graph.has(goal)) {
+        return null;
+    }
+
+    // Priority queue ordered by f(n) = g(n) + h(n)
+    const openSet = new MinPriorityQueue<graphNode<T>>();
+    const gScore = new Map<T, number>(); // Cost from start to node
+    const fScore = new Map<T, number>(); // Estimated total cost
+    const cameFrom = new Map<T, T>();
+    const closedSet = new Set<T>();
+
+    // Initialize start node
+    gScore.set(start, 0);
+    fScore.set(start, heuristic(start, goal));
+    const startFScore = fScore.get(start);
+    if (startFScore === undefined) {
+        return null;
+    }
+
+    openSet.insert({node: start, distance: startFScore});
+
+    while (!openSet.isEmpty()) {
+        const current = openSet.extractMin();
+        if (!current) {
+            break;
+        }
+
+        const currentNode = current.node;
+
+        if (currentNode === goal) {
+            // Reconstruct path
+            const path = pathfindingUtils.reconstructPath(cameFrom, goal);
+            const goalCost = gScore.get(goal);
+            if (goalCost === undefined) {
+                return null;
+            }
+
+            return {path, cost: goalCost};
+        }
+
+        closedSet.add(currentNode);
+
+        const neighbors = graph.get(currentNode);
+        if (!neighbors) {
+            continue;
+        }
+
+        for (const [neighbor, weight] of neighbors) {
+            if (closedSet.has(neighbor)) {
+                continue;
+            }
+
+            const currentNodeGScore = gScore.get(currentNode);
+            if (currentNodeGScore === undefined) {
+                continue;
+            }
+
+            const tentativeGScore = currentNodeGScore + weight;
+            const currentGScore = gScore.get(neighbor) ?? Infinity;
+
+            if (tentativeGScore < currentGScore) {
+                // This path to neighbor is better
+                cameFrom.set(neighbor, currentNode);
+                gScore.set(neighbor, tentativeGScore);
+                fScore.set(neighbor, tentativeGScore + heuristic(neighbor, goal));
+
+                // Add to open set if not already there
+                const neighborFScore = fScore.get(neighbor);
+                if (neighborFScore !== undefined) {
+                    openSet.insert({node: neighbor, distance: neighborFScore});
+                }
+            }
+        }
+    }
+
+    return null; // No path found
+}
+
+/**
+ * A* pathfinding with path reconstruction details
+ * Returns detailed information about the search process
+ */
+export function astarWithDetails<T>(
+    graph: Map<T, Map<T, number>>,
+    start: T,
+    goal: T,
+    heuristic: (node: T, goal: T) => number,
+): {
+        path: T[] | null;
+        cost: number;
+        visited: Set<T>;
+        gScores: Map<T, number>;
+        fScores: Map<T, number>;
+    } {
+    const openSet = new MinPriorityQueue<graphNode<T>>();
+    const gScore = new Map<T, number>();
+    const fScore = new Map<T, number>();
+    const cameFrom = new Map<T, T>();
+    const closedSet = new Set<T>();
+
+    gScore.set(start, 0);
+    fScore.set(start, heuristic(start, goal));
+    const startFScore = fScore.get(start);
+    if (startFScore === undefined) {
+        return {
+            path: null,
+            cost: Infinity,
+            visited: new Set(),
+            gScores: new Map(),
+            fScores: new Map(),
+        };
+    }
+
+    openSet.insert({node: start, distance: startFScore});
+
+    while (!openSet.isEmpty()) {
+        const current = openSet.extractMin();
+        if (!current) {
+            break;
+        }
+
+        const currentNode = current.node;
+
+        if (currentNode === goal) {
+            const path = pathfindingUtils.reconstructPath(cameFrom, goal);
+            return {
+                path,
+                cost: gScore.get(goal) ?? Infinity,
+                visited: closedSet,
+                gScores: gScore,
+                fScores: fScore,
+            };
+        }
+
+        closedSet.add(currentNode);
+
+        const neighbors = graph.get(currentNode);
+        if (!neighbors) {
+            continue;
+        }
+
+        for (const [neighbor, weight] of neighbors) {
+            if (closedSet.has(neighbor)) {
+                continue;
+            }
+
+            const currentNodeGScore = gScore.get(currentNode);
+            if (currentNodeGScore === undefined) {
+                continue;
+            }
+
+            const tentativeGScore = currentNodeGScore + weight;
+            const currentGScore = gScore.get(neighbor) ?? Infinity;
+
+            if (tentativeGScore < currentGScore) {
+                cameFrom.set(neighbor, currentNode);
+                gScore.set(neighbor, tentativeGScore);
+                fScore.set(neighbor, tentativeGScore + heuristic(neighbor, goal));
+                const neighborFScore = fScore.get(neighbor);
+                if (neighborFScore !== undefined) {
+                    openSet.insert({node: neighbor, distance: neighborFScore});
+                }
+            }
+        }
+    }
+
+    return {
+        path: null,
+        cost: Infinity,
+        visited: closedSet,
+        gScores: gScore,
+        fScores: fScore,
+    };
+}
+
+/**
+ * Common heuristic functions for A*
+ */
+export const heuristics = {
+    /**
+   * Manhattan distance heuristic for grid-based graphs
+   */
+    manhattan: (a: [number, number], b: [number, number]): number => {
+        return Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]);
+    },
+
+    /**
+   * Euclidean distance heuristic
+   */
+    euclidean: (a: [number, number], b: [number, number]): number => {
+        return Math.sqrt(Math.pow(a[0] - b[0], 2) + Math.pow(a[1] - b[1], 2));
+    },
+
+    /**
+   * Chebyshev distance heuristic (diagonal movement allowed)
+   */
+    chebyshev: (a: [number, number], b: [number, number]): number => {
+        return Math.max(Math.abs(a[0] - b[0]), Math.abs(a[1] - b[1]));
+    },
+
+    /**
+   * Zero heuristic (makes A* behave like Dijkstra)
+   */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    zero: <T>(_a: T, _b: T): number => 0,
+};

package/src/pathfinding/index.ts

@@ -0,0 +1,2 @@
+export * from "./astar.js";
+export * from "./utils.js";

package/src/pathfinding/utils.ts

@@ -0,0 +1,87 @@
+/**
+ * Utility functions for pathfinding algorithms
+ */
+
+export const pathfindingUtils = {
+    /**
+   * Reconstructs a path from start to goal using the cameFrom map
+   */
+    reconstructPath<T>(cameFrom: Map<T, T>, goal: T): T[] {
+        const path: T[] = [goal];
+        let current = goal;
+
+        while (cameFrom.has(current)) {
+            const next = cameFrom.get(current);
+            if (next === undefined) {
+                break;
+            }
+
+            current = next;
+            path.unshift(current);
+        }
+
+        return path;
+    },
+
+    /**
+   * Creates a grid graph for testing pathfinding algorithms
+   */
+    createGridGraph(
+        width: number,
+        height: number,
+        obstacles = new Set<string>(),
+    ): Map<string, Map<string, number>> {
+        const graph = new Map<string, Map<string, number>>();
+
+        for (let x = 0; x < width; x++) {
+            for (let y = 0; y < height; y++) {
+                const node = `${String(x)},${String(y)}`;
+                if (obstacles.has(node)) {
+                    continue;
+                }
+
+                const neighbors = new Map<string, number>();
+
+                // Add 4-directional neighbors
+                const directions = [
+                    [0, 1], [1, 0], [0, -1], [-1, 0],
+                ];
+
+                for (const dir of directions) {
+                    const dx = dir[0];
+                    const dy = dir[1];
+                    if (dx === undefined || dy === undefined) {
+                        continue;
+                    }
+
+                    const nx = x + dx;
+                    const ny = y + dy;
+                    const neighbor = `${String(nx)},${String(ny)}`;
+
+                    if (nx >= 0 && nx < width && ny >= 0 && ny < height && !obstacles.has(neighbor)) {
+                        neighbors.set(neighbor, 1); // Unit cost for grid movement
+                    }
+                }
+
+                graph.set(node, neighbors);
+            }
+        }
+
+        return graph;
+    },
+
+    /**
+   * Parses a grid coordinate string
+   */
+    parseGridCoordinate(coord: string): [number, number] {
+        const parts = coord.split(",").map(Number);
+        const x = parts[0];
+        const y = parts[1];
+        if (x === undefined || y === undefined) {
+            throw new Error(`Invalid coordinate: ${coord}`);
+        }
+
+        return [x, y];
+    },
+};
+

package/src/types/index.ts

@@ -53,6 +53,17 @@ export interface ComponentResult {
     componentMap: Map<NodeId, number>;
 }
 
+export interface MSTResult {
+    edges: Edge[];
+    totalWeight: number;
+}
+
+export interface FloydWarshallResult {
+    distances: Map<NodeId, Map<NodeId, number>>;
+    predecessors: Map<NodeId, Map<NodeId, NodeId | null>>;
+    hasNegativeCycle: boolean;
+}
+
 // Algorithm options interfaces
 export interface TraversalOptions {
     targetNode?: NodeId;

package/src/utils/graphNode.ts

@@ -0,0 +1,7 @@
+/**
+ * Graph node interface for priority queue operations
+ */
+export interface graphNode<T> {
+    node: T;
+    distance: number;
+}

package/src/utils/priorityQueue.ts

@@ -0,0 +1,120 @@
+/**
+ * Min Priority Queue implementation for graph algorithms
+ */
+export class MinPriorityQueue<T> {
+    private heap: T[] = [];
+    private compare: (a: T, b: T) => number;
+
+    constructor(compareFunction?: (a: T, b: T) => number) {
+        this.compare = compareFunction ?? ((a: T, b: T) => this.defaultCompare(a, b));
+    }
+
+    private defaultCompare(a: T, b: T): number {
+        const aWithDistance = a as T & {distance?: number};
+        const bWithDistance = b as T & {distance?: number};
+
+        if (aWithDistance.distance !== undefined && bWithDistance.distance !== undefined) {
+            return aWithDistance.distance - bWithDistance.distance;
+        }
+
+        return 0;
+    }
+
+    private parent(i: number): number {
+        return Math.floor((i - 1) / 2);
+    }
+
+    private leftChild(i: number): number {
+        return (2 * i) + 1;
+    }
+
+    private rightChild(i: number): number {
+        return (2 * i) + 2;
+    }
+
+    private swap(i: number, j: number): void {
+        const temp = this.heap[i];
+        const temp2 = this.heap[j];
+        if (temp !== undefined && temp2 !== undefined) {
+            this.heap[i] = temp2;
+            this.heap[j] = temp;
+        }
+    }
+
+    private heapifyUp(index: number): void {
+        while (index > 0) {
+            const parentIndex = this.parent(index);
+            const current = this.heap[index];
+            const parent = this.heap[parentIndex];
+            if (current !== undefined && parent !== undefined && this.compare(current, parent) < 0) {
+                this.swap(index, parentIndex);
+                index = parentIndex;
+            } else {
+                break;
+            }
+        }
+    }
+
+    private heapifyDown(index: number): void {
+        while (index < this.heap.length) {
+            let minIndex = index;
+            const left = this.leftChild(index);
+            const right = this.rightChild(index);
+
+            const leftItem = this.heap[left];
+            const minItem = this.heap[minIndex];
+            if (left < this.heap.length && leftItem !== undefined && minItem !== undefined && this.compare(leftItem, minItem) < 0) {
+                minIndex = left;
+            }
+
+            const rightItem = this.heap[right];
+            const newMinItem = this.heap[minIndex];
+            if (right < this.heap.length && rightItem !== undefined && newMinItem !== undefined && this.compare(rightItem, newMinItem) < 0) {
+                minIndex = right;
+            }
+
+            if (minIndex !== index) {
+                this.swap(index, minIndex);
+                index = minIndex;
+            } else {
+                break;
+            }
+        }
+    }
+
+    insert(value: T): void {
+        this.heap.push(value);
+        this.heapifyUp(this.heap.length - 1);
+    }
+
+    extractMin(): T | undefined {
+        if (this.heap.length === 0) {
+            return undefined;
+        }
+
+        if (this.heap.length === 1) {
+            return this.heap.pop();
+        }
+
+        const min = this.heap[0];
+        const last = this.heap.pop();
+        if (last !== undefined) {
+            this.heap[0] = last;
+            this.heapifyDown(0);
+        }
+
+        return min;
+    }
+
+    peek(): T | undefined {
+        return this.heap[0];
+    }
+
+    isEmpty(): boolean {
+        return this.heap.length === 0;
+    }
+
+    size(): number {
+        return this.heap.length;
+    }
+}

package/dist/test/browser/basic.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=basic.test.d.ts.map

package/dist/test/browser/basic.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"basic.test.d.ts","sourceRoot":"","sources":["../../../test/browser/basic.test.ts"],"names":[],"mappings":""}

package/dist/test/browser/basic.test.js

@@ -1,70 +0,0 @@
-/* eslint-disable dot-notation */
-import { describe, expect, it } from "vitest";
-import { degreeCentrality } from "../../src/algorithms/centrality/degree.js";
-import { dijkstra } from "../../src/algorithms/shortest-path/dijkstra.js";
-import { breadthFirstSearch, depthFirstSearch } from "../../src/algorithms/traversal/index.js";
-import { Graph } from "../../src/core/graph.js";
-describe("Browser Environment Tests", () => {
-    it("should create and manipulate graphs in browser", () => {
-        const graph = new Graph();
-        graph.addEdge("a", "b");
-        graph.addEdge("b", "c");
-        graph.addEdge("c", "d");
-        expect(graph.nodeCount).toBe(4);
-        expect(graph.totalEdgeCount).toBe(3);
-    });
-    it("should run BFS traversal in browser", () => {
-        const graph = new Graph();
-        graph.addEdge("a", "b");
-        graph.addEdge("a", "c");
-        graph.addEdge("b", "d");
-        const result = breadthFirstSearch(graph, "a");
-        expect(result.visited.size).toBe(4);
-        expect(result.order).toHaveLength(4);
-        expect(result.order[0]).toBe("a");
-    });
-    it("should run DFS traversal in browser", () => {
-        const graph = new Graph();
-        graph.addEdge("a", "b");
-        graph.addEdge("a", "c");
-        graph.addEdge("b", "d");
-        const result = depthFirstSearch(graph, "a");
-        expect(result.visited.size).toBe(4);
-        expect(result.order).toHaveLength(4);
-        expect(result.order[0]).toBe("a");
-    });
-    it("should calculate degree centrality in browser", () => {
-        const graph = new Graph();
-        graph.addEdge("center", "a");
-        graph.addEdge("center", "b");
-        graph.addEdge("center", "c");
-        const centrality = degreeCentrality(graph);
-        expect(centrality["center"]).toBe(3);
-        expect(centrality["a"]).toBe(1);
-    });
-    it("should run Dijkstra algorithm in browser", () => {
-        const graph = new Graph();
-        graph.addEdge("a", "b", 1);
-        graph.addEdge("b", "c", 2);
-        graph.addEdge("a", "c", 4);
-        const results = dijkstra(graph, "a");
-        const resultC = results.get("c");
-        expect(resultC).toBeDefined();
-        expect(resultC?.distance).toBe(3); // a -> b -> c
-        expect(resultC?.path).toEqual(["a", "b", "c"]);
-    });
-    it("should handle large graphs in browser", () => {
-        const graph = new Graph();
-        const nodeCount = 100;
-        // Create a chain
-        for (let i = 0; i < nodeCount - 1; i++) {
-            graph.addEdge(i, i + 1);
-        }
-        expect(graph.nodeCount).toBe(nodeCount);
-        // Run BFS to ensure traversal works
-        const result = breadthFirstSearch(graph, 0);
-        expect(result.visited.size).toBe(nodeCount);
-        expect(result.order).toHaveLength(nodeCount);
-    });
-});
-//# sourceMappingURL=basic.test.js.map

package/dist/test/browser/basic.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"basic.test.js","sourceRoot":"","sources":["../../../test/browser/basic.test.ts"],"names":[],"mappings":"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"}

package/dist/test/unit/bellman-ford.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=bellman-ford.test.d.ts.map

package/dist/test/unit/bellman-ford.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bellman-ford.test.d.ts","sourceRoot":"","sources":["../../../test/unit/bellman-ford.test.ts"],"names":[],"mappings":""}