def a_star_search(problem, fringe):
# If there is no node on fringe, make one
if len(fringe.queue) <= 0:
initial_node = Node(problem)
fringe.insert(initial_node)
# If nodes don't have path cost for A* Search, give them one
for node in fringe.queue:
if node.a_star_cost == None:
node.a_star_cost = a_star_evaluator(node)
# Form a temporary priority queue
a_star_fringe = Queue()
a_star_fringe.insert_all(fringe.queue)
# Sort them according to lowest path cost
bubble_sort(a_star_fringe, False)
# Iterate over the sorted nodes, to check visually
for nodes in a_star_fringe.queue:
print('Node: ' + str(nodes.a_star_cost) + ' Depth: ' + str(nodes.depth) + ' Action: ' + str(nodes.action))
# Now do the good stuff
# Get the first node in A* fringe and then pop it on the main fringe
greed_node = a_star_fringe.pop()
node = fringe.pop_specific(greed_node)
# If the node is the goal, return it as goal; otherwise expand it
if goal_test(node.state) == True:
return True, solution(node), node
else:
if node.state.connor.death == False:
fringe.insert_all(expand(node))
return False, fringe, node
def search(grid,init,goal,cost):
# ----------------------------------------
# insert code here
# ----------------------------------------
Nr=len(grid)
Nc=len(grid[0])
def childNode(grid, loc, delta, delta_name):
child=[]
for i in range(len(delta)):
move=delta[i]
newloc=[loc[0]+move[0], loc[1]+move[1]]
if loc[0]+move[0]>=0 and loc[0]+move[0]<Nr \
and loc[1]+move[1]>=0 and loc[1]+move[1]<Nc \
and grid[newloc[0]][newloc[1]] ==0:
child.append([newloc,delta_name[i]])
return child
visited=[]
frontier=Queue()
frontier.push([init,0])
while not frontier.isEmpty():
loc, rlen=frontier.pop()
if not loc in visited:
visited.append(loc)
if loc==goal:
return [rlen, loc[0], loc[1]]
for nextloc, move_name in childNode(grid, loc, delta, delta_name):
if not nextloc in visited:
frontier.push([nextloc, rlen+cost])
return 'fail'
def best_fs(problem, fringe):
# If there is no node on fringe, make one
if len(fringe.queue) <= 0:
initial_node = Node(problem)
fringe.insert(initial_node)
# If nodes don't have path cost for Greedy BFS, give them one
for node in fringe.queue:
if node.greed_cost == None:
node.greed_cost = best_fs_evaluator(node)
# Form a temporary priority queue
best_fs_fringe = Queue()
best_fs_fringe.insert_all(fringe.queue)
# Sort them according to lowest path cost
bubble_sort(best_fs_fringe)
# Now do the good stuff
# Get the first node in Greedy BFS fringe and then pop it on the main fringe
greed_node = best_fs_fringe.pop()
node = fringe.pop_specific(greed_node)
# If the node is the goal, return it as goal; otherwise expand it
if goal_test(node.state) == True:
return True, solution(node), node
else:
if node.state.connor.death == False:
fringe.insert_all(expand(node))
return False, fringe, node
def test_pop_2(self):
q = Queue()
q.put(2)
q.put(1)
self.assertEqual(q.pop(), 2)
self.assertEqual(q.pop(), 1)
self.assertTrue(q.empty())
class EventsHub:
"""Implements an event aggregator to gather events from both interfaces as well as the application itself.
Similar to an Observer pattern.
Warning:
Events need to be processed regularly by calling `.handle_events()`
to avoid overflowing the event queue.
Events types:
- pygame events (mouse / key press / quit)
- tkinter events (mouse / key press / quit)
- all buttons
- application events, like "AnimationFinished" event
"""
def __init__(self):
self._events = Queue()
self._callbacks = {}
def raise_event(self, event):
self._events.put(event)
def add_callback(self, event_name, callback):
self._callbacks.setdefault(event_name, []).append(callback)
def handle_events(self):
while not self._events.empty():
event = self._events.pop()
if event.type in [Event.QUIT, Event.NEWFRAME]:
# print("Handling", event, self._callbacks.get(event.type, []))
pass
for callback in self._callbacks.get(event.type, []):
callback(event)
def search(grid, init, goal, cost):
# ----------------------------------------
# insert code here
# ----------------------------------------
Nr = len(grid)
Nc = len(grid[0])
expand = [[-1 for j in range(Nc)] for i in range(Nr)]
policy = [[' ' for j in range(Nc)] for i in range(Nr)]
path = [[' ' for j in range(Nc)] for i in range(Nr)]
count = 0
def childNode(grid, loc, delta, delta_name):
child = []
for i in range(len(delta)):
move = delta[i]
newloc = [loc[0] + move[0], loc[1] + move[1]]
if loc[0]+move[0]>=0 and loc[0]+move[0]<Nr \
and loc[1]+move[1]>=0 and loc[1]+move[1]<Nc \
and grid[newloc[0]][newloc[1]] ==0:
child.append([newloc, delta_name[i]])
return child
visited = []
frontier = Queue()
frontier.push([init, ' ', 0])
while not frontier.isEmpty():
loc, mov, rlen = frontier.pop()
if not loc in visited:
visited.append(loc)
policy[loc[0]][loc[1]] = mov
if loc == goal:
path[goal[0]][goal[1]] = '*'
while loc != init:
x, y = loc
if policy[x][y] == 'v':
loc = [x - 1, y]
path[loc[0]][loc[1]] = 'v'
elif policy[x][y] == '^':
loc = [x + 1, y]
path[loc[0]][loc[1]] = '^'
elif policy[x][y] == '>':
loc = [x, y - 1]
path[loc[0]][loc[1]] = '>'
elif policy[x][y] == '<':
loc = [x, y + 1]
path[loc[0]][loc[1]] = '<'
return path
for nextloc, move_name in childNode(grid, loc, delta, delta_name):
if not nextloc in visited:
frontier.push([nextloc, move_name, rlen + cost])
return 'fail'
def print_weights(self):
q = Queue()
layer = 0
for neuron in self.input_layer:
q.put((neuron, layer + 1))
while not q.empty():
neuron, cur_layer = q.pop()
if cur_layer > layer and cur_layer < self.nlayers:
print "\nlayer %d:" % cur_layer,
layer = cur_layer
for connection in neuron.outputs:
q.put((connection.tar, layer + 1))
for connection in neuron.outputs:
print connection.w,
print # print new line
def search(grid, init, goal, cost):
# ----------------------------------------
# modify code below
# ----------------------------------------
Nr = len(grid)
Nc = len(grid[0])
expand = [[-1 for j in range(Nc)] for i in range(Nr)]
count = 0
def childNode(grid, loc, delta, delta_name):
child = []
for i in range(len(delta)):
move = delta[i]
newloc = [loc[0] + move[0], loc[1] + move[1]]
if loc[0]+move[0]>=0 and loc[0]+move[0]<Nr \
and loc[1]+move[1]>=0 and loc[1]+move[1]<Nc \
and grid[newloc[0]][newloc[1]] ==0:
child.append([newloc, delta_name[i]])
return child
visited = []
frontier = Queue()
frontier.push([init, 0])
while not frontier.isEmpty():
loc, rlen = frontier.pop()
if not loc in visited:
visited.append(loc)
expand[loc[0]][loc[1]] = count
count += 1
if loc == goal:
return expand
for nextloc, move_name in childNode(grid, loc, delta, delta_name):
if not nextloc in visited:
frontier.push([nextloc, rlen + cost])
return 'fail'
def general_search(problem):
"""Problem: {doamin, method, graph, coords, start, goal}
method: B, D, I, U, A
route: graph search (maintain a closed set) except Astar
tsp: tree search
"""
method = problem['method']
if method not in ['B', 'D', 'I', 'U', 'A']:
print("Enter Correct method!")
return None
if problem['start'] not in problem['graph'].get_nodes() or (
problem['domain'] == 'route' and problem['goal'] not in problem['graph'].get_nodes()):
print("Enter Correct Start/Goal!")
return None
# BFS, DFS
if method in ['B', 'D']:
if method == 'B':
frontier = Queue()
else:
frontier = Stack()
start_node = Node(problem['start'])
frontier.push(start_node)
closed_set = set()
while not frontier.isEmpty():
node = frontier.pop()
closed_set.add(node.value)
if goal_test(problem, node):
path = node.get_path()
cost = cal_path_cost(problem['graph'], path)
return path, cost, frontier.count
# Expansion
closed_set.add(node.value)
adj = problem['graph'].adj(node.value)
for child_value in quicksort(adj):
if push_or_not(problem, node, child_value, closed_set):
child_node = Node(child_value, node)
frontier.push(child_node)
return None
"""Uniform Cost Search / Astar Search"""
if method in ['U', 'A']:
frontier = PriorityQueue()
start_node = Node(problem['start'])
priority = 0 if method == 'U' else astar_heuristic(problem, start_node)
frontier.push(priority, start_node)
closed_set = set()
while not frontier.isEmpty():
node = frontier.pop()
closed_set.add(node.value)
if goal_test(problem, node):
path = node.get_path()
cost = cal_path_cost(problem['graph'], path)
return path, cost, frontier.count
# Expansion
adj = problem['graph'].adj(node.value)
for child_value in quicksort(adj):
if push_or_not(problem, node, child_value, closed_set):
child_cost = node.cost_so_far + \
problem['graph'].get_cost(node.value, child_value) # g_n
child_node = Node(child_value, node, child_cost)
priority = child_cost if method == 'U' else child_cost + \
astar_heuristic(problem, child_node)
frontier.push(priority, child_node)
return None
"""Iterative Deepening Search"""
if method == 'I':
def depth_limited(problem, limit):
"""Depth Limited Search"""
frontier = Stack()
start_node = Node(problem['start'])
frontier.push(start_node)
closed_set = set()
while not frontier.isEmpty():
node = frontier.pop()
closed_set.add(node.value)
if goal_test(problem, node):
path = node.get_path()
cost = cal_path_cost(problem['graph'], path)
return path, cost, frontier.count
if node.depth == limit:
pass
else:
# Expansion
adj = problem['graph'].adj(node.value)
for child_value in quicksort(adj):
if push_or_not(problem, node, child_value, closed_set):
child_node = Node(child_value, node)
frontier.push(child_node)
return None
max_depth = 20
for i in range(max_depth):
result = depth_limited(problem, i)
if result:
return result
def test_pop_exception(self):
with self.assertRaises(AssertionError):
q = Queue()
q.put(1)
q.pop()
q.pop()
