inner loop micro optimization

Author: j50n

README.md

@@ -2,33 +2,46 @@
 
 A pretty good implementation of Dijkstra's shortest-path algorithm for Deno.
 
-If you ever run into a problem that can be represented as a graph where the solution has something to do with finding the shortest path between nodes, this algorithm is nothing short of magical. It is well worth the time to learn how to use it, even if you don't really understand how the algorithm works.
+If you ever run into a problem that can be represented as a graph where the
+solution has something to do with finding the shortest path between nodes, this
+algorithm is nothing short of magical. It is well worth the time to learn how to
+use it, even if you don't really understand how the algorithm works.
 
-This implementation of Dijkstra'a algorithm is able to process large in-memory graphs. It will perform
-reasonably well even when the number of edges is in the millions. The performance is `O(n*log(n))`, where `n` is proportional to the number of nodes plus the number of edges in the graph.
+This implementation of Dijkstra'a algorithm is able to process large in-memory
+graphs. It will perform reasonably well even when the number of edges is in the
+millions. The performance is `O(n*log(n))`, where `n` is proportional to the
+number of nodes plus the number of edges in the graph.
 
 This code was adapted to Typescript from
 [A Walkthrough of Dijkstra's Algorithm (In JavaScript!)](https://medium.com/@adriennetjohnson/a-walkthrough-of-dijkstras-algorithm-in-javascript-e94b74192026)
 on Medium. This implemetation was originally part of
 [BlackholeSuns](https://github.com/j50n/blackholesuns), an open source project
 that allowed thousands of No Man's Sky players to navigate the galaxy using
-mapped black holes. This version is cleaned up a bit and includes a few bug fixes and more tests than the original. See also
+mapped black holes. This version is cleaned up a bit and includes a few bug
+fixes and more tests than the original. See also
 [Dijkstra's algorithm](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm) on
 Wikipedia.
 
 # Usage Hints
 
-Dijkstra's algorithm actually calculates the shortest paths from the start node to every other node in the graph. In other words, it isn't just calculating one path at a time. This can let you cheaply do things like find the 20 closest nodes from a particular node in the graph, for example. 
+Dijkstra's algorithm actually calculates the shortest paths from the start node
+to every other node in the graph. In other words, it isn't just calculating one
+path at a time. This can let you cheaply do things like find the 20 closest
+nodes from a particular node in the graph, for example.
 
-You can reverse the direction of the calculation. Calling it "start node" is just a convention. It can also be an end node if you set up the graph correctly.
+You can reverse the direction of the calculation. Calling it "start node" is
+just a convention. It can also be an end node if you set up the graph correctly.
 
-This implementation supports cloning the solver and extending its graph dynamically. Graph generation can be expensive. For many cases, most of the graph can be reused, with a only a small portion needing to be dynamic.  
+This implementation supports cloning the solver and extending its graph
+dynamically. Graph generation can be expensive. For many cases, most of the
+graph can be reused, with a only a small portion needing to be dynamic.
 
 # Example
 
 This example recreates the example from the article referenced earlier. The
 nodes are mapped to integers from `0` to `n-1`. The names and weights are taken
-from [A Walkthrough of Dijkstra's Algorithm (In JavaScript!)](https://medium.com/@adriennetjohnson/a-walkthrough-of-dijkstras-algorithm-in-javascript-e94b74192026).
+from
+[A Walkthrough of Dijkstra's Algorithm (In JavaScript!)](https://medium.com/@adriennetjohnson/a-walkthrough-of-dijkstras-algorithm-in-javascript-e94b74192026).
 
 ```ts
 const FULLSTACK = 0;

dijkstra.ts

@@ -68,7 +68,7 @@ export class DijkstraShortestPathSolver {
   }
 
   /**
-   * The number of nodes in the graph.
+   * The number of nodes in the graph. Nodes are numbered from `0` to `n-1`.
    */
   protected get nodes(): number {
     return this.adjacencyList.length;
@@ -144,15 +144,22 @@ export class DijkstraShortestPathSolver {
     this.adjacencyList[toNode].push({ toNode: fromNode, weight });
   }
 
-  setEdges(node: number, edges: IEdge[]): void {
-    this.adjacencyList[node] = edges;
-  }
+  // TODO: Not ready for general consumption.
+  // setEdges(node: number, edges: IEdge[]): void {
+  //   this.adjacencyList[node] = edges;
+  // }
 
   /**
    * Calculate shortest paths for all nodes for the given start node.
    * @param startNode The start node.
    */
   calculateFor(startNode: number): ShortestPaths {
+    if (startNode < 0 || startNode >= this.nodes) {
+      throw new RangeError(
+        `startNode must be in range 0..${this.nodes - 1}: ${startNode}`,
+      );
+    }
+
     const weights: number[] = new Array(this.nodes).fill(Infinity);
     weights[startNode] = 0;
 
@@ -166,15 +173,15 @@ export class DijkstraShortestPathSolver {
     while (pq.length !== 0) {
       const shortestStep = pq.pop();
 
-      const currentNode = shortestStep!.toNode;
+      const currentNode: number = shortestStep!.toNode;
 
       for (const neighbor of this.adjacencyList[currentNode]) {
         const weight = weights[currentNode] + neighbor.weight;
-
-        if (weight < weights[neighbor.toNode]) {
-          weights[neighbor.toNode] = weight;
-          backtrace[neighbor.toNode] = currentNode;
-          pq.push({ toNode: neighbor.toNode, weight: weight });
+        const toNode = neighbor.toNode;
+        if (weight < weights[toNode]) {
+          weights[toNode] = weight;
+          backtrace[toNode] = currentNode;
+          pq.push({ toNode, weight });
         }
       }
     }