Graph represented by single function

Author: jobh

a_star/a_star.py

@@ -56,13 +56,13 @@ def backtrack(self, current):
 
 Node = collections.namedtuple("Node", ["cost_estimate", "cost_so_far", "vertex", "came_from"])
 
-def a_star_search(graph, start, end, heuristic):
+def a_star_search(neighbors, start, end, heuristic):
     """
     Calculates the shortest path from start to end.
 
-    :param graph: A graph object. The graph object can be anything that implements the following method for a vertex of any comparable and hashable type V:
+    :param neighbors: The graph, represented by a function that takes a vertex of a comparable and hashable type V and returns its neighbors.
 
-        graph.neighbors( from_vertex:V ) : Iterable( (to_vertex:V,edge_cost:float), (to_vertex:V,edge_cost:float), ...)
+        neighbors( from_vertex:V ) : Iterable( (to_vertex:V,edge_cost:float), (to_vertex:V,edge_cost:float), ...)
 
     :param start: The starting vertex, as type V.
     :param end: The ending vertex, as type V.
@@ -83,11 +83,14 @@ def a_star_search(graph, start, end, heuristic):
         if current_node.vertex == end:
             return frontier
 
-        for neighbor, edge_cost in graph.neighbors( current_node.vertex ):
+        for neighbor, edge_cost in neighbors( current_node.vertex ):
 
-            new_cost = current_node.cost_so_far + edge_cost
+            cost_at_neighbor = current_node.cost_so_far + edge_cost
 
-            new_node = Node(new_cost + heuristic(neighbor, end), new_cost, neighbor, current_node.vertex)
+            new_node = Node(cost_at_neighbor + heuristic(neighbor, end),
+                            cost_at_neighbor,
+                            neighbor,
+                            current_node.vertex)
 
             frontier.insert(new_node)
 

examples/maze_solving_example.py

@@ -41,7 +41,7 @@ def from_id_width(point, width):
                                             (7, 3), (7, 4), (7, 5)]}
 
      # Call the A* algorithm and get the frontier
-     frontier = a_star.a_star_search(graph = graph, start=(1, 4), end=(7, 8), heuristic=manhattan_distance)
+     frontier = a_star.a_star_search(neighbors=graph.neighbors, start=(1, 4), end=(7, 8), heuristic=manhattan_distance)
      solution = list(frontier.backtrack((7,8)))
 
      # Print the results

tests/test_maze.py

@@ -19,7 +19,7 @@ def test_maze_1(self):
         start = (0,2)
 
         # Call the A* algorithm and get the frontier
-        frontier = a_star.a_star_search(graph = maze, start=start, end=end, heuristic=manhattan_distance)
+        frontier = a_star.a_star_search(neighbors=maze.neighbors, start=start, end=end, heuristic=manhattan_distance)
         solution = list(frontier.backtrack(end))
         self.assertTrue( solution == my_solution  )
 
@@ -38,7 +38,7 @@ def test_weights_instead_of_walls(self):
                        (2, 0), (1, 0), (0, 0), (0, 1),
                        (0, 2), (0, 3)]
         # Call the A* algorithm and get the frontier
-        frontier = a_star.a_star_search(graph = maze, start=start, end=end, heuristic=manhattan_distance)
+        frontier = a_star.a_star_search(neighbors=maze.neighbors, start=start, end=end, heuristic=manhattan_distance)
 
         solution = list(frontier.backtrack(end))