finish A* search

Author: joncai

.pydevproject

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?eclipse-pydev version="1.0"?><pydev_project>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property>
+</pydev_project>

Assign2/jon/assign2/A_star_search.py

@@ -2,16 +2,80 @@
 Created on Feb 16, 2014
 
 @author: Jon
-'''
-from jon.assign2.prover9 import Prover9
-
 
 
+pseudocode of A* search
+    A*-GRAPH-SEARCH(current,goals,allowed)
+    input: current, current position of the agent
+            goals, a list of goal squares
+            allowed, a list of save squares to go to
+            
+'''
+from prover9 import Prover9
 
+def a_star_batch(current,goals,allowed):
+    '''
+    @param current: current position of the agent
+    @param goals: a list of goal squares
+    @param allowed: a list of save squares to go to
+    @return: the nearest goal square and a plan to get to the goal square with shortest path
+    '''
+    nearest_goal = (float("inf"),None)
+    for goal in goals:
+        distance,plan = a_star(current,goal,allowed)
+        if distance < nearest_goal[0]:
+            nearest_goal = goal
+            shortest_path = (distance,plan)
+    return (nearest_goal, shortest_path)
 
+def a_star(current,goal,allowed):
+    '''
+    @param current: current position of the agent
+    @param goal: goal square of the path
+    @param allowed: a list of save squares to go to
+    @return: a plan to get to the goal square
+    '''
+    nodes = {}
+    for square in allowed:
+        nodes[square] = node(mdistance(square,goal));
+    nodes[current].g = 0
+    open = []
+    plan = []
+    f = nodes[current].g + nodes[current].h
+    heappush(open,(f, current))
+    while len(open) > 0:
+        p = heappop(open)
+        neighbors = allowed_neighbors(p,allowed)
+        for square in neighbors:
+            g = nodes[p].g + 1
+            h = mdistance(square,goal)
+            f_new = g + h
+            if square == goal:
+                nodes[goal].parent = p
+                plan.append(goal)
+                node_in_path = nodes[goal]
+                while node_in_path.parent != None:
+                    plan.append(node_in_path.parent)
+                    node_in_path = nodes[node_in_path.parent]
+                return (f_new, plan)
+            f_old = nodes[square].g + nodes[square].h
+            if f_new < f_old:
+                nodes[square].g = g
+                nodes[square].parent = p
+                if open.count((f_old,square)) > 0:
+                    open.remove((f_old,square))
+                heappush(open,(f_new, square))
+    return(-1,plan)
 
 
+class node(object):
+    def __init__(self,h=float("inf"),g=float("inf"),parent=None):
+        '''
+        
+        '''
+        self.g = g
+        self.h = h
+        self.parent = parent
 
-if __name__ == '__main__':
 
 

Assign2/jon/assign2/Utilities.py

@@ -0,0 +1,36 @@
+'''
+Created on Feb 14, 2014
+
+@author: Jon
+'''
+
+def allowed_neighbors(current, allowed):
+    '''
+    Generate neighbor square of current position from a list of allowed square
+    @param current: a tuple containing the coordinates of the current position of the agent
+    @param allowed: a tuple list of safe squares
+    @return: a tuple list of allowed neighbor square of the current position
+    '''
+    neighbors = []
+    currentx = current[0]
+    currenty = current[1]
+    for i in range(-1,3):
+        for j in range(-1,3):
+            temp = (currentx + i, currenty + j)
+            if allowed.count(temp) > 0:
+                neighbors.append(temp)
+    neighbors.remove(current)
+    return neighbors
+
+def mdistance(square, goal):
+    """
+    @return: Manhattan distance between given square and the goal
+    """
+    return abs(goal[0] - square[0]) + abs(goal[1] - square[1])
+
+if __name__ == '__main__':
+    current = (1, 1)
+    allowed = [(1, 1), (1, 2)]
+    neighbors = allowed_neighbors(current, allowed)
+    print(neighbors)
+    print(current)

Assign2/jon/assign2/hybrid_search.py

