terra-route 0.0.4 → 0.0.6

package/src/terra-route.ts

@@ -1,5 +1,5 @@
 import { FeatureCollection, LineString, Point, Feature, Position } from "geojson";
-import { MinHeap } from "./min-heap";
+import { FibonacciHeap } from "./fibonacci-heap";
 import { haversineDistance } from "./distance/haversine";
 import { createCheapRuler } from "./distance/cheap-ruler";
 
@@ -44,11 +44,11 @@ class TerraRoute {
             return latMap.get(lat)!;
         }
 
-        const idx = this.coords.length;
+        const index = this.coords.length;
         this.coords.push(coord);
-        latMap.set(lat, idx);
+        latMap.set(lat, index);
 
-        return idx;
+        return index;
     }
 
     /**
@@ -68,21 +68,21 @@ class TerraRoute {
         for (const feature of this.network.features) {
             const coords = feature.geometry.coordinates;
             for (let i = 0; i < coords.length - 1; i++) {
-                const aIdx = this.coordinateIndex(coords[i]);
-                const bIdx = this.coordinateIndex(coords[i + 1]);
+                const aIndex = this.coordinateIndex(coords[i]);
+                const bIndex = this.coordinateIndex(coords[i + 1]);
                 const distance = this.distanceMeasurement(coords[i], coords[i + 1]);
 
-                if (!this.adjacencyList.has(aIdx)) this.adjacencyList.set(aIdx, []);
-                if (!this.adjacencyList.has(bIdx)) this.adjacencyList.set(bIdx, []);
+                if (!this.adjacencyList.has(aIndex)) this.adjacencyList.set(aIndex, []);
+                if (!this.adjacencyList.has(bIndex)) this.adjacencyList.set(bIndex, []);
 
-                this.adjacencyList.get(aIdx)!.push({ node: bIdx, distance });
-                this.adjacencyList.get(bIdx)!.push({ node: aIdx, distance });
+                this.adjacencyList.get(aIndex)!.push({ node: bIndex, distance });
+                this.adjacencyList.get(bIndex)!.push({ node: aIndex, distance });
             }
         }
     }
 
     /**
-    * Computes the shortest route between two points in the network using A* algorithm.
+    * Computes the shortest route between two points in the network using bidirectional A* algorithm.
     * 
     * @param start - A GeoJSON Point Feature representing the start location.
     * @param end - A GeoJSON Point Feature representing the end location.
@@ -92,52 +92,96 @@ class TerraRoute {
     */
     public getRoute(start: Feature<Point>, end: Feature<Point>): Feature<LineString> | null {
         if (!this.network) {
-            throw new Error("Network not built. Please call buildNetworkGraph(network) first.");
+            throw new Error("Network not built. Please call buildRouteGraph(network) first.");
         }
 
-        const startIdx = this.coordinateIndex(start.geometry.coordinates);
-        const endIdx = this.coordinateIndex(end.geometry.coordinates);
+        const startIndex = this.coordinateIndex(start.geometry.coordinates);
+        const endIndex = this.coordinateIndex(end.geometry.coordinates);
 
-        if (startIdx === endIdx) {
+        if (startIndex === endIndex) {
             return null;
         }
 
-        const openSet = new MinHeap();
-        openSet.insert(0, startIdx);
-        const cameFrom = new Map<number, number>();
-        const gScore = new Map<number, number>([[startIdx, 0]]);
+        const openSetForward = new FibonacciHeap();
+        const openSetBackward = new FibonacciHeap();
+        openSetForward.insert(0, startIndex);
+        openSetBackward.insert(0, endIndex);
 
-        while (openSet.size() > 0) {
-            const current = openSet.extractMin()!;
+        const cameFromForward = new Map<number, number>();
+        const cameFromBackward = new Map<number, number>();
+        const gScoreForward = new Map<number, number>([[startIndex, 0]]);
+        const gScoreBackward = new Map<number, number>([[endIndex, 0]]);
 
-            if (current === endIdx) {
-                const path: Position[] = [];
-                let currNode: number | undefined = current;
-                while (currNode !== undefined) {
-                    path.unshift(this.coords[currNode]);
-                    currNode = cameFrom.get(currNode);
+        const visitedForward = new Set<number>();
+        const visitedBackward = new Set<number>();
+
+        let meetingNode: number | null = null;
+
+        while (openSetForward.size() > 0 && openSetBackward.size() > 0) {
+            const currentForward = openSetForward.extractMin()!;
+            visitedForward.add(currentForward);
+
+            if (visitedBackward.has(currentForward)) {
+                meetingNode = currentForward;
+                break;
+            }
+
+            for (const neighbor of this.adjacencyList.get(currentForward) || []) {
+                const tentativeG = (gScoreForward.get(currentForward) ?? Infinity) + neighbor.distance;
+                if (tentativeG < (gScoreForward.get(neighbor.node) ?? Infinity)) {
+                    cameFromForward.set(neighbor.node, currentForward);
+                    gScoreForward.set(neighbor.node, tentativeG);
+                    const fScore = tentativeG + this.distanceMeasurement(this.coords[neighbor.node], this.coords[endIndex]);
+                    openSetForward.insert(fScore, neighbor.node);
                 }
-                return {
-                    type: "Feature",
-                    geometry: { type: "LineString", coordinates: path },
-                    properties: {},
-                };
             }
 
-            const neighbors = this.adjacencyList.get(current) || [];
+            const currentBackward = openSetBackward.extractMin()!;
+            visitedBackward.add(currentBackward);
+
+            if (visitedForward.has(currentBackward)) {
+                meetingNode = currentBackward;
+                break;
+            }
 
-            for (const neighbor of neighbors) {
-                const tentativeGScore = (gScore.get(current) ?? Infinity) + neighbor.distance;
-                if (tentativeGScore < (gScore.get(neighbor.node) ?? Infinity)) {
-                    cameFrom.set(neighbor.node, current);
-                    gScore.set(neighbor.node, tentativeGScore);
-                    const fScore = tentativeGScore + this.distanceMeasurement(this.coords[neighbor.node], this.coords[endIdx]);
-                    openSet.insert(fScore, neighbor.node);
+            for (const neighbor of this.adjacencyList.get(currentBackward) || []) {
+                const tentativeG = (gScoreBackward.get(currentBackward) ?? Infinity) + neighbor.distance;
+                if (tentativeG < (gScoreBackward.get(neighbor.node) ?? Infinity)) {
+                    cameFromBackward.set(neighbor.node, currentBackward);
+                    gScoreBackward.set(neighbor.node, tentativeG);
+                    const fScore = tentativeG + this.distanceMeasurement(this.coords[neighbor.node], this.coords[startIndex]);
+                    openSetBackward.insert(fScore, neighbor.node);
                 }
             }
         }
 
-        return null;
+        if (meetingNode === null) {
+            return null;
+        }
+
+        // Reconstruct forward path
+        const pathForward: Position[] = [];
+        let node = meetingNode;
+        while (node !== undefined) {
+            pathForward.unshift(this.coords[node]);
+            node = cameFromForward.get(node)!;
+        }
+
+        // Reconstruct backward path (omit meeting node to avoid duplication)
+        const pathBackward: Position[] = [];
+        node = cameFromBackward.get(meetingNode)!;
+        while (node !== undefined) {
+            pathBackward.push(this.coords[node]);
+            node = cameFromBackward.get(node)!;
+        }
+
+        const fullPath = [...pathForward, ...pathBackward];
+
+        return {
+            type: "Feature",
+            geometry: { type: "LineString", coordinates: fullPath },
+            properties: {},
+        };
     }
 }
 

package/src/test-utils/test-utils.ts

@@ -374,6 +374,8 @@ export function getReasonIfLineStringInvalid(
         return `Not enough coordinates: ${coords.length} (${coords})`;
     }
 
+    const seen = new Set<string>();
+
     // 5. Validate each coordinate is a valid Position
     //    (At minimum, [number, number] or [number, number, number])
     for (const position of coords) {
@@ -389,5 +391,12 @@ export function getReasonIfLineStringInvalid(
         ) {
             return 'Not a Position; elements are not a numbers';
         }
+
+        // 6. Check for duplicates
+        const key = `${position[0]},${position[1]}`;
+        if (seen.has(key)) {
+            return `Duplicate coordinate: ${key}`;
+        }
+        seen.add(key);
     }
 }

package/src/min-heap.spec.ts

@@ -1,75 +0,0 @@
-import { MinHeap } from './min-heap';
-
-describe('MinHeap', () => {
-    let heap: MinHeap;
-
-    beforeEach(() => {
-        heap = new MinHeap();
-    });
-
-    it('should create an empty heap', () => {
-        expect(heap.size()).toBe(0);
-    });
-
-    it('should insert a single element', () => {
-        heap.insert(5, 100);
-        expect(heap.size()).toBe(1);
-        expect(heap.extractMin()).toBe(100);
-        expect(heap.size()).toBe(0);
-    });
-
-    it('should maintain correct heap order when inserting multiple elements', () => {
-        heap.insert(10, 200);
-        heap.insert(5, 100);
-        heap.insert(3, 50);
-        heap.insert(7, 150);
-
-        expect(heap.size()).toBe(4);
-        expect(heap.extractMin()).toBe(50);
-        expect(heap.extractMin()).toBe(100);
-        expect(heap.extractMin()).toBe(150);
-        expect(heap.extractMin()).toBe(200);
-        expect(heap.size()).toBe(0);
-    });
-
-    it('should return null when extracting from an empty heap', () => {
-        expect(heap.extractMin()).toBeNull();
-    });
-
-    it('should handle duplicate keys properly', () => {
-        heap.insert(5, 100);
-        heap.insert(5, 200);
-        heap.insert(5, 300);
-
-        expect(heap.size()).toBe(3);
-        expect(heap.extractMin()).toBe(100);
-        expect(heap.extractMin()).toBe(200);
-        expect(heap.extractMin()).toBe(300);
-        expect(heap.size()).toBe(0);
-    });
-
-    it('should correctly reorder after sequential insert and extract', () => {
-        heap.insert(10, 100);
-        heap.insert(1, 50);
-        expect(heap.extractMin()).toBe(50);
-
-        heap.insert(2, 60);
-        heap.insert(3, 70);
-        expect(heap.extractMin()).toBe(60);
-        expect(heap.extractMin()).toBe(70);
-        expect(heap.extractMin()).toBe(100);
-    });
-
-    it('should handle large number of elements correctly', () => {
-        const elements = Array.from({ length: 1000 }, (_, i) => ({ key: 1000 - i, value: i }));
-        elements.forEach(el => heap.insert(el.key, el.value));
-
-        expect(heap.size()).toBe(1000);
-
-        for (let i = 999; i >= 0; i--) {
-            expect(heap.extractMin()).toBe(i);
-        }
-
-        expect(heap.size()).toBe(0);
-    });
-});

package/src/min-heap.ts

@@ -1,87 +0,0 @@
-export class MinHeap {
-    private heap: Array<{ key: number; value: number; index: number }> = [];
-    private insertCounter = 0;
-
-    insert(key: number, value: number): void {
-        const node = { key, value, index: this.insertCounter++ };
-        let idx = this.heap.length;
-        this.heap.push(node);
-
-        // Optimized Bubble Up
-        while (idx > 0) {
-            const parentIdx = (idx - 1) >>> 1; // Fast Math.floor((idx - 1) / 2)
-            const parent = this.heap[parentIdx];
-            if (node.key > parent.key || (node.key === parent.key && node.index > parent.index)) break;
-            this.heap[idx] = parent;
-            idx = parentIdx;
-        }
-        this.heap[idx] = node;
-    }
-
-    extractMin(): number | null {
-        const length = this.heap.length;
-        if (length === 0) return null;
-
-        const minNode = this.heap[0];
-        const endNode = this.heap.pop()!;
-
-        if (length > 1) {
-            this.heap[0] = endNode;
-            this.bubbleDown(0);
-        }
-
-        return minNode.value;
-    }
-
-    size(): number {
-        return this.heap.length;
-    }
-
-    private bubbleDown(idx: number): void {
-        const { heap } = this;
-        const length = heap.length;
-        // Grab the parent node once, then move it down only if needed
-        const node = heap[idx];
-        const nodeKey = node.key;
-        const nodeIndex = node.index;
-
-        while (true) {
-            // Calculate left and right child indexes
-            const leftIdx = (idx << 1) + 1;
-            if (leftIdx >= length) {
-                // No children => we’re already in place
-                break;
-            }
-
-            // Assume left child is the smaller one by default
-            let smallestIdx = leftIdx;
-            let smallestKey = heap[leftIdx].key;
-            let smallestIndex = heap[leftIdx].index;
-
-            const rightIdx = leftIdx + 1;
-            if (rightIdx < length) {
-                // Compare left child vs. right child
-                const rightKey = heap[rightIdx].key;
-                const rightIndex = heap[rightIdx].index;
-                if (rightKey < smallestKey || (rightKey === smallestKey && rightIndex < smallestIndex)) {
-                    smallestIdx = rightIdx;
-                    smallestKey = rightKey;
-                    smallestIndex = rightIndex;
-                }
-            }
-
-            // Compare the smaller child with the parent
-            if (smallestKey < nodeKey || (smallestKey === nodeKey && smallestIndex < nodeIndex)) {
-                // Swap the smaller child up
-                heap[idx] = heap[smallestIdx];
-                idx = smallestIdx;
-            } else {
-                // We’re in the correct position now, so stop
-                break;
-            }
-        }
-
-        // Place the original node in its final position
-        heap[idx] = node;
-    }
-}