def runSimulation(start, solution):
"""
Returns minumum number of time steps needed to get to solution
"""
scoredict = {}
solutionNodes = []
lowest = 15
currentmin = 20
pare_node = Node(start)
m = (0, pare_node)
heappush(queue, m)
tempnode = heappop(queue)
tempchildren = generateAllChildren(tempnode[1].cargo)
for k in range(len(tempchildren)):
score = bart(tempchildren[k])
initnode = Node(tempchildren[k], tempnode[1])
v = (score, initnode)
heappush(queue, v)
while (queue != []):
pare_node = heappop(queue)
children = generateAllChildren(pare_node[1].cargo)
c = selectChildren(children)
print
print c
for i in range(len(c)):
# create nodes
node = Node(c[i], pare_node[1])
if (c[i] == solution):
solutionNodes.append(node)
print "length of solutionNodes: ", len(solutionNodes)
else:
score = bart(c[i])
l = (score, node)
# print score
if (len(queue) <= maxqueue):
heappush(queue, l)
else:
heappushpop(queue, l)
inversions = 0
for j in range(len(solutionNodes)):
node = solutionNodes[j]
while((node.prev != None) and (inversions < lowest)):
print "Step", node
node = node.prev
inversions += 1
if ((inversions < lowest) and (node.prev == None)):
lowest = inversions
print "Inversions: ", inversions
j += 1
print "Start: ", start
def runSimulation(start, solution):
"""
Returns minumum number of time steps needed to get to solution
"""
solutionNodes = []
lowest = 15
pare_node = Node(start)
m = (0, pare_node)
heappush(queue, m)
solution_found = False
while (queue != [] and (solution_found == False)):
pare_node = heappop(queue)
children = generateAllChildren(pare_node[1].cargo)
c = selectChildren(children)
for i in range(len(c)):
score = bart(c[i])
node = Node(c[i], pare_node[1])
l = (score, node)
if (len(queue) <= maxqueue):
heappush(queue, l)
else:
heappushpop(queue, l)
if (c[i] == solution):
print "Solution: ", c[i]
solution_found = True
inversions = 0
while(node.prev != None):
print node
node = node.prev
inversions += 1
print "Inversions: ", inversions
def runSimulation(start, solution):
"""
Returns minumum number of time steps needed to get to solution
"""
solutionNodes = []
pare_node = Node(start)
m = (0, pare_node)
heappush(queue, m)
while (queue != [] and (len(solutionNodes) < 2)):
pare_node = heappop(queue)
children = generateAllChildren(pare_node[1].cargo)
c = selectChildren(children)
for i in range(len(c)):
# create nodes
node = Node(c[i], pare_node[1])
if (c[i] == solution):
solutionNodes.append(node)
print "length of solutionNodes: ", len(solutionNodes)
else:
score = bart(c[i])
l = (score, node)
if (len(queue) <= maxqueue):
heappush(queue, l)
else:
heappushpop(queue, l)
# # print all solutions
# for j in range(len(solutionNodes)):
# inversions = 0
# node = solutionNodes[j]
# while((node.prev != None)):
# print "Step", node
# node = node.prev
# inversions += 1
# print "Inversions: ", inversions
# j += 1
# only print shortest solutions
lowest = 50
inversions = 0
for j in range(len(solutionNodes)):
node = solutionNodes[j]
while((node.prev != None) and (inversions < lowest)):
print "Step", node
node = node.prev
inversions += 1
if (inversions < lowest):
lowest = inversions
print "Inversions: ", inversions
j += 1
def selectChildren(children):
scores = []
# calculate "fitness" scores
for i in range(len(children)):
s = bart(children[i])
scores.append(s)
# check which 3 genomes have the best scores
dictionary = heapq.nsmallest(beam, zip(scores, children))
# put the best genomes in a list before returning
best_children = []
for j in range(len(dictionary)):
best_children.append(dictionary[j][1])
children = []
scores = []
return best_children
def runSimulation(start, solution):
"""
Returns minumum number of time steps needed to get to solution
"""
solutionNodes = []
pare_node = Node(start)
# TODO: make tuple for rootnode (score, generation, genome)?
m = (0, pare_node)
heappush(queue, m)
while (queue != [] and (len(solutionNodes) <= 10000)):
pare_node = heappop(queue)
children = generateAllChildren(pare_node[1].cargo)
c = selectChildren(children)
for i in range(len(c)):
# create nodes
node = Node(c[i], pare_node[1])
if (c[i] == solution):
solutionNodes.append(node)
else:
score = bart(c[i])
l = (score, node)
if (len(queue) <= maxqueue):
heappush(queue, l)
else:
heappushpop(queue, l)
lowest = 50
inversions = 0
for j in range(len(solutionNodes)):
node = solutionNodes[j]
while((node.prev != None) and (inversions < lowest)):
print "Step", node
node = node.prev
inversions += 1
if (inversions < lowest):
lowest = inversions
print "Inversions: ", inversions
j += 1