@@ -0,0 +1,60 @@
+'''
+Created on Feb 16, 2014
+
+@author: Jon
+
+
+pseudocode of a hybrid agent program for the wumpus world. 
+It uses a propositional knowledge base to infer the state 
+of the world, and a combination of problem-solving search 
+and domain-specific code to decide what actions to take.
+
+function HYBRID-WUMPUS-AGENT(percept) returns an action
+    inputs: percept, a list, [stench,breeze,glitter,bump,scream]
+    persistent: KB, a knowledge base, initially the atemporal "wumpus physics"
+                t, a counter, initially 0, indicating time
+                plan, an action sequence, initially empty
+    
+    TELL(KB, MAKE-PERCEPT-SENTENCE(percept, t))
+    TELL the KB the temporal "physics" sentences for time t
+    safe <- {[x,y] : ASK(KB, OK_xy^t)=true}
+    
+    if ASK(KB, Glitter^t) = true then
+        plan <- [Grab] + PLAN-ROUTE(current,{[1,1]},safe)+[Climb]
+    if plan is empty then
+        unvisited <- {[x,y] : ASK(KB,L_x,y^t') = false for all t'<=t}
+        plan <- PLAN-ROUTE(current,unvisited^safe,safe)
+    if plan is empty and ASK(KB,HaveArrow^t) = true then
+        possible_wumpus <- {[s,y] : ASK(KB,-W_x,y)=false}
+        plan <- PLAN-SHOT(current,possible_wumpus,safe)
+    if plan is empty then    // no choice but to take a risk
+        not_unsafe <- {[x,y] : ASK(KB,-OK_x,y^t)=false}
+        plan <- PLAN-ROUTE(current,unvisited^not_unsafe,safe)
+    if plan is empty then
+        plan <- PLAN-ROUTE(current,{[1,1]},safe) + [Climb]
+    action <- POP(plan)
+    TELL(KB,MAKE-ACTION-SENTENCE(action,t))
+    t <- t + 1
+    return action
+    
+function PLAN-ROUTE(current,goals,allowed) returns an action sequence
+    input: current, the agent's current position
+            goals, a set of squares; try to plan a route to one of them
+            allowed, a set of squares that can form part of the route
+    
+    problem <- ROUTE-PROBLEM(current,goals,allowed)
+    return A*-GRAPH-SEARCH(problem)
+    
+'''
+from prover9 import Prover9
+
+
+
+
+
+
+
+
+if __name__ == '__main__':
+    pass
+    

Assign2/jon/assign2/mainmodule.py

@@ -67,11 +67,7 @@ def buildmap(filename):
     fptr.close()
     return (wumpusmap, agent_location, goal)
 
-def mdistance(square, goal):
-    """
-    Return Manhattan distance between given square and the goal
-    """
-    return abs(goal[0] - square[0]) + abs(goal[1] - square[1])
+
 
 def initassumption():
     s = 'all x all y all a all b adjacent((x, y), (a,b)) <->'

Assign2/jon/assign2/test.py

@@ -3,7 +3,17 @@
 
 @author: Jon
 '''
-from jon.assign2.prover9 import Prover9
+from prover9 import Prover9
+
+
+
+class test1(object):
+    def __init__(self,a=0):
+        self.a = a
+    
+    def setA(self,a):
+        self.a = a
+
 
 if __name__ == '__main__':
 #     filename = 'F:\\Program Files (x86)\\Prover9-Mace4\\bin-win32\\prover9.exe'
@@ -34,7 +44,22 @@
 #     print(dict[0])
 #     dict[0].append('one')
 #     print(dict[0][0])
-    for i in range(1, 10):
-        if i == 4:
-            break
-        print(i)
+#     for i in range(1, 10):
+#         if i == 4:
+#             break
+#         print(i)
+#     a = [(1,2), (2,1)]
+#     print(a[0][1])
+#     b = test1(1)
+#     print(b.a)
+#     b.a = 10
+#     print(b.a)
+#     b.setA(100)
+#     print(b.a)
+    a = []
+    for i in range(1,10):
+        a.append(i)
+    for i in range(1,10):
+        print(a.pop())
+    
+    

Assign2/jon/assign2/wumpusmap.py

@@ -92,29 +92,29 @@ def shoot(self, x, y, tx, ty):
                         self.get_content(_x, y).remove('W')
                         for nx, ny in self.neighbor(_x, y):
                             self.get_content(nx, ny).remove('S')
-                        return 'Hit'
+                        return 'Scream'
             elif x < tx:
                 for _x in range(x+1, self._width):
                     if 'W' in self.get_content(_x, y):
                         self.get_content(_x, y).remove('W')
                         for nx, ny in self.neighbor(_x, y):
                             self.get_content(nx, ny).remove('S')
-                        return 'Hit'
+                        return 'Scream'
         if y != ty:
             if y > ty:
                 for _y in range(0, y):
                     if 'W' in self.get_content(x, _y):
                         self.get_content(x, _y).remove('W')
                         for nx, ny in self.neighbor(x, _y):
                             self.get_content(nx, ny).remove('S')
-                        return 'Hit'
+                        return 'Scream'
             elif y < ty:
                 for _y in range(y+1, self._height):
                     if 'W' in self.get_content(x, _y):
                         self.get_content(x, _y).remove('W')
                         for nx, ny in self.neighbor(x, _y):
                             self.get_content(nx, ny).remove('S')
-                        return 'Hit'
+                        return 'Scream'
         return 'Miss'