def test_h_manhattan(self):
a = E.State([[3, 1, 2], [4, 5, 0], [6, 7, 8]])
self.assertTrue(a.h_manhattan() == 3)
b = E.State([[8, 7, 6], [5, 4, 3], [2, 1, 0]])
self.assertTrue(b.h_manhattan() == 20)
c = E.State([[7, 2, 4], [5, 0, 6], [8, 3, 1]])
self.assertTrue(c.h_manhattan() == 18)
print("Manhattan passes!")
def test_custom(self):
a = E.State([[0, 2, 1], [3, 7, 8], [4, 6, 5]])
self.assertTrue(a.h_manhattan() == 8)
self.assertTrue(a.h_custom() == 10)
b = E.State([[8, 7, 6], [5, 4, 3], [2, 1, 0]])
self.assertTrue(b.h_manhattan() == 20)
self.assertTrue(b.h_custom() == 22)
print("custom tests passed")
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 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 = []
CLOSED = []
BACKLINKS[initial_state] = -1
OPEN.append(initial_state)
PRI.append(0)
G = {}
F = {}
G[initial_state] = 0
while len(OPEN) > 0:
index = findMin()
S = OPEN[index]
del OPEN[index]
del PRI[index]
while S in CLOSED:
index = findMin()
S = OPEN[index]
del OPEN[index]
del PRI[index]
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
COUNT += 1
for op in Problem.OPERATORS:
if op.precond(S):
new_state = op.state_transf(S)
if not (new_state in OPEN) and not (new_state in CLOSED):
G[new_state] = G[S] + 1
F[new_state] = G[new_state] + heuristics(new_state)
BACKLINKS[new_state] = S
OPEN.append(new_state)
PRI.append(F[new_state])
elif BACKLINKS[new_state] != -1:
other_parent = BACKLINKS[new_state]
temp = F[new_state] - G[other_parent] + G[S]
if temp < F[new_state]:
G[new_state] = G[new_state] - F[new_state] + temp
F[new_state] = temp
BACKLINKS[new_state] = S
if new_state in CLOSED:
OPEN.append(new_state)
PRI.append(F[new_state])
CLOSED.remove(new_state)
def test_h_euclidian(self):
a = E.State([[8, 1, 2], [3, 4, 5], [6, 7, 0]])
self.assertTrue(a.h_euclidian() == m.sqrt(8))
b = E.State([[3, 1, 2], [4, 5, 0], [6, 7, 8]])
self.assertTrue(b.h_euclidian() == 3)
c = E.State(([[8, 7, 6], [5, 4, 3], [2, 1, 0]]))
result = c.h_euclidian()
#print(result)
#self.assertTrue(c.h_euclidian() == 3*m.sqrt(8) + 8)
print("Euclidian passes!")
def backtrace(S):
global BACKLINKS
path = []
while not S == -1:
path.append(S)
S = BACKLINKS[Problem.HASHCODE(S)]
path.reverse()
print("Solution path: ")
for s in path:
print(Problem.DESCRIBE_STATE(s))
return path
def test_isSolvable(self):
a = E.State([[3, 1, 2], [4, 5, 0], [6, 7, 8]])
self.assertTrue(isSolvable(a))
b = E.State([[8, 7, 6], [5, 4, 3], [2, 1, 0]])
self.assertTrue(isSolvable(b))
c = E.State([[0, 1, 2], [3, 4, 5], [6, 8, 7]])
self.assertFalse(isSolvable(c))
d = E.State([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
self.assertTrue(isSolvable(d))
e = E.State([[8, 7, 6], [5, 0, 3], [4, 2, 1]])
self.assertFalse(isSolvable(e))
print("tests passed")
def runAStar():
initial_state = puzzle.CREATE_INITIAL_STATE()
print("Initial State:")
print(Problem.DESCRIBE_STATE(initial_state))
if Problem.PROBLEM_NAME == "Basic Eight Puzzle" and Problem.CHECK_INI_STATE(
initial_state) % 2 != 0:
print("This particular puzzle is not solvable.")
return
global COUNT, BACKLINKS
COUNT = 0
BACKLINKS = {}
IterativeAStar(initial_state)
print(str(COUNT) + " states examined.")
def AStar(initial_state):
global COUNT, BACKLINKS, MAX_OPEN_LENGTH
# STEP 1. Put the start state on a list OPEN
OPEN = PriorityQB()
OPEN.insert(initial_state, heur(initial_state))
x = OPEN.getpriority(initial_state)
print(x)
CLOSED = []
BACKLINKS[initial_state] = None
moves = {initial_state: 0}
# STEP 2. If OPEN is empty, output “DONE” and stop.
while len(OPEN) != 0:
report(OPEN, CLOSED, COUNT)
if len(OPEN) > MAX_OPEN_LENGTH: MAX_OPEN_LENGTH = len(OPEN)
# STEP 3. Select the first state on OPEN and call it S.
# Delete S from OPEN.
# Put S on CLOSED.
# If S is a goal state, output its description
S = OPEN.deletemin()
S = S[0]
CLOSED.append(S)
if Problem.GOAL_TEST(S):
print(Problem.GOAL_MESSAGE_FUNCTION(S))
path = backtrace(S)
print('Length of solution path found: ' + str(len(path) - 1) +
' edges')
return
COUNT += 1
# STEP 4. Generate the list L of successors of S and delete
# from L those states already appearing on CLOSED.
L = []
for op in Problem.OPERATORS:
if op.precond(S):
new_state = op.state_transf(S)
if not (new_state in CLOSED):
priority = getPriority(new_state, moves[S] + 1)
if new_state in OPEN and priority < OPEN.getpriority(
new_state):
OPEN.remove(new_state)
if new_state not in OPEN:
BACKLINKS[new_state] = S
moves[new_state] = moves[S] + 1
OPEN.insert(new_state, priority)
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 = PriorityQueue()
OPEN.put((0,initial_state))
SEEN = []
CLOSED = []
G_SCORE = {}
G_SCORE[initial_state] = 0
BACKLINKS[initial_state] = -1
MAX_GSCORE = 0
while not OPEN.empty():
S = OPEN.get()[1]
while S in CLOSED:
S = OPEN.get()[1]
CLOSED.append(S)
# DO NOT CHANGE THIS SECTION: begining
if Problem.GOAL_TEST(S):
print(Problem.GOAL_MESSAGE_FUNCTION(S))
# path = backtrace(S)
print(len(BACKLINKS))
return path, Problem.PROBLEM_NAME
# DO NOT CHANGE THIS SECTION: end
COUNT += 1
# TODO: finish A* implementation
for op in Problem.OPERATORS:
if op.precond(S):
next_state = op.state_transf(S)
# This is a valid move so you need to calculate F(n) = G(n) + H(n)
if next_state not in SEEN and next_state not in CLOSED:
if S in G_SCORE:
next_G_SCORE = 1 + G_SCORE[S]
else:
next_G_SCORE = MAX_GSCORE
G_SCORE[next_state] = next_G_SCORE
if next_G_SCORE > MAX_GSCORE:
MAX_GSCORE = next_G_SCORE
next_F_SCORE = next_G_SCORE + heuristics(next_state)
OPEN.put((next_F_SCORE, next_state))
SEEN.append(next_state)
BACKLINKS[next_state] = S
print(S)
def runAStar():
print("Initial State:")
print(Problem.DESCRIBE_STATE(init_state))
global COUNT, BACKLINKS
COUNT = 0
BACKLINKS = {}
IterateAStar(init_state)
print(str(COUNT)+" states examined.")
def occurs_in(s1, lst):
index = 0
for s2 in lst:
if Problem.DEEP_EQUALS(s1, s2[0]):
return index
else:
index = index + 1
return -1
def IterativeAStar(initial_state):
global COUNT, BACKLINKS
OPEN = [initial_state]
CLOSED = []
BACKLINKS[Problem.HASHCODE(initial_state)] = -1
g = {Problem.HASHCODE(initial_state): 0}
while OPEN != []:
S = OPEN[0]
del OPEN[0]
CLOSED.append(S)
if Problem.GOAL_TEST(S):
print(Problem.GOAL_MESSAGE_FUNCTION(S))
backtrace(S)
return
COUNT += 1
if (COUNT % 32) == 0:
print(".", end="")
if (COUNT % 128) == 0:
print("COUNT = " + str(COUNT))
print("len(OPEN)=" + str(len(OPEN)))
print("len(CLOSED)=" + str(len(CLOSED)))
L = []
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 occurs_in(new_state, CLOSED):
L.append(new_state)
BACKLINKS[Problem.HASHCODE(new_state)] = S
g[Problem.HASHCODE(new_state)] = g[Problem.HASHCODE(S)] + 1
#Uncomment for debugging:
#print(Problem.DESCRIBE_STATE(new_state))
for s2 in L:
for i in range(len(OPEN)):
if Problem.DEEP_EQUALS(s2, OPEN[i]):
del OPEN[i]
break
OPEN = L + OPEN
OPEN = sorted(OPEN,
key=lambda s: g[Problem.HASHCODE(s)] + heuristics(s))
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 runAStar():
# initial_state = Problem.CREATE_INITIAL_STATE(keyVal)
initial_state = Problem.CREATE_INITIAL_STATE()
print("Initial State:")
print(initial_state)
global COUNT, BACKLINKS
COUNT = 0
BACKLINKS = {}
path, name = AStar(initial_state)
print(str(COUNT) + " states examined.")
return path, name
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 AStar(initial_state):
counter = count() # 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 = PriorityQueue()
CLOSED = []
OPEN.put((0, next(counter), initial_state))
BACKLINKS[initial_state] = -1
while not OPEN.empty():
COUNT += 1
S = OPEN.get()
while S[2] in CLOSED:
S = OPEN.get()
cost = S[0]
S = S[2]
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)
h += cost
new_pq_item = (h, next(counter), new_state)
OPEN.put(new_pq_item)
BACKLINKS[new_state] = S
def AStar(initial_state):
global COUNT, BACKLINKS
# priority queue with respective priority
# add any auxiliary data structures as needed
OPEN = PriorityQueue()
OPEN.put((heuristics(initial_state), initial_state))
OPENlist = [initial_state]
#OPEN.put(initial_state)
CLOSED = []
BACKLINKS[initial_state] = -1
prioritycount = 0
while not OPEN.empty():
S = OPEN.get()[1]
OPENlist.remove(S)
while S in CLOSED:
S = OPEN.get()[1]
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
for op in Problem.OPERATORS:
prioritycount += 2
#print(prioritycount)
#print("Trying operator: "+op.name)
if op.precond(S):
new_state = op.state_transf(S)
if not (new_state in CLOSED) and not (new_state in OPENlist):
#print(heuristics(new_state) +prioritycount)
#print(new_state)
#print(OPEN.qsize())
OPEN.put((heuristics(new_state), new_state))
OPENlist.append(new_state)
BACKLINKS[new_state] = S
def runAStar():
initial_state = Problem.CREATE_INITIAL_STATE()
#Use an externally specified initial state
if len(sys.argv) > 3:
initial_state_file = importlib.import_module(sys.argv[3])
initial_state = initial_state_file.CREATE_INITIAL_STATE()
print("Initial State:")
print(initial_state)
global COUNT, BACKLINKS
COUNT = 0
BACKLINKS = {}
path, name = AStar(initial_state)
print(str(COUNT) + " states examined.")
return path, name
def runAStar():
global Problem
initial_state = Problem.CREATE_INITIAL_STATE()
if not isSolvable(initial_state):
print(
"There is no possible solution to this puzzle. Please choose a different initial state."
)
return
print("Initial State:")
print(initial_state)
global COUNT, BACKLINKS, MAX_OPEN_LENGTH
COUNT = 0
BACKLINKS = {}
MAX_OPEN_LENGTH = 0
AStar(initial_state)
print(str(COUNT) + " states expanded.")
print('MAX_OPEN_LENGTH = ' + str(MAX_OPEN_LENGTH))
def test_h_hamming(self):
a = E.State([[0, 3, 2], [1, 7, 4], [8, 5, 6]])
self.assertTrue(a.h_hamming() == 7)
b = E.State([[0, 1, 3], [4, 6, 7], [5, 8, 2]])
self.assertTrue(b.h_hamming() == 7)
c = E.State([[-2, -5, -6], [99, 82, 45], [99, 17, 56]])
self.assertTrue(c.h_hamming() == 8)
d = E.State([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
self.assertTrue(d.h_hamming() == 0)
e = E.State(([[0, 1, 2], [4, 3, 5], [7, 6, 8]]))
self.assertTrue(e.h_hamming() == 4)
f = E.State([[3, 1, 2], [4, 5, 0], [6, 7, 8]])
self.assertTrue(f.h_hamming() == 3)
print("Hamming tests Passed!")
# A* Search of a problem space.
# The Problem should be given in a separate Python
# file using the "QUIET" file format.
# See the TowerOfHanoi.py example file for details.
# Examples of Usage:
# python3 AStar.py EightPuzzleWithHeuristics h_manhattan puzzle10a
import sys
from queue import PriorityQueue
# DO NOT CHANGE THIS SECTION
if sys.argv==[''] or len(sys.argv)<3:
import EightPuzzleWithHeuristics as Problem
heuristics = lambda s: Problem.HEURISTICS['h_manhattan'](s)
initial_state = Problem.CREATE_INITIAL_STATE()
else:
import importlib
Problem = importlib.import_module(sys.argv[1])
heuristics = lambda s: Problem.HEURISTICS[sys.argv[2]](s)
initial_state = Problem.State(importlib.import_module(sys.argv[3]).CREATE_INITIAL_STATE())
print("\nWelcome to AStar")
COUNT = None
BACKLINKS = {}
# DO NOT CHANGE THIS SECTION
def runAStar():
import EightPuzzleWithHeuristics as p CREATE_INITIAL_STATE = lambda: p.State([3, 1, 2, 6, 8, 7, 5, 4, 0])
import EightPuzzleWithHeuristics as Problem #puzzle16a.py: CREATE_INITIAL_STATE = lambda: Problem.State([0, 8, 2, 1, 7, 4, 3, 6, 5])
# Ying Dang
# CSE 415 A, Spring 2016
# Homework 3: Part II
#3. A Star COMPLETE
import sys
if len(sys.argv)<2:
# Use defaults
import EightPuzzleWithHeuristics as Problem
init_state = Problem.CREATE_INITIAL_STATE()
heuristic_choice = 'h_euclidean'
heuristics = Problem.HEURISTICS[heuristic_choice]
else:
# Use command line parameters
import importlib
Problem = importlib.import_module(sys.argv[1])
Initial_state = importlib.import_module(sys.argv[3])
init_state = Initial_state.CREATE_INITIAL_STATE()
heuristic_choice = sys.argv[2]
heuristics = Problem.HEURISTICS[heuristic_choice]
print("\nWelcome to A Star")
COUNT = None
BACKLINKS = {}
def runAStar():
print("Initial State:")
def IterateAStar(initial_state):
global COUNT, BACKLINKS
OPEN = [[initial_state, heuristics(initial_state)]]
CLOSED = []
# print(initial_state)
COST = {Problem.HASHCODE(initial_state): 0}
BACKLINKS[Problem.HASHCODE(initial_state)] = -1
while OPEN != []:
S = OPEN[0]
del OPEN[0]
CLOSED.append(S)
if Problem.GOAL_TEST(S[0]):
print(Problem.GOAL_MESSAGE_FUNCTION(S[0]))
backtrace(S[0])
return
COUNT += 1
if (COUNT % 32)==0:
print(".",end="")
if (COUNT % 128)==0:
print("COUNT = "+str(COUNT))
print("len(OPEN)="+str(len(OPEN)))
print("len(CLOSED)="+str(len(CLOSED)))
L = []
# for each possible child in S (state)
for op in Problem.OPERATORS:
# is a child
if op.precond(S[0]):
new_state = op.state_transf(S[0])
# index of occurrence in CLOSED
occur_closed = occurs_in(new_state, CLOSED)
# index of occurence in OPEN
occur_open = occurs_in(new_state, OPEN)
# the moves made so far + 1
new_cost = COST[Problem.HASHCODE(S[0])] + 1
# place in neighbor if new state
if occur_closed == -1 and occur_open == -1:
L.append([new_state, heuristics(new_state)])
BACKLINKS[Problem.HASHCODE(new_state)] = S[0]
COST[Problem.HASHCODE(new_state)] = new_cost
elif occur_open > -1:
# check to see if this move is more efficient
if COST[Problem.HASHCODE(new_state)] > new_cost:
COST[Problem.HASHCODE(new_state)] = new_cost
OPEN[occur_open] = [new_state, new_cost]
# for all neighbors found, if it equals to states in OPEN,
# delete it, shouldn't occur but juuuuust in case...
for s2 in L:
for i in range(len(OPEN)):
if Problem.DEEP_EQUALS(s2, OPEN[i][0]):
del OPEN[i]; break
OPEN = L + OPEN
OPEN.sort(key=lambda x: x[1])
import EightPuzzleWithHeuristics as Problem # puzzle1a: CREATE_INITIAL_STATE = lambda: Problem.State([1, 0, 2, 3, 4, 5, 6, 7, 8])
import EightPuzzleWithHeuristics as p CREATE_INITIAL_STATE = lambda: p.State([4, 5, 0, 1, 2, 8, 3, 7, 6])
import EightPuzzleWithHeuristics as Problem #puzzle10a.py: CREATE_INITIAL_STATE = lambda: Problem.State([4, 5, 0, 1, 2, 3, 6, 7, 8])
import EightPuzzleWithHeuristics as Problem # puzzle4a: CREATE_INITIAL_STATE = lambda: Problem.State([1, 4, 2, 3, 7, 0, 6, 8, 5])
