def pq_setup():
"""Create random order entry of values into priority queue"""
pq = PriorityQ()
for num in range(1, 200):
pq.insert(randint(1, 10))
return pq
def test_pop_empty():
"""Test that popping an empty list raises an index error."""
from priorityq import PriorityQ
instance = PriorityQ()
with pytest.raises(IndexError):
instance.pop()
def test_pop_empty():
"""Test that popping an empty list raises an index error."""
from priorityq import PriorityQ
instance = PriorityQ()
with pytest.raises(IndexError):
instance.pop()
def test_insert_item_QNode_to_empty():
node1 = QNode(10, priority=0)
pqueue = PriorityQ()
pqueue.insert(node1)
assert len(pqueue) == 1
assert pqueue[0].val == 10
assert pqueue[0].priority == 0
def test_insert_one(self):
pri, val = 2, 'a'
testq = PriorityQ()
testq.insert(pri, val)
actual = testq.harray
expected = [[None], [pri, val]]
self.assertEquals(expected, actual)
def test_initialize_with_single_tuple():
"""The test initializes priority q with a single tuple."""
from priorityq import PriorityQ
new_pq = PriorityQ((3, 2))
assert len(new_pq) == 1
assert new_pq._high_p == 2
assert new_pq.peek() == 3
def q10():
"""Create Q with 10 priorities that contain 1 value each."""
from priorityq import PriorityQ
q = PriorityQ()
for i in range(1, 10):
q.insert('a', i)
return q
def test_2(self):
""" test that insert puts the node in the queue in the correct position with no priority assignment """
p = PriorityQ()
n1 = Node(1)
n2 = Node(2)
p.insert(n1)
p.insert(n2)
self.assertEqual(p.head._value, 1)
def test_pq_insert_len():
pq = PriorityQ()
for num in range(10):
pq.insert(1)
p1 = pq.priorities[1]
assert len(p1.heap_list) is 10
pq.insert(1)
assert len(p1.heap_list) is 11
def test_pop_values_of_same_priority_acts_like_queue(amount):
"""Test that popping only item from queue empties it."""
from random import randint
from priorityq import PriorityQ
q = PriorityQ()
random_nums = [randint(0, 100) for _ in range(amount)]
for n in random_nums:
q.insert(n)
popped = [q.pop() for _ in random_nums]
assert popped == random_nums
def test_peek():
"""Test that peeking reveals the root of the priority queue."""
from priorityq import PriorityQ
push_list = [(2, 'maintenance'), (1, 'staff mtg'), (1, 'stand-up'),
(0, 'server crash'), (0, 'boss DUI')]
test_q = PriorityQ()
for pri, val in push_list:
test_q.insert(pri, val)
assert test_q.peek() == 'server crash'
def full_priorityq():
priorityq = PriorityQ()
priorityq.insert(3, 8)
priorityq.insert(5, 2)
priorityq.insert(6, 3)
priorityq.insert(4, 10)
priorityq.insert(7, 3)
return priorityq
def test_insert():
from priorityq import PriorityQ
push_list = [(2, 'maintenance'), (1, 'staff mtg'), (1, 'stand-up'),
(0, 'server crash')]
pop_list = ['server crash', 'staff mtg', 'stand-up', 'maintenance']
test_q = PriorityQ()
for pri, val in push_list:
test_q.insert(pri, val)
for item in pop_list:
assert test_q.pop() == item
def test_peek():
"""Test that peeking reveals the root of the priority queue."""
from priorityq import PriorityQ
push_list = [(2, 'maintenance'),
(1, 'staff mtg'),
(1, 'stand-up'),
(0, 'server crash'),
(0, 'boss DUI')]
test_q = PriorityQ()
for pri, val in push_list:
test_q.insert(pri, val)
assert test_q.peek() == 'server crash'
def test_pop_from_random_p_q_with_all_diff_priority_in_sorted_order():
"""Test popping all the items from a priority queue are in sorted order.
All items inserted have the same priority as their value, so when
removed they should be in sorted order.
"""
from priorityq import PriorityQ
from random import randint
random_nums = list(set([randint(0, 100) for _ in range(20)]))
q = PriorityQ()
for n in random_nums:
q.insert(n, n)
popped = [q.pop() for _ in range(len(q._all_values) - 1)]
assert popped == sorted(random_nums, reverse=True)
def test_insert():
from priorityq import PriorityQ
push_list = [(2, 'maintenance'),
(1, 'staff mtg'),
(1, 'stand-up'),
(0, 'server crash')]
pop_list = ['server crash', 'staff mtg', 'stand-up', 'maintenance']
test_q = PriorityQ()
for pri, val in push_list:
test_q.insert(pri, val)
for item in pop_list:
assert test_q.pop() == item
def test_peek_with_1_elem(self):
pri1, val1 = 2, 'a'
pri2, val2 = 5, 'b'
pri3, val3 = 1, 'c'
pri4, val4 = 4, 'd'
pri5, val5 = 3, 'e'
testq = PriorityQ()
testq.insert(pri1, val1)
testq.insert(pri2, val2)
testq.insert(pri3, val3)
testq.insert(pri4, val4)
testq.insert(pri5, val5)
x = testq.peek()
self.assertEquals(x, 'c')
def AStar(initial_state):
global COUNT, BACKLINKS
# priority queue with respective priority
# add any auxiliary data structures as needed
OPEN = PriorityQ()
CLOSED = []
BACKLINKS[initial_state] = None
g = {initial_state: 0}
OPEN.insert(initial_state, heuristics(initial_state))
while not len(OPEN) == 0:
S, f = OPEN.deletemin()
while S in CLOSED:
S, f = OPEN.deletemin()
CLOSED.append(S)
# DO NOT CHANGE THIS SECTION: begining
if Problem.GOAL_TEST(S):
print(Problem.GOAL_MESSAGE_FUNCTION(S))
path = backtrace(S)
return path, Problem.PROBLEM_NAME
# DO NOT CHANGE THIS SECTION: end
COUNT += 1
print(COUNT)
L = []
for op in Problem.OPERATORS:
if op.precond(S):
new_state = op.state_transf(S)
if not occurs_in(new_state, CLOSED):
L.append(new_state)
BACKLINKS[new_state] = S
if new_state not in g.keys():
g[new_state] = g[S] + 1
for s2 in L:
if s2 in OPEN:
OPEN.remove(s2)
for elt in L:
OPEN.insert(elt, heuristics(elt) + g[elt])
def test_pop_with_2_elem(self):
pri1, val1 = 2, 'a'
pri2, val2 = 5, 'b'
pri3, val3 = 1, 'c'
pri4, val4 = 7, 'f'
pri5, val5 = 1, 'd'
pri6, val6 = 3, 'e'
testq = PriorityQ()
testq.insert(pri1, val1)
testq.insert(pri2, val2)
testq.insert(pri3, val3)
testq.insert(pri4, val4)
testq.insert(pri5, val5)
testq.insert(pri6, val6)
testq.pop()
expected = [[None], [pri3, val5], [pri6, val6], [pri1, val1],
[pri4, val4], [pri2, val2]]
actual = testq.harray
self.assertEquals(expected, actual)
def test_insert_many(self):
pri1, val1 = 2, 'a'
pri2, val2 = 5, 'b'
pri3, val3 = 1, 'c'
pri4, val4 = 4, 'd'
pri5, val5 = 3, 'e'
testq = PriorityQ()
testq.insert(pri1, val1)
testq.insert(pri2, val2)
testq.insert(pri3, val3)
testq.insert(pri4, val4)
testq.insert(pri5, val5)
expected = [[None], [pri3, val3], [pri5, val5], [pri1, val1],
[pri2, val2], [pri4, val4]]
actual = testq.harray
self.assertEquals(expected, actual)
def test_3(self):
""" test that insert puts the node in the queue in the correct position if given a priority value """
p = PriorityQ()
n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
p.insert(n1, 1)
p.insert(n2, 2)
p.insert(n3, 3)
self.assertEqual(p.head._priority, 3)
def AStar(initial_state):
global COUNT, BACKLINKS
# TODO: initialze and put first state into
# priority queue with respective priority
# add any auxiliary data structures as needed
OPEN = PriorityQ()
CLOSED = []
#define the g score which means
#the cost of the move will increase by 1 at each depth
g = {}
g[initial_state] = 0
BACKLINKS[initial_state] = None
#in priority queue, the state is the element
#and the F score is the priority
#F socre is the heuristics score plus g scorce
OPEN.insert(initial_state, g[initial_state] + 0)
while not OPEN.isEmpty():
COUNT += 1
S = OPEN.deletemin()
while S in CLOSED:
S = OPEN.deletemin()
CLOSED.append(S)
# DO NOT CHANGE THIS SECTION: begining
if Problem.GOAL_TEST(S):
print(Problem.GOAL_MESSAGE_FUNCTION(S))
path = backtrace(S)
return path, Problem.PROBLEM_NAME
# DO NOT CHANGE THIS SECTION: end
# TODO: finish A* implementation
for op in Problem.OPERATORS:
if op.precond(S):
new_state = op.state_transf(S)
if not (new_state in CLOSED):
h = heuristics(new_state)
g[new_state] = g[S] + 1
if new_state not in OPEN:
OPEN.insert(new_state, h + g[new_state])
BACKLINKS[new_state] = S
def test_many_equal_priorities(self):
pri1, val1 = 2, 'a'
pri2, val2 = 5, 'b'
pri3, val3 = 1, 'c'
pri4, val4 = 2, 'f'
pri5, val5 = 4, 'd'
pri6, val6 = 3, 'e'
testq = PriorityQ()
testq.insert(pri1, val1)
testq.insert(pri2, val2)
testq.insert(pri3, val3)
testq.insert(pri4, val4)
testq.insert(pri5, val5)
testq.insert(pri6, val6)
expected = [[None], [pri3, val3], [pri6, val6], [pri1, val1, val4],
[pri2, val2], [pri5, val5]]
actual = testq.harray
self.assertEquals(expected, actual)
def AStar(initial_state):
# this breaks pq ties
global COUNT, BACKLINKS
# TODO: initialze and put first state into
# priority queue with respective priority
# add any auxiliary data structures as needed
OPEN = PriorityQ()
CLOSED = []
OPEN.insert(initial_state,0)
BACKLINKS[initial_state] = None
while not OPEN.isEmpty():
COUNT += 1
S = OPEN.deletemin()
while S in CLOSED:
S = OPEN.deletemin()
CLOSED.append(S)
# DO NOT CHANGE THIS SECTION: begining
if Problem.GOAL_TEST(S):
print(Problem.GOAL_MESSAGE_FUNCTION(S))
path = backtrace(S)
return path, Problem.PROBLEM_NAME
# DO NOT CHANGE THIS SECTION: end
# TODO: finish A* implementation
for op in Problem.OPERATORS:
#Optionally uncomment the following when debugging
#a new problem formulation.
# print("Trying operator: "+op.name)
if op.precond(S):
new_state = op.state_transf(S)
if not (new_state in CLOSED):
h = heuristics(new_state)
#new_pq_item = ( new_state,h)
OPEN.insert(new_state , h)
BACKLINKS[new_state] = S
def test_insert():
priorityq = PriorityQ()
priorityq.insert(3, 8)
assert priorityq.list[0].value == 3
def test_intitalize_with_single_digit():
"""The test initialized a prio q with a single digit."""
from priorityq import PriorityQ
with pytest.raises(TypeError):
PriorityQ(3)
def test_empty_instantiation_args():
tpq = PriorityQ()
with pytest.raises(IndexError):
tpq.pop()
def test_valid_instantiation_args(input):
tpq = PriorityQ(input)
assert tpq.pop() is not None
def AStar(initial_state):
global COUNT, BACKLINKS
OPEN = PriorityQ() #currently discovered, not yet evaluated states
CLOSED = [] #already evaluated states
BACKLINKS[initial_state] = None #Tracks most efficient previous step
#Calculate F, G, H scores for Starting state
initialize_scores(initial_state)
#Only one state is known as of now
OPEN.insert(initial_state, F_SCORE[initial_state])
while OPEN.isEmpty() != True:
S, priority = OPEN.deletemin()
while S in CLOSED:
S = OPEN.deletemin()
CLOSED.append(S)
# DO NOT CHANGE THIS SECTION: beginning
if Problem.GOAL_TEST(S):
print(Problem.GOAL_MESSAGE_FUNCTION(S))
path = backtrace(S)
return path, Problem.PROBLEM_NAME
# DO NOT CHANGE THIS SECTION: end
COUNT += 1
if (COUNT % 32) == 0:
# if True:
# print(".",end="")
# if (COUNT % 128*128)==0:
if True:
print("COUNT = " + str(COUNT))
#print("len(OPEN)=" + str(len(OPEN))) #PriorityQ OPEN doesn't have len()
print("len(CLOSED)=" + str(len(CLOSED)))
for op in Problem.OPERATORS:
if op.precond(S):
new_state = op.state_transf(S)
if not occurs_in(new_state,
CLOSED): #ignore already evaluated neighbors
#find tentative score of neighbor
tentative_g_score = G_SCORE[S] + 1
if new_state not in G_SCORE: #Default INFINITY
BACKLINKS[
new_state] = S #First known path to new_state
elif tentative_g_score <= G_SCORE[new_state]:
BACKLINKS[
new_state] = S # Found better path to new_State
else:
continue #current path is not the best path to the neighbor
G_SCORE[new_state] = tentative_g_score
F_SCORE[new_state] = G_SCORE[new_state] + h_score_fn(
new_state)
# Delete previous F-score in PriorityQ if it exists
if OPEN.__contains__(new_state):
OPEN.remove(new_state)
#Update PriorityQ with new priority
OPEN.insert(new_state, F_SCORE[new_state])
# print(Problem.DESCRIBE_STATE(new_state))
#print(OPEN)
#Failure, if goal_test has not succeeded until now
print("COULD NOT FIND GOAL")
return
def test_insert_item_not_QNode_to_empty():
queue = PriorityQ()
queue.insert(50)
assert len(queue) == 1
assert queue[0].val == 50
assert queue[0].priority is None
def pop_empty():
priorityq = PriorityQ()
with pytest.raises(IndexError):
priorityq.pop()
from priorityq import PriorityQ import EightPuzzle import EightPuzzleWithHeuristics OPEN = PriorityQ() s1 = EightPuzzle.State([0, 1, 2, 3, 4, 5, 6, 7, 8]) s2 = EightPuzzle.State([1, 0, 2, 3, 4, 5, 6, 7, 8]) s3 = EightPuzzle.State([1, 0, 3, 2, 4, 5, 6, 7, 8]) h1 = EightPuzzleWithHeuristics.h_euclidean(s1) h2 = EightPuzzleWithHeuristics.h_euclidean(s2) h3 = EightPuzzleWithHeuristics.h_euclidean(s3) OPEN.insert(s1, h1) OPEN.insert(s2, h2) OPEN.insert(s3, h3) print(OPEN) s = OPEN.deletemin() print(s) s = OPEN.deletemin() print(s) OPEN.deletemin() print(OPEN)
def empty_priority_q():
"""Thie fixture creates and empty priority queue."""
from priorityq import PriorityQ
new_pq = PriorityQ()
return new_pq
def test_pop_last():
priorityq = PriorityQ()
priorityq.insert(5, 2)
assert priorityq.pop() == 5
assert priorityq.list == []
def empty_priorityq():
"""Create an empty priority queue."""
from priorityq import PriorityQ
return PriorityQ()
def test_PriorityQ_default():
test_pq = PriorityQ([1, 2, 3])
assert test_pq._priority_heap._heap_list[0]._priority == 1
def test_pq():
return PriorityQ(PQ_ITEM_LIST)
def empty_q():
"""Create empty BinaryHeap."""
from priorityq import PriorityQ
return PriorityQ()
def test_1(self):
""" test that insert puts the node in the queue """
p = PriorityQ()
n1 = Node(1)
p.insert(n1)
self.assertEqual(p.head._value, 1)
def test_insert_more():
priorityq = PriorityQ()
priorityq.insert(3, 8)
priorityq.insert(5, 2)
assert priorityq.list[0].value == 5
assert priorityq.list[1].value == 3
def filled_priority_q():
"""The fixture creates a filled priority queue."""
from priorityq import PriorityQ
new_pq = PriorityQ(TEST_SET[0])
return new_pq
def AStar(initial_state):
global COUNT, BACKLINKS
# priority queue with respective priority
# add any auxiliary data structures as needed
OPEN = PriorityQ()
# inserts the initial state with a priority of 0 (priority for initial state is irrelevant to algorithm)
OPEN.insert(initial_state, 0)
CLOSED = []
BACKLINKS[initial_state] = None
while OPEN.__len__() > 0:
# S = min-priority state (priority value gets discarded, only state is looked at)
S = OPEN.deletemin()[0]
while S in CLOSED:
S = OPEN.deletemin()
CLOSED.append(S)
# DO NOT CHANGE THIS SECTION: beginning
if Problem.GOAL_TEST(S):
print(Problem.GOAL_MESSAGE_FUNCTION(S))
path = backtrace(S)
return path, Problem.PROBLEM_NAME
# DO NOT CHANGE THIS SECTION: end
COUNT += 1
# if (COUNT % 32)==0:
if True:
# print(".",end="")
# if (COUNT % 128)==0:
if True:
print("COUNT = " + str(COUNT))
print("len(OPEN)=" + str(len(OPEN)))
print("len(CLOSED)=" + str(len(CLOSED)))
L = []
# looks at all possible new states from operations on S
# if the new state has not already been put on CLOSED, append to L
for op in Problem.OPERATORS:
if op.precond(S):
new_state = op.state_transf(S)
#print(new_state.__str__())
if not occurs_in(new_state, CLOSED):
L.append(new_state)
BACKLINKS[new_state] = S
# adds new states in L into OPEN with their priorities
# if any state already occurs in OPEN...
# if L's state has a lower priority, change OPEN's state priority to L's
# otherwise, keep OPEN's state in OPEN, ignore L's
for state in L:
g_state = G(state)
if OPEN.__contains__(state):
if g_state < OPEN.getpriority(state):
OPEN.remove(state)
else:
break
OPEN.insert(state, g_state)
def sample_priorityq():
"""Make a sample_priorityq for testing."""
from priorityq import PriorityQ
return PriorityQ()
def pq_setup_large():
pq = PriorityQ()
for num in range(1, 10001):
pq.insert(randint(1, 10))
return pq
def AStar(initial_state):
# print("In RecDFS, with depth_limit="+str(depth_limit)+", current_state is ")
# print(Problem.DESCRIBE_STATE(current_state))
global COUNT, BACKLINKS
#Tracks most efficient previous step
BACKLINKS[initial_state] = None
#already evaluated states
CLOSED = []
#currently discovered, not yet evaluated states
OPEN = PriorityQ()
#Calculate F, G, H scores
initialize_scores(initial_state)
#Only initial node is known as of now
OPEN.insert(initial_state, F_SCORE[initial_state])
while OPEN.isEmpty() != True:
S = OPEN.deletemin()
CLOSED.append(S)
if Problem.GOAL_TEST(S):
print(Problem.GOAL_MESSAGE_FUNCTION(S))
backtrace(S)
return #FOUND GOAL
COUNT += 1
if (COUNT % 32) == 0:
# if True:
# print(".",end="")
# if (COUNT % 128*128)==0:
if True:
print("COUNT = " + str(COUNT))
#print("len(OPEN)=" + str(len(OPEN))) #PriorityQ OPEN doesn't have len()
print("len(CLOSED)=" + str(len(CLOSED)))
for op in Problem.OPERATORS:
if op.precond(S):
new_state = op.state_transf(S)
if not occurs_in(new_state,
CLOSED): #ignore already evaluated neighbors
#find tentative score of neighbor
tentative_g_score = G_SCORE[S] + 1
if new_state not in G_SCORE: #Default INFINITY
BACKLINKS[
new_state] = S #First known path to new_state
elif tentative_g_score >= G_SCORE[new_state]:
continue #current path is not the best path to the neighbor
else:
BACKLINKS[
new_state] = S #Found better path to new_State
G_SCORE[new_state] = tentative_g_score
F_SCORE[new_state] = G_SCORE[new_state] + h_score_fn(
new_state)
# discovered a new State
if not OPEN.__contains__(new_state):
OPEN.insert(new_state, F_SCORE[new_state])
# print(Problem.DESCRIBE_STATE(new_state))
#print(OPEN)
#Failure, if goal_test has not succeeded until now
print("COULD NOT FIND GOAL")
return