def __init__(self, problem): """creates a searcher from a problem """ self.problem = problem self.initialize_frontier() self.num_expanded = 0 self.add_to_frontier(Path(problem.start_node())) super().__init__()
def result(self, path1, path2): current = path2 result = path1 while current.arc != None: result = Path(result, Arc(current.arc.to_node, current.arc.from_node, 1, current.arc.action)) current = current.initial #print(result) return result
def search(self): """returns (next) path from the problem's start node to a goal node. Returns None if no path exists. """ path = Path(None) while not self.empty_frontier(): # pop the first one path = self.frontier.pop(0) self.add_to_expended_state(path.end()) self.frontier_state.remove(path.end()) self.display(2, "Expanding:", path, "(cost:", path.cost, ")") self.num_expanded += 1 neighs = self.problem.neighbors(path.end()) self.display(3, "Neighbors are", neighs) for arc in neighs: if (arc.to_node not in self.expended_state) or ( arc.to_node in self.frontier_state): self.add_to_frontier(Path(path, arc)) self.frontier_state.remove(path.end()) self.display(3, "Frontier:", self.frontier) if self.problem.is_goal(path.end()): self.display(1, self.num_expanded, "paths have been expanded and", len(self.frontier), "paths remain in the frontier") self.solution = path # store the solution found return path # then stop the searcher
def __init__(self, problem): """creates a searcher from a problem """ self.problem = problem self.initialize_frontier() self.initialize_f_frontier() self.initialize_b_frontier( ) # frontier for the bidirectional (back starting) self.num_f_expanded = 0 self.num_b_expanded = 0 self.add_to_f_frontier(Path(problem.start_node())) self.add_to_b_frontier(Path( problem.goal_node())) # start state is the goal node super().__init__() self.max_display_level self.f_closed = set() self.b_closed = set() self.new_path = []
def iterativeDeepeningSearch(self): while (self.hit_depth_bound): self.hit_depth_bound = False retVal = self.search(self.depth_bound) if retVal != None: return retVal self.depth_bound += 1 self.initialize_frontier self.add_to_frontier(Path(self.problem.start_node()))
def __init__(self, problem): """creates a searcher from a problem """ self.problem = problem self.initialize_frontier() self.num_expanded = 0 self.add_to_frontier(Path(problem.start_node())) super().__init__() self.max_display_level self.visited = set() # pruning
def search(self): path=Path(None) while not self.empty_frontier(): print() print("explored: ",self.explored) print("front: ",self.frontier) path=self.frontier.pop(0) #self.explored.add(path) print("path:",path," pathend",path.end()) neighs = self.problem.neighbors(path.end()) print("neighs: ",neighs) self.display(3, "Neighbors are", neighs) self.num_expanded+=1 for arc in neighs: print("arc: ",arc," arc_to:",arc.to_node) if arc.to_node not in self.explored: print("not have visited: ",arc.to_node) self.add_to_frontier(Path(path,arc)) #self.explored.add(Path(path,arc)) self.explored.add(arc.to_node) if self.problem.is_goal(path.end()): # solution found self.display(1, self.num_expanded, "paths have been expanded and", len(self.frontier), "paths remain in the frontier") self.solution = path # store the solution found return path self.display(1, "No (more) solutions. Total of", self.num_expanded, "paths expanded.")
def search(self): """returns an optimal solution to a problem with cost less than bound. returns None if there is no solution with cost less than bound.""" self.frontier = [Path(self.problem.start_node())] self.num_expanded = 0 while self.frontier: path = self.frontier.pop() if path.cost+self.problem.heuristic(path.end()) < self.bound: self.display(3,"Expanding:",path,"cost:",path.cost) self.num_expanded += 1 if self.problem.is_goal(path.end()): self.best_path = path self.bound = path.cost self.display(2,"New best path:",path," cost:",path.cost) else: neighs = self.problem.neighbors(path.end()) self.display(3,"Neighbors are", neighs) for arc in reversed(list(neighs)): self.add_to_frontier(Path(path, arc)) self.display(1,"Number of paths expanded:",self.num_expanded) self.solution = self.best_path return self.best_path
def __init__(self, problem): """creates a searcher from a problem """ self.problem = problem self.initialize_frontier() self.num_expanded = 0 self.add_to_frontier(Path(problem.start_node())) super().__init__() #self.max_display_level #self.visitedNode=[] #for the linear time #maybe needs to initialize a visited paths list--- to avoid the duplicates #have a set instead self.closed = []
def search(self): path = Path(None) while not self.empty_frontier(): path = self.frontier.pop(0) self.add_to_expanded_city(path.end()) self.frontier_city.remove(path.end()) self.display(2, "Expanding:", path, "(cost:", path.cost, ")") self.num_expanded += 1 neighbors = self.problem.neighbors(path.end()) self.display(3, "Neighbors are", neighbors) for arc in neighbors: if (arc.to_node not in self.expanded_city) or (arc.to_node in self.frontier_city): self.add_to_frontier(Path(path, arc)) self.frontier_city.append(Path(path, arc).end()) self.display(3, "Frontier:", self.frontier) if self.problem.is_goal(arc.to_node): # solution found self.display(1, self.num_expanded, "paths have been expanded and", len(self.frontier), "paths remain in the frontier") self.solution = Path(path, arc) return Path(path, arc)
def search(self, time_limit=20): """returns (next) path from the problem's start node to a goal node. Returns None if no path exists. """ if time_limit: start = time.time() skip = 0 skip_limit = 100000 # only check the time this often while not self.empty_frontier(): if time_limit: if skip < skip_limit: skip += 1 else: skip = 0 run_time = time.time() - start if run_time > time_limit: self.display(1, "Time limit ", time_limit, "exceeded after", run_time, "seconds") return None path = self.frontier.pop() self.display(2, "Expanding:", path, "(cost:", path.cost, ")") self.num_expanded += 1 if self.problem.is_goal(path.end()): # solution found self.display(1, self.num_expanded, "paths have been expanded and", len(self.frontier), "paths remain in the frontier") self.solution = path # store the solution found return path else: neighs = self.problem.neighbors(path.end()) self.display(3, "Neighbors are", neighs) for arc in reversed(neighs): self.add_to_frontier(Path(path, arc)) self.display(3, "Frontier:", self.frontier) self.display(1, "No (more) solutions. Total of", self.num_expanded, "paths expanded.")
def search(self): """returns (next) path from the problem's start node to a goal node. Returns None if no path exists. """ while not self.empty_frontier(): path = self.frontier.pop(0) # dir([]) pop self.display(2, "Expanding:", path, "(cost:", path.cost, ")") self.num_expanded += 1 if self.problem.is_goal(path.end()): # solution found self.display(1, self.num_expanded, "paths have been expanded and", len(self.frontier), "paths remain in the frontier") self.solution = path # store the solution found return path else: neighs = self.problem.neighbors(path.end()) self.display(3, "Neighbors are", neighs) for arc in reversed(neighs): self.add_to_frontier(Path(path, arc)) self.display(3, "Frontier:", self.frontier) self.display(1, "No (more) solutions. Total of", self.num_expanded, "paths expanded.")
def search(self): """returns (next) path from the problem's start node to a goal node. Returns None if no path exists. """ count = 0 indexClosed = 0 while not self.empty_frontier(): path = self.frontier.pop(0) self.display(2, "Expanding:", path, "(cost:", path.cost, ")") # self.visitedNode.append(nodeList) # add path to the visitedNode list self.num_expanded += 1 #print(path) if self.problem.is_goal(path.end()): # solution found print("Maximum closed list: ", indexClosed) #print(path) self.display(1, self.num_expanded, "paths have been expanded and", len(self.frontier), "paths remain in the frontier") self.solution = path # store the solution found return path else: neighs = self.problem.neighbors(path.end()) self.display(3, "Neighbors are", neighs) for arc in reversed(neighs): if arc.to_node not in self.closed: self.add_to_frontier(Path(path, arc)) self.closed.append(arc.to_node) if (indexClosed < len(self.closed)): indexClosed = len(self.closed) self.display(3, "Frontier:", self.frontier) self.display(1, "No (more) solutions. Total of", self.num_expanded, "paths expanded.")
def __init__(self, problem): super().__init__(problem) self.frontier_state = [] self.expanded_state = [] self.add_to_frontier_state(Path(problem.start_node()).end())
def search(self): """returns next path from the problem's start node to a goal node. Returns None if no path exists. """ if self.pruning == 'mpp': while not self.frontier.empty(): path = self.frontier.pop() if path.end() not in self.explored: self.display(2, "Expanding: ", path, "(cost:", path.cost, ")") self.explored.add(path.end()) self.num_expanded += 1 if self.problem.is_goal(path.end()): self.display(1, self.num_expanded, "paths have been expanded and", len(self.frontier.frontierpq), "paths remain in the frontier") return path else: neighs = self.problem.neighbors(path.end()) for arc in neighs: self.add_to_frontier(Path(path, arc)) self.display(3, "Frontier:", self.frontier) elif self.pruning == 'cycle': while not self.frontier.empty(): path = self.frontier.pop() if path.end() not in path.initial_nodes( ): # new part for cycle pruning self.display(2, "Expanding: ", path, "(cost:", path.cost, ")") self.num_expanded += 1 if self.problem.is_goal(path.end()): self.display(1, self.num_expanded, "paths have been expanded and", len(self.frontier.frontierpq), "paths remain in the frontier") return path else: neighs = self.problem.neighbors(path.end()) for arc in neighs: self.add_to_frontier(Path(path, arc)) self.display(3, "Frontier:", elf.frontier) else: # no pruning while not self.frontier.empty( ) and self.num_expanded < self.max_expanded: path = self.frontier.pop() self.display(2, "Expanding: ", path, "(cost:", path.cost, ")") self.num_expanded += 1 if self.problem.is_goal(path.end()): self.display(1, self.num_expanded, "paths have been expanded and", len(self.frontier.frontierpq), "paths remain in the frontier") return path else: neighs = self.problem.neighbors(path.end()) for arc in neighs: self.add_to_frontier(Path(path, arc)) self.display(3, "Frontier:", self.frontier) self.display(1, "Total of", self.frontier.frontier_index, "paths expanded.")
def search(self): """returns (next) path from the problem's start node to a goal node. Returns None if no path exists. """ while not self.empty_f_frontier() and not self.empty_b_frontier(): path = self.f_frontier.pop(0) if path.end() in self.b_closed: # print("intersect beforehand") path.list = self.merge_path(path, b_path) self.solution = path.list return path.list b_path = self.b_frontier.pop(0) if path.end() == b_path.end(): # print("intersection on") path.list = self.merge_path(path, b_path) self.solution = path.list return path.list if path.end() not in self.f_closed: self.display(2, "Expanding:", path, "(cost:", path.cost, ")") self.f_closed.add(path.end()) # add path to the visited list self.num_f_expanded += 1 if self.problem.is_goal(path.end()): # solution found self.display(1, self.num_f_expanded, "paths have been expanded and", len(self.f_frontier + self.b_frontier), "paths remain in the frontier") self.solution = path # store the solution found return path else: neighs = self.problem.neighbors(path.end()) self.display(3, "Neighbors are", neighs) for arc in reversed(neighs): self.add_to_f_frontier(Path(path, arc)) self.display(3, "Frontier:", self.f_frontier) if b_path.end() not in self.b_closed: self.display(2, "Expanding:", b_path, "(cost:", b_path.cost, ")") self.b_closed.add(b_path.end()) # add path to the visited list self.num_b_expanded += 1 if self.problem.is_start(b_path.end()): # solution found self.display(1, self.num_b_expanded, "paths have been expanded and", len(self.b_frontier + self.f_frontier), "paths remain in the frontier") self.solution = b_path return b_path else: neighs = self.problem.neighbors(b_path.end(), True) self.display(3, "Neighbors are", neighs) for arc in reversed(neighs): self.add_to_b_frontier(Path(b_path, arc)) self.display(3, "Frontier:", self.f_frontier) self.display(1, "No (more) solutions. Total of", self.num_f_expanded, "paths expanded.")
def __init__(self,problem): super().__init__(problem) self.frontier_state=[] self.explored=set() self.explored.add(Path(problem.start_node()))