def depthFirstSearch(problem): print 'This is DFS' from searchAgents import direction_list from spade import pyxf import os """ Building the XSB PROLOG query """ myXsb = pyxf.xsb("/home/vishal/Downloads/xsb/XSB/bin/xsb") myXsb.load(os.getcwd() + '/maze.P') myXsb.load(os.getcwd() + '/dfs.P') q_result = myXsb.query("dfs(start,X)") result = q_result[0]['X'] result = result[1:] result = result[:-1] result = result.split(',') result.reverse() result = result[1:] result_list = list() result_list.append(direction_list[('start', result[0])]) """ Converting the list of actions returned by prolog into appropriate directions to be returned """ for x in range(len(result) - 1): result_list.append(direction_list[(result[x], result[x + 1])]) return result_list
def depthFirstSearch(problem): """ Search the deepest nodes in the search tree first [p 85]. Your search algorithm needs to return a list of actions that reaches the goal. Make sure to implement a graph search algorithm [Fig. 3.7]. To get started, you might want to try some of these simple commands to understand the search problem that is being passed in: print "Start:", problem.getStartState() print "Is the start a goal?", problem.isGoalState(problem.getStartState()) print "Start's successors:", problem.getSuccessors(problem.getStartState()) """ "*** YOUR CODE HERE ***" from spade import pyxf myXSB = pyxf.xsb("/home/raghu/ai/XSB/bin/xsb") myXSB.load("maze1.P") myXSB.load("dfs.P") result = myXSB.query("dfs(start,[],P).") #print result path = result[0]['P'] #print path #print type(path) path_no_null = path[6:-6] #print path_no_null path_list = path_no_null.split(",") #print path_list path_upper_list = [word[:1].upper() + word[1:] for word in path_list] #print path_upper_list return path_upper_list
def breadthFirstSearch(problem): "Search the shallowest nodes in the search tree first. [p 81]" "*** YOUR CODE HERE ***" from spade import pyxf myXSB = pyxf.xsb("/home/raghu/ai/XSB/bin/xsb") myXSB.load("maze1.P") myXSB.load("bfs.P") result1 = myXSB.query("bfs([[start]],P).") #print result1 path = result1[0]['P'] #print path #print type(path) path_no_null = path[6:-12] #print path_no_null path_list = path_no_null.split(",") #print path_list path_dir = path_list[1::2] #print "path_dir " + str(path_dir) path_upper_list = [word[:1].upper() + word[1:] for word in path_dir] #print path_upper_list path_reverse = path_upper_list[::-1] print path_reverse return path_reverse
def aStarSearch(problem, heuristic=nullHeuristic): "Search the node that has the lowest combined cost and heuristic first." "*** YOUR CODE HERE ***" from spade import pyxf myXSB = pyxf.xsb("/home/raghu/ai/XSB/bin/xsb") myXSB.load("maze_astar.P") myXSB.load("astar2.P") result1 = myXSB.query("astar1([[start]],P).") #print result1 path = result1[0]['P'] print path #print type(path) #path_no_null = path[:-12] print path path_list = path.split(",") print path_list path_dir = path_list[1::3] print "path_dir " + str(path_dir) path_no_null = path_dir[:-1] path_upper_list = [word[:1].upper() + word[1:] for word in path_no_null] #print path_upper_list path_reverse = path_upper_list[::-1] #print path_reverse return path_reverse util.raiseNotDefined()
def breadthFirstSearch(problem): "Search the shallowest nodes in the search tree first. [p 81]" "*** YOUR CODE HERE ***" startTime = time.clock() mazeFilePath = './maze.P' foodList = getFoodStatus(mazeFilePath) permutationList = getPermutations(foodList) # get all the 24 permutations of food list file = open(mazeFilePath) lines = file.readlines() pathLists = [] xsb = pyxf.xsb('/Users/zephyrYin/Documents/tools/XSB/bin/xsb') for i in range(len(permutationList)): reviseMazeFile(mazeFilePath, lines, permutationList[i]) xsb.load(mazeFilePath) xsb.load('./bfs.P') result = xsb.query('solve(F).') fullPath = result[0]['F'] tempList = fullPath[1:-1].split(',') pathList = [int(x) for x in tempList] print pathList pathLists.append(pathList) shortestPath = getShortest(pathLists) # find a shortest path print 'time cost:' print time.clock() - startTime return path2Action(shortestPath)
def depthFirstSearch(problem): """ Search the deepest nodes in the search tree first [p 85]. Your search algorithm needs to return a list of actions that reaches the goal. Make sure to implement a graph search algorithm [Fig. 3.7]. To get started, you might want to try some of these simple commands to understand the search problem that is being passed in: print "Start:", problem.getStartState() print "Is the start a goal?", problem.isGoalState(problem.getStartState()) print "Start's successors:", problem.getSuccessors(problem.getStartState()) """ "*** YOUR CODE HERE ***" xsb = pyxf.xsb('/Users/zephyrYin/Documents/tools/XSB/bin/xsb') xsb.load('./maze.P') xsb.load('./dfs.P') startTime = time.clock() result = xsb.query('solve(X).') print time.clock() - startTime print result path = result[0]['X'] tempList = path[1:-1].split(',') pathList = [int(x) for x in tempList] return path2Action(pathList)
def breadthFirstSearch(problem): "Search the shallowest nodes in the search tree first. [p 81]" "*** YOUR CODE HERE ***" myXsb= pyxf.xsb("/Users/muthukumarsuresh/Downloads/XSB/bin/xsb") myXsb.load('mazeeee.P') myXsb.load('bfs2.P') time.sleep(5) result = myXsb.query('planPathbfs(X)') while(result == False): result = myXsb.query('planPathbfs(X)') returnstr = result[0]['X'] returnstr = returnstr[1:len(returnstr)-1] returnList = returnstr.split(',') s =Directions.SOUTH w = Directions.WEST e = Directions.EAST n = Directions.NORTH retList = [] for element in returnList: if element == 's': retList.append(s) if element == 'e': retList.append(e) if element == 'w': retList.append(w) if element == 'n': retList.append(n) # returnList = returnList.reverse() return retList
def aStarSearch(problem, heuristic=nullHeuristic): "Search the node that has the lowest combined cost and heuristic first." from game import Directions from spade import pyxf import time # Creates an instance and makes a query to XSB using SPADE interface myXsb = pyxf.xsb('C:/XSB/config/x86-pc-windows/bin/xsb.exe') myXsb.load('D:/Tmp/maze.P') myXsb.load('D:/Tmp/astar.P') # print ('Starting to search!') time.sleep(2) result = myXsb.query("astar(start,finish,Direction).") finalDirections = [] res = [] # Choose the shortest path from all results available. # XSB is unstable from time to time, so we print something when it goes wrong. # print ('Retrieving results!') # print result # Choose the shortest path from all results available. if isinstance(result,bool): print "Catches XSB Problem!" else: cnt = 99999 for dict in result: if len(dict['Direction']) < cnt: cnt = len(dict['Direction']) res = dict['Direction'] res = res.split(",") print res break # print ('Final processing') # Perform final step to return real directions to Pacman for direction in res: if direction=="s": finalDirections.append(Directions.SOUTH) if direction=="w": finalDirections.append(Directions.WEST) if direction=="n": finalDirections.append(Directions.NORTH) if direction=="e": finalDirections.append(Directions.EAST) print finalDirections return finalDirections # We didn't find a solution, such assert # calls generalErrorDefined() and exit util.generalErrorDefined()
def depthFirstSearch(problem): """ Search the deepest nodes in the search tree first [p 85]. Your search algorithm needs to return a list of actions that reaches the goal. Make sure to implement a graph search algorithm [Fig. 3.7]. To get started, you might want to try some of these simple commands to understand the search problem that is being passed in: print "Start:", problem.getStartState() print "Is the start a goal?", problem.isGoalState(problem.getStartState()) print "Start's successors:", problem.getSuccessors(problem.getStartState()) """ "*** YOUR CODE HERE ***" f = open('maze.P', 'r') for line in f: if "goal" in line: g = line last = line print "lastline", last print "goal", g f.close() refine = last.split("(") refine2 = refine[1].split(")") startPac = refine2[0] myXSB = pyxf.xsb("/home/nikhil/Downloads/XSB/bin/xsb") myXSB.load("maze.P") myXSB.load("dfs.P") result = myXSB.query("depthFirstSearch(" + startPac + ", Path,Direction).") print result x = result[0]['Path'] f1 = x.split("[") neededDir = f1[1].split(",") gg = g.split("(") g2 = gg[1].split(")") ls = [] f2 = open('maze.P', 'r') for i in xrange(len(neededDir)): f2 = open('maze.P', 'r') for line1 in f2: if i + 1 < len(neededDir): stri = neededDir[i] + "," + neededDir[i + 1] if i + 1 < len(neededDir) and stri in line1: j = line1.split(",") k = j[2].split(").") print line1, neededDir[i], neededDir[i + 1], k[0] if g2[0] == neededDir[i + 1]: exit ls.append(str(k[0])) continue f2.close() return ls """for x in xrange(len(array)):
def breadthFirstSearch(problem): "Search the shallowest nodes in the search tree first. [p 81]" "*** YOUR CODE HERE ***" f = open('maze.P','r') for line in f: pass last = line refine = last.split("(") refine2 = refine[1].split(")") startPac = refine2[0] myXSB = pyxf.xsb("/home/nikhil/Downloads/XSB/bin/xsb") myXSB.load("maze.P") myXSB.load("bfs.P") if sys.argv=="CornersProblem": myXSB = pyxf.xsb("/home/nikhil/Downloads/XSB/bin/xsb") myXSB.load("maze.P") myXSB.load("CornersProblem.P") result = myXSB.query("breadthFirstSearch("+startPac+",Path,Direction).") print result else: result = myXSB.query("breadthFirstSearch("+startPac+",Path,Direction).") print result
def depthFirstSearch(problem): """ Search the deepest nodes in the search tree first [p 85]. Your search algorithm needs to return a list of actions that reaches the goal. Make sure to implement a graph search algorithm [Fig. 3.7]. To get started, you might want to try some of these simple commands to understand the search problem that is being passed in: print "Start:", problem.getStartState() print "Is the start a goal?", problem.isGoalState(problem.getStartState()) print "Start's successors:", problem.getSuccessors(problem.getStartState()) """ "*** YOUR CODE HERE ***" """ This function makes a generic implementation of DFS.Following variables are mainly used - 1. state_stack - It is the stack class imported from util class. It keeps track of the nodes to be expanded and pops the nodes depth first. 2. parents - It is used to backtrack the path of the node after it reaches the goal. 3. direction - This is also used to backtrack the path of the node once it reaches goal. It gives the exact direction to trace back. 4. visited - This keeps track of visited nodes so as to avoid a deadlock. 5. path - This is used to return the path to the main function """ from game import Directions from spade import pyxf south = Directions.SOUTH west = Directions.WEST north = Directions.NORTH east = Directions.EAST myXSB = pyxf.xsb("/home/dushyant/Downloads/XSB/bin/xsb") myXSB.load("maze.P") myXSB.load("dfs.P") result = myXSB.query("connected(start, A,D).") print result result1 = myXSB.query("dfs(start,[],P,D).") print result1 #print result1[0]['P'] #print result1[0]['D'] #print result1[0].values path = result1[0]['D'] #print path, len(path) path2 = path[1:-6] #print path2 import re path3 = re.split(',',path2) #print path3 path4 = [word[:1].upper() + word[1:] for word in path3] print path4 print "Sending the path" return path4
def depthFirstSearch(problem): from spade import pyxf myXsb = pyxf.xsb("/home/prasidh/Downloads/XSB/bin/xsb") myXsb.load("/home/prasidh/Downloads/search-source1/search/dfs.P") myXsb.load("/home/prasidh/Downloads/search-source1/search/maze.P") param = "dfs1(c" + str(problem.startState[0]) + "_" + str(problem.startState[1]) + ",goal,Solution)" # param calls the prolog query that returns the dfs path result1 = myXsb.query(param) # print result1 x = [] x.append(result1[0]) xy1 = [0] xy2 = [0] moves = [] # Parse the values obtained from the dfs.P file and return the directions for i in x: # print i x = i.values() # print x z = x[0] # print z t = z.replace("[", "") t = t.replace("]", "") t = t.replace("c", "") t = t.split(",") # print t for i in t: i = i.split("_") xy1.append(i[0]) xy2.append(i[1]) # print i[0] # print i[1] # print xy1 # print xy2 # print xy1 # print xy2 length = len(xy1) - 1 for i in range(1, length): if int(xy1[i + 1]) - int(xy1[i]) == 1: moves.append("East") if int(xy2[i + 1]) - int(xy2[i]) == 1: moves.append("North") if int(xy1[i + 1]) - int(xy1[i]) == -1: moves.append("West") if int(xy2[i + 1]) - int(xy2[i]) == -1: moves.append("South") return moves
def breadthFirstSearch(problem): "Search the shallowest nodes in the search tree first. [p 81]" "*** YOUR CODE HERE ***" f = open('maze.P', 'r') for line in f: pass last = line refine = last.split("(") refine2 = refine[1].split(")") startPac = refine2[0] myXSB = pyxf.xsb("/home/nikhil/Downloads/XSB/bin/xsb") myXSB.load("maze.P") myXSB.load("bfs.P") if sys.argv == "CornersProblem": myXSB = pyxf.xsb("/home/nikhil/Downloads/XSB/bin/xsb") myXSB.load("maze.P") myXSB.load("CornersProblem.P") result = myXSB.query("breadthFirstSearch(" + startPac + ",Path,Direction).") print result else: result = myXSB.query("breadthFirstSearch(" + startPac + ",Path,Direction).") print result
def aStarSearch(problem, heuristic=nullHeuristic): "Search the node that has the lowest combined cost and heuristic first." "*** YOUR CODE HERE ***" f = open('maze.P','r') for line in f: pass last = line refine = last.split("(") refine2 = refine[1].split(")") startPac = refine2[0] myXSB = pyxf.xsb("/home/nikhil/Downloads/XSB/bin/xsb") myXSB.load("maze.P") myXSB.load("AStar.P") result = myXSB.query("AStarAlgorithm("+startPac+",Path,Direction).") print result
def aStarSearch(problem, heuristic=nullHeuristic): "Search the node that has the lowest combined cost and heuristic first." "*** YOUR CODE HERE ***" f = open('maze.P', 'r') for line in f: pass last = line refine = last.split("(") refine2 = refine[1].split(")") startPac = refine2[0] myXSB = pyxf.xsb("/home/nikhil/Downloads/XSB/bin/xsb") myXSB.load("maze.P") myXSB.load("AStar.P") result = myXSB.query("AStarAlgorithm(" + startPac + ",Path,Direction).") print result
def aStarSearch(problem, heuristic=nullHeuristic): "Search the node that has the lowest combined cost and heuristic first." "*** YOUR CODE HERE ***" mazeFile = 'maze.P' heuFile = 'heu.P' createHeuFile(problem, heuristic, heuFile) xsb = pyxf.xsb('/Users/zephyrYin/Documents/tools/XSB/bin/xsb') xsb.load('./maze.P') xsb.load('./heu.P') xsb.load('./astar.P') startTime = time.clock() result = xsb.query('solve(P/C).') print time.clock() - startTime path = result[0]['P'] tempList = path[1:-1].split(',') pathList = [int(x) for x in tempList] print pathList return path2Action(pathList)
def depthFirstSearch(problem): """ Search the deepest nodes in the search tree first [p 85]. Your search algorithm needs to return a list of actions that reaches the goal. Make sure to implement a graph search algorithm [Fig. 3.7]. To get started, you might want to try some of these simple commands to understand the search problem that is being passed in: print "Start:", problem.getStartState() print "Is the start a goal?", problem.isGoalState(problem.getStartState()) print "Start's successors:", problem.getSuccessors(problem.getStartState()) """ "*** YOUR CODE HERE ***" myXsb= pyxf.xsb("/Users/muthukumarsuresh/Downloads/XSB/bin/xsb") myXsb.load('mazeeee.P') myXsb.load('dfs2.P') time.sleep(5) result = myXsb.query('planPath(X)') while(result == False): result = myXsb.query('planPath(X)') returnstr = result[0]['X'] returnstr = returnstr[1:len(returnstr)-1] returnList = returnstr.split(',') s =Directions.SOUTH w = Directions.WEST e = Directions.EAST n = Directions.NORTH retList = [] for element in returnList: if element == 's': retList.append(s) if element == 'e': retList.append(e) if element == 'w': retList.append(w) if element == 'n': retList.append(n) # returnList = returnList.reverse() return retList
def breadthFirstSearch(problem): "Search the shallowest nodes in the search tree first. [p 81]" "*** YOUR CODE HERE ***" """ This function makes a generic implementation of DFS.Following variables are mainly used - 1. state_queue - It is the queue class imported from util class. It keeps track of the nodes to be expanded and pops the nodes breadth first. 2. parents - It is used to backtrack the path of the node after it reaches the goal. 3. direction - This is also used to backtrack the path of the node once it reaches goal. It gives the exact direction to trace back. 4. visited - This keeps track of visited nodes so as to avoid a deadlock. 5. path - This is used to return the path to the main function """ from game import Directions from spade import pyxf south = Directions.SOUTH west = Directions.WEST north = Directions.NORTH east = Directions.EAST myXSB = pyxf.xsb("/home/dushyant/Downloads/XSB/bin/xsb") myXSB.load("maze.P") myXSB.load("bfs.P") result = myXSB.query("connected(start, A,D).") print result result1 = myXSB.query("solve(start,D).") print result1 print result1[0]['D'] path = result1[0]['D'] print path, len(path) path2 = path[1:-7] print path2 import re path3 = re.split(',',path2) print path3 path4 = [word[:1].upper() + word[1:] for word in path3] print path4 path5 = path4[1:][::2] path6 = path5[::-1] print path5, path6 print path[0] print "Sending the path" return path6
def aStarSearch(problem, heuristic=nullHeuristic): "Search the node that has the lowest combined cost and heuristic first." "*** YOUR CODE HERE ***" """ This function makes a generic implementation of UCS.Following variables are mainly used - 1. state_queue - It is the priority queue class imported from util class. It keeps track of the nodes to be expanded and pops the nodes in order of their priotiy. 2. parents - It is used to backtrack the path of the node after it reaches the goal. 3. direction - This is also used to backtrack the path of the node once it reaches goal. It gives the exact direction to trace back. 4. visited - This keeps track of visited nodes so as to avoid a deadlock. 5. cost - this keeps track of the cost of the nodes and adds them to the child if needed. 6. path - This is used to return the path to the main function """ from game import Directions from spade import pyxf south = Directions.SOUTH west = Directions.WEST north = Directions.NORTH east = Directions.EAST myXSB = pyxf.xsb("/home/dushyant/Downloads/XSB/bin/xsb") myXSB.load("mazeastar.P") myXSB.load("astar.P") #result = myXSB.query("connected(start#A#D#E#F).") result1 = myXSB.query("solve(start, D).") print "Result is -" print result1 path = result1[0]['D'] path2 = path[1:-1] import re path3 = re.split(',',path2) final_path = [] i=1 for it in path3: temp = re.split('#',it.replace(" ","")) final_path.append(temp[1]) del final_path[-1] path4 = [word[:1].upper() + word[1:] for word in final_path] path6 = path4[::-1] print "Sending the path" return path6
def aStarSearch(problem, heuristic=nullHeuristic): "Search the node that has the lowest combined cost and heuristic first." "*** YOUR CODE HERE ***" myXsb= pyxf.xsb("/Users/muthukumarsuresh/Downloads/XSB/bin/xsb") myXsb.load('mazeeee.P') myXsb.load('heuristic.P') myXsb.load('astar.P') time.sleep(5) result = myXsb.query('planPathbfs(X)') if result is False: print(result) result = myXsb.query('planPathbfs(X)') print("hello", result) returnstr = result[0]['X'] returnstr = returnstr[1:len(returnstr)-1] returnList = returnstr.split(',') s =Directions.SOUTH w = Directions.WEST e = Directions.EAST n = Directions.NORTH retList = [] for element in returnList: if element == 's': retList.append(s) if element == 'e': retList.append(e) if element == 'w': retList.append(w) if element == 'n': retList.append(n) print retList # returnList = returnList.reverse() return retList
def aStarSearch(problem, heuristic=nullHeuristic): print "***************************astarSearch Start***************************" south = Directions.SOUTH west = Directions.WEST north = Directions.NORTH east = Directions.EAST myXSB = pyxf.xsb("/home/gp/Downloads/XSB/bin/xsb") myXSB.load("mazeastar.P") myXSB.load("astar.P") result1 = myXSB.query("astar_search(start, D).") path = result1[0]['D'] path2 = path[1:-1] path3 = re.split(',',path2) final_path = [] i=1 for it in path3: temp = re.split('#',it.replace(" ","")) final_path.append(temp[1]) del final_path[-1] path4 = [word[:1].upper() + word[1:] for word in final_path] path6 = path4[::-1] print "***************************astarSearch End***************************" return path6
def aStarSearch(problem, heuristic=nullHeuristic): print "***************************astarSearch Start***************************" south = Directions.SOUTH west = Directions.WEST north = Directions.NORTH east = Directions.EAST myXSB = pyxf.xsb("/home/gp/Downloads/XSB/bin/xsb") myXSB.load("mazeastar.P") myXSB.load("astar.P") result1 = myXSB.query("astar_search(start, D).") path = result1[0]['D'] path2 = path[1:-1] path3 = re.split(',', path2) final_path = [] i = 1 for it in path3: temp = re.split('#', it.replace(" ", "")) final_path.append(temp[1]) del final_path[-1] path4 = [word[:1].upper() + word[1:] for word in final_path] path6 = path4[::-1] print "***************************astarSearch End***************************" return path6
def aStarSearch(problem, heuristic=nullHeuristic): print 'This is A*!' from game import Directions """ A separate file consisting of heuristic values based on argument is populated for future use by the query. """ f = open('astar_heuristic.P', 'w') sx, sy = problem.startState start = sx + (problem.walls.width - 2) * (problem.walls.height - 2 - sy) gx, gy = problem.goal goal = gx + (problem.walls.width - 2) * (problem.walls.height - 2 - gy) for x in range(problem.walls.width): for y in range(problem.walls.height): """ Avoiding the boundary frames """ if x != 0 and y != 0 and x != problem.walls.width - 1 and y != problem.walls.height - 1: if problem.walls[x][y] is False: curr = x + (problem.walls.width - 2) * (problem.walls.height - 2 - y) if curr == goal: u = 'finish' elif curr == start: u = 'start' else: u = 'c' + str(curr) v = '' temp = 0 """ Processing the left of the node """ if problem.walls[x - 1][y] is False: temp = x - 1 + (problem.walls.width - 2) * (problem.walls.height - 2 - y) if temp == goal: v = 'finish' elif temp == start: v = 'start' else: v = 'c' + str(temp) """ Adding the manhattan heuristic value to the clause file. """ man_d = heuristic((x - 1, y), problem, {}) f.write('manhattan_distance_heuristic(' + v + ',' + str(man_d) + ').\n') """ Processing the right of the node """ if problem.walls[x + 1][y] is False: temp = x + 1 + (problem.walls.width - 2) * (problem.walls.height - 2 - y) if temp == goal: v = 'finish' elif temp == start: v = 'start' else: v = 'c' + str(temp) """ Adding the manhattan heuristic value to the clause file. """ man_d = heuristic((x + 1, y), problem, {}) f.write('manhattan_distance_heuristic(' + v + ',' + str(man_d) + ').\n') """ Processing left of the node """ if problem.walls[x][y - 1] is False: temp = x + (problem.walls.width - 2) * (problem.walls.height - 2 - (y - 1)) if temp == goal: v = 'finish' elif temp == start: v = 'start' else: v = 'c' + str(temp) """ Adding the manhattan heuristic value to the clause file. """ man_d = heuristic((x, y - 1), problem, {}) f.write('manhattan_distance_heuristic(' + v + ',' + str(man_d) + ').\n') """ Processing right of the node """ if problem.walls[x][y + 1] is False: temp = x + (problem.walls.width - 2) * (problem.walls.height - 2 - (y + 1)) if temp == goal: v = 'finish' elif temp == start: v = 'start' else: v = 'c' + str(temp) """ Adding the manhattan heuristic value to the clause file. """ man_d = heuristic((x, y + 1), problem, {}) f.write('manhattan_distance_heuristic(' + v + ',' + str(man_d) + ').\n') f.close() from searchAgents import direction_list from spade import pyxf import os """ Building the XSB PROLOG Query """ myXsb = pyxf.xsb("/home/vishal/Downloads/xsb/XSB/bin/xsb") myXsb.load(os.getcwd() + '/maze.P') myXsb.load(os.getcwd() + '/astar.P') myXsb.load(os.getcwd() + '/astar_heuristic.P') q_result = myXsb.query("astar(start,X)") result = q_result[0]['X'] result = result[1:] result = result[:-1] result = result.split(',') result = result[1:] result_list = list() result_list.append(direction_list[('start', result[0])]) """ Converting the list of actions returned by prolog into appropriate directions to be returned """ for x in range(len(result) - 1): result_list.append(direction_list[(result[x], result[x + 1])]) return result_list
def depthFirstSearch(problem): """ Search the deepest nodes in the search tree first [p 85]. Your search algorithm needs to return a list of actions that reaches the goal. Make sure to implement a graph search algorithm [Fig. 3.7]. To get started, you might want to try some of these simple commands to understand the search problem that is being passed in: print "Start:", problem.getStartState() print "Is the start a goal?", problem.isGoalState(problem.getStartState()) print "Start's successors:", problem.getSuccessors(problem.getStartState()) """ from game import Directions from spade import pyxf import time # Creates an instance and makes a query to XSB using SPADE interface myXsb = pyxf.xsb('C:/XSB/config/x86-pc-windows/bin/xsb.exe') myXsb.load('D:/Tmp/maze.P') myXsb.load('D:/Tmp/dfs.P') # print ('Starting to search!') time.sleep(2) result = myXsb.query("dfs(finish,[start],Direction).") finalDirections = [] res = [] # print ('Retrieving results!') # Choose the shortest path from all results available. # XSB is unstable from time to time, so we print something when it goes wrong. if isinstance(result,bool): print "Catches XSB Problem!" else: cnt = 99999 for dict in result: if len(dict['Direction']) < cnt: cnt = len(dict['Direction']) res = dict['Direction'] res = res.split(",") print res break # print ('Final processing') # Final step to return real direction to Pacman for direction in res: if direction=="s": finalDirections.append(Directions.SOUTH) if direction=="w": finalDirections.append(Directions.WEST) if direction=="n": finalDirections.append(Directions.NORTH) if direction=="e": finalDirections.append(Directions.EAST) print finalDirections return finalDirections # We didn't find a solution, such assert # calls generalErrorDefined() and exit util.generalErrorDefined()
def breadthFirstSearch(problem): print 'This is BFS!' if problem.problemType is 'Position': from searchAgents import direction_list from spade import pyxf import os """ Building the XSB PROLOG query """ myXsb = pyxf.xsb("/home/vishal/Downloads/xsb/XSB/bin/xsb") myXsb.load(os.getcwd() + '/maze.P') myXsb.load(os.getcwd() + '/bfs.P') q_result = myXsb.query("bfs(start,X)") result = q_result[0]['X'] result = result[1:] result = result[:-1] result = result.split(',') result.reverse() result = result[1:] result_list = list() result_list.append(direction_list[('start', result[0])]) """ Converting the list of actions returned by prolog into appropriate directions to be returned """ for x in range(len(result) - 1): result_list.append(direction_list[(result[x], result[x + 1])]) return result_list elif problem.problemType is 'Corners': from searchAgents import direction_list from spade import pyxf import os merged_result = [] """ Building the XSB PROLOG query """ myXsb = pyxf.xsb("/home/vishal/Downloads/xsb/XSB/bin/xsb") myXsb.load(os.getcwd() + '/maze.P') myXsb.load(os.getcwd() + '/bfs.P') myXsb.load(os.getcwd() + '/corner4.P') q_result = myXsb.query("bfs(start,X)") result = q_result[0]['X'] result = result[1:] result = result[:-1] result = result.split(',') merged_result.extend(result[1:]) """ Building the XSB PROLOG query """ myXsb = pyxf.xsb("/home/vishal/Downloads/xsb/XSB/bin/xsb") myXsb.load(os.getcwd() + '/maze.P') myXsb.load(os.getcwd() + '/bfs.P') myXsb.load(os.getcwd() + '/corner3.P') q_result = myXsb.query("bfs(" + str(result[0]) + ",X)") result = q_result[0]['X'] result = result[1:] result = result[:-1] result = result.split(',') temp = result[1:] temp.extend(merged_result) merged_result = temp """ Building the XSB PROLOG query """ myXsb = pyxf.xsb("/home/vishal/Downloads/xsb/XSB/bin/xsb") myXsb.load(os.getcwd() + '/maze.P') myXsb.load(os.getcwd() + '/bfs.P') myXsb.load(os.getcwd() + '/corner2.P') q_result = myXsb.query("bfs(" + str(result[0]) + ",X)") result = q_result[0]['X'] result = result[1:] result = result[:-1] result = result.split(',') temp = result[1:] temp.extend(merged_result) merged_result = temp """ Building the XSB PROLOG query """ myXsb = pyxf.xsb("/home/vishal/Downloads/xsb/XSB/bin/xsb") myXsb.load(os.getcwd() + '/maze.P') myXsb.load(os.getcwd() + '/bfs.P') myXsb.load(os.getcwd() + '/corner1.P') q_result = myXsb.query("bfs(" + str(result[0]) + ",X)") result = q_result[0]['X'] result = result[1:] result = result[:-1] result = result.split(',') temp = result temp.extend(merged_result) merged_result = temp result = merged_result result.reverse() result = result[1:] result_list = list() result_list.append(direction_list[('start', result[0])]) """ Converting the list of actions returned by prolog into appropriate directions to be returned """ for x in range(len(result) - 1): result_list.append(direction_list[(result[x], result[x + 1])]) return result_list
from spade import pyxf myXsb= pyxf.xsb("/Users/muthukumarsuresh/Downloads/XSB/bin/xsb") myXsb.load('program.P') myXsb.load('program2.P') result = myXsb.query('q(X)') print(result)
def aStarSearch(problem, heuristic=nullHeuristic): "Search the node that has the lowest combined cost and heuristic first." "*** YOUR CODE HERE ***" #get map's outline w = problem.walls.width h = problem.walls.height sx, sy = problem.getStartState() goalx,goaly = problem.goal #define the notion to each position in map: (1,1) --> cell01 notion = [] t=0 for i in range(0,w): notion.append([]) for i in range(0,w): for j in range(0,h): notion[i].append(t) t=t+1 #prolog file contains connection between cell fname = 'connection.P' from game import Directions dict ={} with open(fname, 'w') as fout: fout.write('\n') for i in range(0,w): for j in range(0,h): if not problem.walls[i][j]: if i+1 <= w : if not problem.walls[i+1][j]: fout.write('connect(cell'+ notion[i][j].__str__() +',cell'+ notion[i+1][j].__str__()+ ').') fout.write('\n') word = 'cell'+ notion[i][j].__str__()+'cell'+ notion[i+1][j].__str__() dict[word] = Directions.EAST #dictionary translating from strings "cellXcellY" to the real direction in game if i-1 >= 0 : if not problem.walls[i-1][j]: fout.write('connect(cell'+ notion[i][j].__str__() +',cell'+ notion[i-1][j].__str__()+ ').') fout.write('\n') word = 'cell'+ notion[i][j].__str__()+'cell'+ notion[i-1][j].__str__() dict[word] = Directions.WEST if j+1 <= h : if not problem.walls[i][j+1]: fout.write('connect(cell'+ notion[i][j].__str__() +',cell'+ notion[i][j+1].__str__()+ ').') fout.write('\n') word = 'cell'+ notion[i][j].__str__()+'cell'+ notion[i][j+1].__str__() dict[word] = Directions.NORTH if j-1 >= 0 : if not problem.walls[i][j-1]: fout.write('connect(cell'+ notion[i][j].__str__() +',cell'+ notion[i][j-1].__str__()+ ').') fout.write('\n') word = 'cell'+ notion[i][j].__str__()+'cell'+ notion[i][j-1].__str__() dict[word] = Directions.SOUTH fout.close() global hname hname = 'heuristicvalues.P' with open(hname, 'w') as fout: for i in range(0,w): for j in range(0,h): if not problem.walls[i][j]: distant=abs(i - goalx) + abs(j - goaly) fout.write('h(cell'+ notion[i][j].__str__()+ ','+ distant.__str__() + ').') fout.write('\n') fout.close() #load prolog fact from spade import pyxf brain = pyxf.xsb('/home/hieule/Downloads/XSB/bin/xsb') brain.load(fname) brain.load(hname) brain.load('astar.P') goal = 'cell'+notion[goalx][goaly].__str__() start = 'cell'+notion[sx][sy].__str__() #feedback = brain.query('dfs('+start+',['+start+'],'+goal+',X).') feedback = brain.query('solve2('+start+','+goal+',X).') path=feedback[0].__str__() path = path[8:len(path)-3] path = path.split(',', 9999) #reverse the path path= path[::-1] #translate the path using dictionary path_translated=[] for i in range(0,len(path)-1): path_translated.append(dict[path[i]+path[i+1]]) return path_translated
def breadthFirstSearch(problem): from spade import pyxf myXsb = pyxf.xsb("/home/prasidh/Downloads/XSB/bin/xsb") myXsb.load("/home/prasidh/Downloads/search-source1/search/bfs2.P") myXsb.load("/home/prasidh/Downloads/search-source1/search/maze.P") param = "bfs(c" + str(problem.startState[0]) + "_" + str(problem.startState[1]) + ",Solution)." # param calls the prolog query that returns the bfs path result1 = myXsb.query(param) # print result1 length = len(result1) # print length list = [] m = 0 y = "inf" minlist = 0 # Find the shortest path that bfs returns for i in range(0, length): list.append(result1[i]) # print list for j in list: l = j.values() # print l z = l[0] m = z.count("_") # print m if m < y: y = m minlist = i # print index # print list list = [] x = [] x.append(result1[minlist]) xy1 = [0] xy2 = [0] moves = [] # Parse the solution to return the moves for Breadth First Search for i in x: # print i x = i.values() # print x z = x[0] # print z t = z.replace("[", "") t = t.replace("]", "") t = t.replace("c", "") t = t.split(",") # print t for i in t: i = i.split("_") xy1.append(i[0]) xy2.append(i[1]) # print i[0] # print i[1] # print xy1 # print xy2 # print xy1 # print xy2 length = len(xy1) - 1 for i in range(1, length): if int(xy1[i + 1]) - int(xy1[i]) == 1: moves.append("West") if int(xy2[i + 1]) - int(xy2[i]) == 1: moves.append("South") if int(xy1[i + 1]) - int(xy1[i]) == -1: moves.append("East") if int(xy2[i + 1]) - int(xy2[i]) == -1: moves.append("North") # print int(xy2[i+1])-int(xy2[i]) # print moves moves.reverse() # print moves return moves
from spade import pyxf #print spade.__file__ myXsb = pyxf.xsb('/home/adrian/Applications/XSB/bin/xsb') myXsb.load("/home/adrian/project/cse537-project/project_4/search/prolog_scripts/maze.P") myXsb.load("/home/adrian/project/cse537-project/project_4/search/prolog_scripts/bfs.P") #result = myXsb.query("member(cell23,[cell23|start]).") #print result result = myXsb.query("append([a,b,c],[1,2,3],[a,b,c,1,2,3]).") print result
def breadthFirstSearch(problem): print 'This is BFS!' if problem.problemType is 'Position': from searchAgents import direction_list from spade import pyxf import os """ Building the XSB PROLOG query """ myXsb = pyxf.xsb("/home/vishal/Downloads/xsb/XSB/bin/xsb") myXsb.load(os.getcwd() + '/maze.P') myXsb.load(os.getcwd() + '/bfs.P') q_result = myXsb.query("bfs(start,X)") result = q_result[0]['X'] result = result[1:] result = result[:-1] result = result.split(',') result.reverse() result = result[1:] result_list = list() result_list.append(direction_list[('start', result[0])]) """ Converting the list of actions returned by prolog into appropriate directions to be returned """ for x in range(len(result) - 1): result_list.append(direction_list[(result[x], result[x + 1])]) return result_list elif problem.problemType is 'Corners': from searchAgents import direction_list from spade import pyxf import os merged_result = [] """ Building the XSB PROLOG query """ myXsb = pyxf.xsb("/home/vishal/Downloads/xsb/XSB/bin/xsb") myXsb.load(os.getcwd() + '/maze.P') myXsb.load(os.getcwd() + '/bfs.P') myXsb.load(os.getcwd() + '/corner4.P') q_result = myXsb.query("bfs(start,X)") result = q_result[0]['X'] result = result[1:] result = result[:-1] result = result.split(',') merged_result.extend(result[1:]) """ Building the XSB PROLOG query """ myXsb = pyxf.xsb("/home/vishal/Downloads/xsb/XSB/bin/xsb") myXsb.load(os.getcwd() + '/maze.P') myXsb.load(os.getcwd() + '/bfs.P') myXsb.load(os.getcwd() + '/corner3.P') q_result = myXsb.query("bfs("+str(result[0])+",X)") result = q_result[0]['X'] result = result[1:] result = result[:-1] result = result.split(',') temp = result[1:] temp.extend(merged_result) merged_result = temp """ Building the XSB PROLOG query """ myXsb = pyxf.xsb("/home/vishal/Downloads/xsb/XSB/bin/xsb") myXsb.load(os.getcwd() + '/maze.P') myXsb.load(os.getcwd() + '/bfs.P') myXsb.load(os.getcwd() + '/corner2.P') q_result = myXsb.query("bfs("+str(result[0])+",X)") result = q_result[0]['X'] result = result[1:] result = result[:-1] result = result.split(',') temp = result[1:] temp.extend(merged_result) merged_result = temp """ Building the XSB PROLOG query """ myXsb = pyxf.xsb("/home/vishal/Downloads/xsb/XSB/bin/xsb") myXsb.load(os.getcwd() + '/maze.P') myXsb.load(os.getcwd() + '/bfs.P') myXsb.load(os.getcwd() + '/corner1.P') q_result = myXsb.query("bfs("+str(result[0])+",X)") result = q_result[0]['X'] result = result[1:] result = result[:-1] result = result.split(',') temp = result temp.extend(merged_result) merged_result = temp result = merged_result result.reverse() result = result[1:] result_list = list() result_list.append(direction_list[('start', result[0])]) """ Converting the list of actions returned by prolog into appropriate directions to be returned """ for x in range(len(result) - 1): result_list.append(direction_list[(result[x], result[x + 1])]) return result_list
def depthFirstSearch(problem): #get map's outline w = problem.walls.width h = problem.walls.height sx, sy = problem.getStartState() goalx,goaly = problem.goal #define the notion to each position in map: (1,1) --> cell01 notion = [] t=0 for i in range(0,w): notion.append([]) for i in range(0,w): for j in range(0,h): notion[i].append(t) t=t+1 #prolog file contains connection between cell fname = 'connection.P' from game import Directions dict ={} with open(fname, 'w') as fout: fout.write('\n') for i in range(0,w): for j in range(0,h): if not problem.walls[i][j]: if i+1 <= w : if not problem.walls[i+1][j]: fout.write('connect(cell'+ notion[i][j].__str__() +',cell'+ notion[i+1][j].__str__()+ ').') fout.write('\n') word = 'cell'+ notion[i][j].__str__()+'cell'+ notion[i+1][j].__str__() dict[word] = Directions.EAST #dictionary translating from strings "cellXcellY" to the real direction in game if i-1 >= 0 : if not problem.walls[i-1][j]: fout.write('connect(cell'+ notion[i][j].__str__() +',cell'+ notion[i-1][j].__str__()+ ').') fout.write('\n') word = 'cell'+ notion[i][j].__str__()+'cell'+ notion[i-1][j].__str__() dict[word] = Directions.WEST if j+1 <= h : if not problem.walls[i][j+1]: fout.write('connect(cell'+ notion[i][j].__str__() +',cell'+ notion[i][j+1].__str__()+ ').') fout.write('\n') word = 'cell'+ notion[i][j].__str__()+'cell'+ notion[i][j+1].__str__() dict[word] = Directions.NORTH if j-1 >= 0 : if not problem.walls[i][j-1]: fout.write('connect(cell'+ notion[i][j].__str__() +',cell'+ notion[i][j-1].__str__()+ ').') fout.write('\n') word = 'cell'+ notion[i][j].__str__()+'cell'+ notion[i][j-1].__str__() dict[word] = Directions.SOUTH fout.close() #load prolog fact from spade import pyxf brain = pyxf.xsb('/home/hieule/Downloads/XSB/bin/xsb') brain.load(fname) brain.load('dfs.P') goal = 'cell'+notion[goalx][goaly].__str__() start = 'cell'+notion[sx][sy].__str__() feedback = brain.query('dfs('+start+',['+start+'],'+goal+',X).') #feedback = brain.query('solve2('+start+','+goal+',X).') path=feedback[0].__str__() path = path[8:len(path)-3] path = path.split(',', 9999) #translate the path using dictionary path_translated=[] for i in range(0,len(path)-1): path_translated.append(dict[path[i]+path[i+1]]) return path_translated
import types from spade import pyxf # load xsb from your computer - have to be installed # go to Flora-2 download, unzip and ./runflora after that # run command 'xsb'. If xsb working then change path # in line below xsb = pyxf.xsb('/home/stella/Flora-2/XSB/bin/xsb') xsb.load('osobe.P') def getMyFriends(user): # define path to xsb results = xsb.query('all_friends(%s, X)' % user) return parseResultToArray(results) def getMySuggestions(user): results = xsb.query('all_suggestions(%s, X)' % user) return parseResultToArray(results) def addNewFriend(user, friend): query = "asserta(friends('%s', '%s'))." % (user, friend) xsb.query(query) def parseResultToArray(dictData): if type(dictData) == type(True) or type(dictData) == type(False): return [] result = dictData[0]["X"] result = result.replace('[', '').replace(']', '')
def depthFirstSearch(problem): """ Search the deepest nodes in the search tree first [p 85]. Your search algorithm needs to return a list of actions that reaches the goal. Make sure to implement a graph search algorithm [Fig. 3.7]. To get started, you might want to try some of these simple commands to understand the search problem that is being passed in: print "Start:", problem.getStartState() print "Is the start a goal?", problem.isGoalState(problem.getStartState()) print "Start's successors:", problem.getSuccessors(problem.getStartState()) """ "*** YOUR CODE HERE ***" f = open('maze.P','r') for line in f: if "goal" in line: g = line last = line print "lastline",last print "goal",g f.close() refine = last.split("(") refine2 = refine[1].split(")") startPac = refine2[0] myXSB = pyxf.xsb("/home/nikhil/Downloads/XSB/bin/xsb") myXSB.load("maze.P") myXSB.load("dfs.P") result = myXSB.query("depthFirstSearch("+startPac+", Path,Direction).") print result x = result[0]['Path'] f1 = x.split("[") neededDir = f1[1].split(",") gg = g.split("(") g2 = gg[1].split(")") ls = [] f2 = open('maze.P','r') for i in xrange(len(neededDir)): f2 = open('maze.P','r') for line1 in f2: if i+1<len(neededDir): stri = neededDir[i] + "," + neededDir[i+1] if i+1<len(neededDir) and stri in line1: j = line1.split(",") k = j[2].split(").") print line1,neededDir[i],neededDir[i+1],k[0] if g2[0]==neededDir[i+1]: exit ls.append(str(k[0])) continue f2.close() return ls """for x in xrange(len(array)):
from spade import pyxf myXsb=pyxf.xsb("/home/prasidh/Downloads/XSB/bin/xsb") myXsb.load("/home/prasidh/Downloads/search-source1/search/dfs.P") myXsb.load("/home/prasidh/Downloads/search-source1/search/maze.P") result1=myXsb.query("dfs_start(c35_1,goal,Path).") print result1
def aStarSearch(problem, heuristic=nullHeuristic): print 'This is A*!' from game import Directions """ A separate file consisting of heuristic values based on argument is populated for future use by the query. """ f = open('astar_heuristic.P', 'w') sx, sy = problem.startState start = sx + (problem.walls.width - 2) * (problem.walls.height- 2 - sy) gx, gy = problem.goal goal = gx + (problem.walls.width - 2) * (problem.walls.height - 2 - gy) for x in range(problem.walls.width): for y in range(problem.walls.height): """ Avoiding the boundary frames """ if x != 0 and y != 0 and x != problem.walls.width - 1 and y != problem.walls.height - 1: if problem.walls[x][y] is False: curr = x + (problem.walls.width - 2) * (problem.walls.height - 2 - y) if curr == goal: u = 'finish' elif curr == start: u = 'start' else: u = 'c' + str(curr) v = '' temp = 0 """ Processing the left of the node """ if problem.walls[x - 1][y] is False: temp = x - 1 + (problem.walls.width - 2) * (problem.walls.height - 2 - y) if temp == goal: v = 'finish' elif temp == start: v = 'start' else: v = 'c' + str(temp) """ Adding the manhattan heuristic value to the clause file. """ man_d = heuristic((x-1,y),problem,{}) f.write('manhattan_distance_heuristic(' + v + ',' + str(man_d) + ').\n') """ Processing the right of the node """ if problem.walls[x + 1][y] is False: temp = x + 1 + (problem.walls.width - 2) * (problem.walls.height - 2 - y) if temp == goal: v = 'finish' elif temp == start: v = 'start' else: v = 'c' + str(temp) """ Adding the manhattan heuristic value to the clause file. """ man_d = heuristic((x+1,y),problem,{}) f.write('manhattan_distance_heuristic(' + v + ',' + str(man_d) + ').\n') """ Processing left of the node """ if problem.walls[x][y - 1] is False: temp = x + (problem.walls.width - 2) * (problem.walls.height - 2 - (y - 1)) if temp == goal: v = 'finish' elif temp == start: v = 'start' else: v = 'c' + str(temp) """ Adding the manhattan heuristic value to the clause file. """ man_d = heuristic((x,y-1),problem,{}) f.write('manhattan_distance_heuristic(' + v + ',' + str(man_d) + ').\n') """ Processing right of the node """ if problem.walls[x][y + 1] is False: temp = x + (problem.walls.width - 2) * (problem.walls.height - 2 - (y + 1)) if temp == goal: v = 'finish' elif temp == start: v = 'start' else: v = 'c' + str(temp) """ Adding the manhattan heuristic value to the clause file. """ man_d = heuristic((x,y+1),problem,{}) f.write('manhattan_distance_heuristic(' + v + ',' + str(man_d) + ').\n') f.close() from searchAgents import direction_list from spade import pyxf import os """ Building the XSB PROLOG Query """ myXsb = pyxf.xsb("/home/vishal/Downloads/xsb/XSB/bin/xsb") myXsb.load(os.getcwd() + '/maze.P') myXsb.load(os.getcwd() + '/astar.P') myXsb.load(os.getcwd() + '/astar_heuristic.P') q_result = myXsb.query("astar(start,X)") result = q_result[0]['X'] result = result[1:] result = result[:-1] result = result.split(',') result = result[1:] result_list = list() result_list.append(direction_list[('start', result[0])]) """ Converting the list of actions returned by prolog into appropriate directions to be returned """ for x in range(len(result) - 1): result_list.append(direction_list[(result[x], result[x + 1])]) return result_list