move all functionality into a single file

Author: bgrins

Gruntfile.js

@@ -16,7 +16,7 @@ module.exports = function(grunt) {
         globals: {
         }
       },
-      all: ['graph.js', 'astar.js']
+      all: ['astar.js']
     }
   });
 

README.md

@@ -4,22 +4,10 @@
 
 See a demo at http://www.briangrinstead.com/files/astar/
 
-### astar.js
-
-The newest version of the algorithm using a Binary Heap.  It is quite faster than the original.
-http://www.briangrinstead.com/blog/astar-search-algorithm-in-javascript-updated
-Binary Heap taken from http://eloquentjavascript.net/appendix2.html (license: http://creativecommons.org/licenses/by/3.0/)
-
-### original-implementation/astar-list.js:
-
-The original version of the algorithm based off the original blog post at: http://www.briangrinstead.com/blog/astar-search-algorithm-in-javascript
-I left it in because it may be a little easier for some people to understand, but if you are planning on actually using this, I would strongly recommend using astar.js instead.
-
 ## Sample Usage
 
 If you want just the A* search code (not the demo visualization), use code like this http://gist.github.com/581352
 
-	<script type='text/javascript' src='graph.js'></script>
 	<script type='text/javascript' src='astar.js'></script>
 	<script type='text/javascript'>
 		var graph = new Graph([
@@ -48,6 +36,15 @@ If you want just the A* search code (not the demo visualization), use code like
 		// resultWithWeight is an array containing the shortest path taking into account the weight of a node
 	</script>
 
+### Original (slower) implementation
+
+The original version of the algorithm used a list, and was a bit clearer but much slower.  It was based off the [original blog post](http://www.briangrinstead.com/blog/astar-search-algorithm-in-javascript).  The code is available at: https://github.com/bgrins/javascript-astar/tree/0.0.1/original-implementation.
+
+The newest version of the algorithm using a Binary Heap.  It is quite faster than the original.
+http://www.briangrinstead.com/blog/astar-search-algorithm-in-javascript-updated
+Binary Heap taken from http://eloquentjavascript.net/appendix2.html (license: http://creativecommons.org/licenses/by/3.0/)
+
+
 ## Running the test suite
 
 If you don't have grunt installed, follow the [grunt getting started guide](http://gruntjs.com/getting-started) first.

astar.js

@@ -1,16 +1,19 @@
-// javascript-astar
+// javascript-astar 0.0.1
 // http://github.com/bgrins/javascript-astar
 // Freely distributable under the MIT License.
-// Implements the astar search algorithm in javascript using a binary heap.
-
+// Implements the astar search algorithm in javascript using a Binary Heap.
+// Includes Binary Heap (with modifications) from Marijn Haverbeke.
+// http://eloquentjavascript.net/appendix2.html
 
 (function(definition) {
     if(typeof exports === 'object') {
         module.exports = definition();
     } else if(typeof define === 'function' && define.amd) {
         define([], definition);
     } else {
-        window.astar = definition();
+        var exports = definition();
+        window.astar = exports.astar;
+        window.Graph = exports.Graph;
     }
 })(function() {
 
@@ -162,6 +165,181 @@ var astar = {
     }
 };
 
-return astar;
+function Graph(grid) {
+    var nodes = [];
+
+    for (var x = 0; x < grid.length; x++) {
+        nodes[x] = [];
+
+        for (var y = 0, row = grid[x]; y < row.length; y++) {
+            nodes[x][y] = new GraphNode(x, y, row[y]);
+        }
+    }
+
+    this.input = grid;
+    this.nodes = nodes;
+}
+
+Graph.prototype.toString = function() {
+    var graphString = "\n";
+    var nodes = this.nodes;
+    var rowDebug, row, y, l;
+    for (var x = 0, len = nodes.length; x < len; x++) {
+        rowDebug = "";
+        row = nodes[x];
+        for (y = 0, l = row.length; y < l; y++) {
+            rowDebug += row[y].type + " ";
+        }
+        graphString = graphString + rowDebug + "\n";
+    }
+    return graphString;
+};
+
+function GraphNode(x,y,type) {
+    this.data = { };
+    this.x = x;
+    this.y = y;
+    this.pos = {
+        x: x,
+        y: y
+    };
+    this.type = type;
+}
+
+GraphNode.prototype.toString = function() {
+    return "[" + this.x + " " + this.y + "]";
+};
+
+GraphNode.prototype.isWall = function() {
+    return this.type === 0;
+};
+
+function BinaryHeap(scoreFunction){
+    this.content = [];
+    this.scoreFunction = scoreFunction;
+}
+
+BinaryHeap.prototype = {
+    push: function(element) {
+        // Add the new element to the end of the array.
+        this.content.push(element);
+
+        // Allow it to sink down.
+        this.sinkDown(this.content.length - 1);
+    },
+    pop: function() {
+        // Store the first element so we can return it later.
+        var result = this.content[0];
+        // Get the element at the end of the array.
+        var end = this.content.pop();
+        // If there are any elements left, put the end element at the
+        // start, and let it bubble up.
+        if (this.content.length > 0) {
+            this.content[0] = end;
+            this.bubbleUp(0);
+        }
+        return result;
+    },
+    remove: function(node) {
+        var i = this.content.indexOf(node);
+
+        // When it is found, the process seen in 'pop' is repeated
+        // to fill up the hole.
+        var end = this.content.pop();
+
+        if (i !== this.content.length - 1) {
+            this.content[i] = end;
+
+            if (this.scoreFunction(end) < this.scoreFunction(node)) {
+                this.sinkDown(i);
+            }
+            else {
+                this.bubbleUp(i);
+            }
+        }
+    },
+    size: function() {
+        return this.content.length;
+    },
+    rescoreElement: function(node) {
+        this.sinkDown(this.content.indexOf(node));
+    },
+    sinkDown: function(n) {
+        // Fetch the element that has to be sunk.
+        var element = this.content[n];
+
+        // When at 0, an element can not sink any further.
+        while (n > 0) {
+
+            // Compute the parent element's index, and fetch it.
+            var parentN = ((n + 1) >> 1) - 1,
+                parent = this.content[parentN];
+            // Swap the elements if the parent is greater.
+            if (this.scoreFunction(element) < this.scoreFunction(parent)) {
+                this.content[parentN] = element;
+                this.content[n] = parent;
+                // Update 'n' to continue at the new position.
+                n = parentN;
+            }
+
+            // Found a parent that is less, no need to sink any further.
+            else {
+                break;
+            }
+        }
+    },
+    bubbleUp: function(n) {
+        // Look up the target element and its score.
+        var length = this.content.length,
+            element = this.content[n],
+            elemScore = this.scoreFunction(element);
+
+        while(true) {
+            // Compute the indices of the child elements.
+            var child2N = (n + 1) << 1, child1N = child2N - 1;
+            // This is used to store the new position of the element,
+            // if any.
+            var swap = null;
+            var child1Score;
+            // If the first child exists (is inside the array)...
+            if (child1N < length) {
+                // Look it up and compute its score.
+                var child1 = this.content[child1N];
+                child1Score = this.scoreFunction(child1);
+
+                // If the score is less than our element's, we need to swap.
+                if (child1Score < elemScore){
+                    swap = child1N;
+                }
+            }
+
+            // Do the same checks for the other child.
+            if (child2N < length) {
+                var child2 = this.content[child2N],
+                    child2Score = this.scoreFunction(child2);
+                if (child2Score < (swap === null ? elemScore : child1Score)) {
+                    swap = child2N;
+                }
+            }
+
+            // If the element needs to be moved, swap it, and continue.
+            if (swap !== null) {
+                this.content[n] = this.content[swap];
+                this.content[swap] = element;
+                n = swap;
+            }
+
+            // Otherwise, we are done.
+            else {
+                break;
+            }
+        }
+    }
+};
+
+return {
+    astar: astar,
+    Graph: Graph
+};
 
 });

benchmark/index.html

@@ -6,7 +6,6 @@
 
         <link rel="stylesheet" type="text/css" href="../demo/demo.css" />
         <script type='text/javascript' src='../demo/jquery-1.7.1.min.js'></script>
-        <script type='text/javascript' src='../graph.js'></script>
         <script type='text/javascript' src='../astar.js'></script>
         <script type='text/javascript' src='grid_150x150.js'></script>
         <script type='text/javascript' src='benchmark.js'></script>

demo/demo.js

@@ -10,6 +10,8 @@ window.log = function(){
 	}
 };
 
+var WALL = 0;
+var OPEN = 1;
 
 var generateRandom = function (width, height, wallFrequency) {
 
@@ -23,10 +25,10 @@ var generateRandom = function (width, height, wallFrequency) {
 
     		var isWall = Math.floor(Math.random()*(1/wallFrequency));
     		if(isWall == 0) {
-    			nodeRow.push(Graph.GraphNodeType.WALL);
+    			nodeRow.push(WALL);
     		}
     		else  {
-    			nodeRow.push(Graph.GraphNodeType.OPEN);
+    			nodeRow.push(OPEN);
     		}
     	}
     	nodes.push(nodeRow);
@@ -127,7 +129,7 @@ GraphSearch.prototype.initialize = function() {
 
     		var isWall = Math.floor(Math.random()*(1/self.opts.wallFrequency));
     		if(isWall == 0) {
-    			nodeRow.push(Graph.GraphNodeType.WALL);
+    			nodeRow.push(WALL);
     			$cell.addClass(css.wall);
     		}
     		else  {

demo/index.html

@@ -84,7 +84,6 @@ <h2>Demonstration</h2>
 	<div id="footer"></div>
 
 	<script type='text/javascript' src='jquery-1.7.1.min.js'></script>
-	<script type='text/javascript' src='../graph.js'></script>
 	<script type='text/javascript' src='../astar.js'></script>
 	<!--<script type='text/javascript' src='../dist/astar-concat.js'></script>-->
 	<script type='text/javascript' src='demo.js'></script>