✨ introduce a better interface for Edge

Author: saby1101

src/graph/dijkstra.bench.ts

@@ -39,7 +39,9 @@ const edges = generateSampleData(N, EDGE_PROB);
 
 let result: any;
 // warmup
-const spa = createSPA(edges);
+const spa = createSPA(
+  edges.map((e) => ({ from: e[0], to: e[1], distance: e[2] })),
+);
 for (let i = 0; i < ITERS; i++) {
   const a = Math.floor(Math.random() * N);
   const b = Math.floor(Math.random() * N);

src/graph/dijkstra.spec.ts

@@ -5,15 +5,18 @@ const INF = 1e9;
 
 const createSPAlgoUndirected = (edges: any[]) => {
   return new DijkstraShortestPath(
-    edges,
+    edges.flatMap((e) => [
+      { from: e[0], to: e[1], distance: e[2] },
+      { from: e[1], to: e[0], distance: e[2] },
+    ]),
     () => new mnemonist.Heap<HeapNode>((a, b) => a.distance - b.distance),
     INF,
   );
 };
 
 const createSPAlgoDirected = (edges: any[]) => {
   return new DijkstraShortestPath(
-    edges,
+    edges.map((e) => ({ from: e[0], to: e[1], distance: e[2] })),
     () => new mnemonist.Heap<HeapNode>((a, b) => a.distance - b.distance),
     INF,
   );

src/graph/dijkstra.ts

@@ -1,5 +1,5 @@
 import {
-  Edge,
+  EdgeDef,
   PriorityQueue,
   ShortestPath,
   ShortestPathAlgo,
@@ -12,7 +12,7 @@ export class HeapNode {
   ) {}
 }
 
-export class DijkstraShortestPath<T, E extends Edge<T>>
+export class DijkstraShortestPath<T, E extends EdgeDef<T>>
   implements ShortestPathAlgo<T, E>
 {
   private readonly nodeToIndex = new Map<T, number>();
@@ -24,7 +24,7 @@ export class DijkstraShortestPath<T, E extends Edge<T>>
     public priorityQueueFactory: () => PriorityQueue<HeapNode>,
     public readonly INF = 1e9,
   ) {
-    const nodeSet = new Set(edges.flatMap((e) => [e[0], e[1]]));
+    const nodeSet = new Set(edges.flatMap((e) => [e.from, e.to]));
     let index = 0;
     for (const node of nodeSet) {
       this.nodes[index] = node;
@@ -33,11 +33,11 @@ export class DijkstraShortestPath<T, E extends Edge<T>>
       index++;
     }
     for (const edge of edges) {
-      const fromId = this.nodeToIndex.get(edge[0]);
+      const fromId = this.nodeToIndex.get(edge.from);
       if (fromId == null) {
         throw new Error();
       }
-      const toId = this.nodeToIndex.get(edge[1]);
+      const toId = this.nodeToIndex.get(edge.to);
       if (toId == null) {
         throw new Error();
       }
@@ -51,7 +51,7 @@ export class DijkstraShortestPath<T, E extends Edge<T>>
   calculate(
     srcNode: T,
     dstNode: T,
-    distFn: (edge: E) => number = (e) => e[2],
+    distFn: (edge: E) => number = (e) => e.distance,
   ): ShortestPath<T> {
     const src = this.nodeToIndex.get(srcNode)!;
     if (src == null) {
@@ -94,7 +94,7 @@ export class DijkstraShortestPath<T, E extends Edge<T>>
         }
         if (dist < 0) {
           throw new Error(
-            `Negative distance ${dist} for edge ${neighbor.edge[0]} -> ${neighbor.edge[1]}`,
+            `Negative distance ${dist} for edge ${neighbor.edge.from} -> ${neighbor.edge.to}`,
           );
         }
         const candidate = distances[node] + dist;

src/graph/index.ts

@@ -5,6 +5,7 @@ export {
 } from "./floyd-warshal";
 export {
   Edge,
+  EdgeDef,
   TransitiveClosure,
   INF,
   PriorityQueue,

src/graph/interfaces.ts

@@ -4,6 +4,12 @@
 // [parent, child, distance]
 export type Edge<T> = [T, T, number];
 
+export interface EdgeDef<T> {
+  from: T;
+  to: T;
+  distance: number;
+}
+
 export type TransitiveClosure<T> = {
   parent: T;
   child: T;
@@ -24,7 +30,7 @@ export interface ShortestPath<T> {
   distance: number;
 }
 
-export interface ShortestPathAlgo<T, E extends Edge<T>> {
+export interface ShortestPathAlgo<T, E extends EdgeDef<T>> {
   calculate(
     srcNode: T,
     dstNode: T,