signalNum = 2
r = 1
destinationNum = 12
#flow distribution
flow = Pd.ClassPdist(5, 15, totalNum)
# Initialize the CA model map
line = readfile.readline()
CAMap = [[] for i in range(xLength)]
for i in range(xLength):
line = readfile.readline()
#print line
stateList = line.split(",")
for j in range(yLength):
CAMap[i].append(CE.Cell(i, j, int(stateList[j])))
#draw the map with more details: walking zones, no walking zones, signals(crosswalk), stadium exits
#Exits of stadiums
stadExits = []
exitLocation = [[609, 426, 609, 440], [591, 400, 591,
414], [344, 416, 358, 416],
[212, 416, 226, 416], [153, 446, 153,
460], [103, 468, 103, 482],
[103, 630, 103, 644], [110, 811, 124, 811],
[444, 811, 458, 811], [689, 797, 689, 811]]
for i in range(stadiumExitNum):
e = StadiumExit.StadiumExit(exitLocation[i][0], exitLocation[i][1],
exitLocation[i][2], exitLocation[i][3], i + 1,
flow)
stadExits.append(e)
# crosswalk signals
def makePOSCAR(header, a0, dest):
""" Creates updated POSCAR with new lattice parameter """
cell = Cell().loadFromPOSCAR('POSCAR')
cell.setHeader(header)
cell.setA0(a0)
cell.sendToPOSCAR('%s/POSCAR' % dest)
def copy_without(dic, key):
dic2 = {}
for key_loop in dic.keys():
if key_loop != key:
dic2[key_loop] = dic[key_loop]
return dic2
def transform_keys_to_list(dic):
l = []
for key in dic.keys():
l += [key]
return l
MAZE1 = Maze([[Cell(0, 0, True, False),
Cell(1, 0, True, True)],
[Cell(0, 1, False, True),
Cell(1, 1, True, True)]])
MAZE2 = Maze([[
Cell(0, 0, False, False),
Cell(1, 0, False, False),
Cell(2, 0, True, True)
], [Cell(0, 1, False, True),
Cell(1, 1, True, True),
Cell(2, 1, True, True)]])
def __init__(self, size: int):
self.size = size
self.board = [[Cell.Cell(x, y) for x in range(size)]
for y in range(size)]
self.flat_board = [item for row in self.board for item in row]
# ============================================================================
# Main Program
# ============================================================================
print '\nAdd POSCAR, POTCAR and KPOINTS files to working directory.\n'
# Get user inputs
system = raw_input('System name: ')
print system, '\n'
# VASP Settings
ENCUT = 450
PREC = 'Accurate'
NPAR = 4
cell = Cell().loadFromPOSCAR('POSCAR')
nAtoms = sum(cell.elementCounts)
print '%d atoms detected' % nAtoms
if nAtoms > 20:
LREAL = 'Auto'
else:
LREAL = '.FALSE.'
print 'Using LREAL = %s' % LREAL, '\n'
# Get strains from user
perc = raw_input('Maximum percent strain (default 5): ')
if perc:
perc = float(perc)
else:
perc = 5.0
print str(perc) + ' %', '\n'
from Cell import *
if __name__ == "__main__":
# Initial statement
neighbor_array = [0, 0, 0, 0, 0, 0, 0, 0]
is_alive = 1
cell = Cell(neighbor_array, is_alive)
print cell
import pygame as pg
import math
from settings import *
from Cell import *
pg.init()
for j in range(rows):
for i in range(cols):
c = Cell(i, j)
grid.append(c)
current = grid[0]
running = True
clock = pg.time.Clock()
while running:
for event in pg.event.get():
if event.type == pg.QUIT:
running = False
clock.tick(fps)
screen.fill(BLACK)
for i in grid:
i.show()
current.visited = True
current.head()
next = current.checkSides()
if next:
next.visited = True
import time
import GameFinish
import HC
import sys
import Cell
import random
# Hardcoded information
DEBUG_MODE = True
BOARD_SIZE = 6
# Global variables
initial_cell = Cell.Cell(0, 0)
board = []
mines_left = round(BOARD_SIZE * BOARD_SIZE / 5)
total_mines = mines_left
def main(cell):
# Init the board itself
init_board()
# Set the mines on the board
init_mines()
# Get the user's command.
try:
while not is_board_solved():
from Piece import *
from Cell import *
from Pawn import *
from Rook import *
from Bishop import *
from Knight import *
from Queen import *
from King import *
cells = []
pieces = [Rook, Bishop, Knight, Queen, King, Knight, Bishop, Rook]
for i in range(8):
cells.append(Cell(i + 1, 2, Pawn)) # initializing white pawns at 2nd rank
cells.append(Cell(i + 1, 7, Pawn)) # initializing black pawns at 7th rank
cells.append(Cell(i + 1, 1, pieces[i])) # initializing white pieces at 1st rank
cells.append(Cell(i + 1, 8, pieces[i])) # initializing black pieces at 7th rank
def _notSolvedArrayInit(self):
self._notSolvedIndex = []
for r in range(len(self._array)):
for c in range(len(self._array[r])):
if not self._array[r][c]:
self._cells.append(Cell(r, c))
def detailed_transformation_analysis(self):
problem_helper = ProblemHelper()
problem_figures = problem_helper.get_problem_figures(self.problem)
solution_figures = problem_helper.get_solution_figures(self.problem)
ATTRIBUTES = [
'black_white_ratio', 'min_black_distance_l',
'min_black_distance_r', 'min_black_distance_t',
'min_black_distance_b', 'max_black_distance_l',
'max_black_distance_r', 'max_black_distance_t',
'max_black_distance_b', 'avg_black_distance_l',
'avg_black_distance_r', 'avg_black_distance_t',
'avg_black_distance_b'
]
# Instantiate A,B,C cells with their images
problem_cells = {}
for figure in problem_figures:
if "A.png" in figure.visualFilename:
problem_cells['a'] = Cell(Image.open(figure.visualFilename))
elif "B.png" in figure.visualFilename:
problem_cells['b'] = Cell(Image.open(figure.visualFilename))
elif "C.png" in figure.visualFilename:
problem_cells['c'] = Cell(Image.open(figure.visualFilename))
# Instantiate 1-6 cells with their images
solution_cells = {}
for figure in solution_figures:
if "1.png" in figure.visualFilename:
solution_cells['1'] = Cell(Image.open(figure.visualFilename))
elif "2.png" in figure.visualFilename:
solution_cells['2'] = Cell(Image.open(figure.visualFilename))
elif "3.png" in figure.visualFilename:
solution_cells['3'] = Cell(Image.open(figure.visualFilename))
elif "4.png" in figure.visualFilename:
solution_cells['4'] = Cell(Image.open(figure.visualFilename))
elif "5.png" in figure.visualFilename:
solution_cells['5'] = Cell(Image.open(figure.visualFilename))
elif "6.png" in figure.visualFilename:
solution_cells['6'] = Cell(Image.open(figure.visualFilename))
# Generate an image analysis for each problem cell
for _, problem_cell in problem_cells.items():
problem_cell.generate_cell_analysis()
# Generate an image analysis for each solution cell
for _, solution_cell in solution_cells.items():
solution_cell.generate_cell_analysis()
# Find ABC, AB, AC transformations where attributes remain close to the same
transformation_patterns = self.analyze_transformation_patterns(
problem_cells, ATTRIBUTES)
abc_pattern = transformation_patterns['abc']
ab_pattern = transformation_patterns['ab']
ac_pattern = transformation_patterns['ac']
# If any ABC attribute or AB, AC transormation attribute remains exactly
# the same, that attributes value should be expected in the solution.
# Remove possible solutions cells that do not match these patterns.
unsifted_cells = dict(solution_cells)
sifted_solution_cells = self.sift_solution_cells(
unsifted_cells, abc_pattern) # Sift for ABC pattern
sifted_solution_cells = self.sift_solution_cells(
sifted_solution_cells, ab_pattern) # Sift for AB pattern
sifted_solution_cells = self.sift_solution_cells(
sifted_solution_cells, ac_pattern) # Sift for AC pattern
if not sifted_solution_cells:
sifted_solution_cells = solution_cells
# Generate analyses for AB, AC transformations
ab_transformation_analysis = problem_cells[
'a'].generate_cell_transformation_analysis(problem_cells['b'])
ac_transformation_analysis = problem_cells[
'a'].generate_cell_transformation_analysis(problem_cells['b'])
# Predict the attributes of D that AD, BD, CD transformations will
# produce based on the observed AB, AC transformations
ab_ac_transform_applied_to_a = problem_cells[
'a'].predict_transformed_attrs(ab_transformation_analysis,
ac_transformation_analysis)
ac_transform_applied_to_b = problem_cells[
'b'].predict_transformed_attrs(ac_transformation_analysis)
ab_transform_applied_to_c = problem_cells[
'c'].predict_transformed_attrs(ab_transformation_analysis)
d_expected_attributes = {}
for attr in ATTRIBUTES:
total = ab_ac_transform_applied_to_a[
attr] + ac_transform_applied_to_b[
attr] + ab_transform_applied_to_c[attr]
average = total / 3
d_expected_attributes[attr] = average
# Generate similarity scores for each sifted solution compared to the
# average expected attributes of D
similarity_scores = {}
for key, solution in sifted_solution_cells.items():
solution_attrs = solution.get_attrs()
similarity_score = self.generate_similarity_score(
solution_attrs, d_expected_attributes)
similarity_scores[key] = similarity_score
# Choose the solution with the highest similarity score
proposed_solution = int(
max(similarity_scores, key=similarity_scores.get))
similarity = similarity_scores[str(proposed_solution)]
# If the combined similarity score is above the 95% threshold, then
# return the number of the proposed solution cell, otherwise, if we
# can sift out enough solutions, return the solution with the highest
# similarity score, otherwise, return -1
if proposed_solution and similarity > 0.95:
return proposed_solution
elif len(sifted_solution_cells) < 5:
return proposed_solution
else:
return -1
def AStar2(world, DEBUG_MODE): # start and goal are cells
if(DEBUG_MODE == 1):
print "running AStar2"
start = world.getStart()
goal = world.getGoal()
if(DEBUG_MODE == 1):
print goal.getCoord()
frontier = [] # nodes
visited = [] # nodes
numberMoves = 0
firstNode = Node(start, Cell(Coord(-1, -1), -1), [], 0, 0) # Last 0 is robot dir!
frontier.append(firstNode)
while len(frontier) is not 0:
# HOPEFULLY ths sorts the list so that the least g+h is first
frontier.sort(key=lambda node: node.total())
# for node in frontier:
# print node
# after frontier is sorted the node with the lowest g+h becomes current
current = frontier[0]
# remove the node being looked at from the frontier
del frontier[0]
visited.append(current) # add it to the visited list
if(DEBUG_MODE == 1):
print "------------------------------"
print "len of frontier"
print len(frontier)
print "len of visited"
print len(visited)
print "current Coords"
print current.getCell().getCoord()
if(current.getCell().getIsGoal()): # if its the goal, we are done
if(DEBUG_MODE == 1):
print "Goal Found!"
return (visited, numberMoves)
# print anydup(visited)
# raw_input()
if(DEBUG_MODE == 1):
print "Building neighbors..."
neighborCells = world.getNeighbors(current.getCell().getCoord())
neighborNodes = cellsToNodes(current, neighborCells, current.getRobotDir(), False)
bashCells = world.getBashNeighbors(current.getCell().getCoord())
bashNodes = cellsToNodes(current, bashCells, current.getRobotDir(), True)
moveNodes = list(neighborNodes + bashNodes)
numberMoves += len(moveNodes)
if(DEBUG_MODE == 1):
print len(moveNodes)
neibsRm = []
frontRm = []
for i in range(len(moveNodes)):
neighborNode = moveNodes[i]
for j in range(len(visited)):
visitNode = visited[j]
if neighborNode.getCell().getCoord() != visitNode.getCell().getCoord(): # I think This is where we are accidentally adding tons of things to visited
for f in range(len(frontier)):
frontNode = frontier[f]
if neighborNode.getCell().getCoord() == frontNode.getCell().getCoord():
if neighborNode.total() < frontNode.total():
frontRm.append(f)
else:
neibsRm.append(i)
else:
neibsRm.append(i)
removedFront = 0
for rm in list(set(frontRm)):
if(DEBUG_MODE == 1):
print "FrontRM:",rm - removedFront
del frontier[rm - removedFront]
removedFront += 1
removedNeibs = 0
for rm in list(set(neibsRm)):
if(DEBUG_MODE == 1):
print "MovesRM:",rm - removedNeibs
del moveNodes[rm - removedNeibs]
removedNeibs += 1
if(DEBUG_MODE == 1):
print "len of moveNodes"
print len(moveNodes)
frontier += moveNodes
if(DEBUG_MODE == 1):
print "Goal not found!"
return ([], numberMoves)
from Cell import *
import time
#from Grid import *
grid = [[
Cell(0, 0),
Cell(1, 0),
Cell(2, 0),
Cell(3, 1),
Cell(4, 1),
Cell(5, 1),
Cell(6, 2),
Cell(7, 2),
Cell(8, 2)
],
[
Cell(9, 0),
Cell(10, 0),
Cell(11, 0),
Cell(12, 1),
Cell(13, 1),
Cell(14, 1),
Cell(15, 2),
Cell(16, 2),
Cell(17, 2)
],
[
Cell(18, 0),
Cell(19, 0),
Cell(20, 0),
Cell(21, 1),
def AStar2(world): # start and goal are cells
print "running AStar2"
start = world.getStart()
goal = world.getGoal()
print goal.getCoord()
frontier = [] # nodes
visited = [] # nodes
firstNode = Node(start, Cell(Coord(-1, -1), -1), [], 0, 0) # Last 0 is robot dir!
frontier.append(firstNode)
while len(frontier) is not 0:
# HOPEFULLY ths sorts the list so that the least g+h is first
frontier.sort(key=lambda node: node.total())
# for node in frontier:
# print node
# after frontier is sorted the node with the lowest g+h becomes current
current = frontier[0]
# remove the node being looked at from the frontier
frontier.remove(current)
visited.append(current) # add it to the visited list
print "------------------------------"
print "len of frontier"
print len(frontier)
print "len of visited"
print len(visited)
print "current Coords"
print current.getCell().getCoord()
if(current.getCell().getIsGoal()): # if its the goal, we are done
visited.append(current)
print "Goal Found!"
return visited
# print anydup(visited)
# raw_input()
print "Building neighbors..."
neighborCells = world.getNeighbors(current.getCell().getCoord())
neighborNodes = cellsToNodes(current, neighborCells, current.getRobotDir(), False)
bashCells = world.getBashNeighbors(current.getCell().getCoord())
bashNodes = cellsToNodes(current, bashCells, current.getRobotDir(), True)
moveNodes = neighborNodes + bashNodes
for moveNode in moveNodes: #for each possible move from the current cell
for visitNode in visited: #see if that move would put us in a cell thats already been visited
if moveNode.getCell().getCoord() is not visitNode.getCell().getCoord(): #if we've not visited this cell before
for frontNode in frontier: #ee if the move would put us in a cell that is already in the frontier
if moveNode.getCell().getCoord() is frontNode.getCell().getCoord(): # if it is
if moveNode.getCost() < frontNode.getCost(): # check if the new move is cheaper than the old move
frontier.remove(frontNode) # if it is, remove the old move from frontier
break
else: # otherwise, remove the new node from the list of nodes that will be added to frontier
# print "Removing: " + str(moveNode)
if moveNode in moveNodes:
moveNodes.remove(moveNode)
break
else: # if the node we are looking at would put us in a cell thats already been visited
#print "Removing: " + str(moveNode)
if moveNode in moveNodes:
moveNodes.remove(moveNode) # remove the new node from the list of nodes to be added to the frontier
print "len of moveNodes"
print len(moveNodes)
frontier += moveNodes
print "Goal not found!"
def new_cell(self, cellAttr):
cellAttr["module"] = self
# create new cell here
cell = Cell.Cell(cellAttr)
self.__cells[cell.name] = cell
return cell
def init_cells(self):
return [[
Cell(i * self.cell_size, j * self.cell_size,
random.choice([True, False, False, False]), self.cell_size)
for i in range(self.enviroment_width)
] for j in range(self.enviroment_height)]
def __init__(self):
self._cells = [[Cell() for i in range(7)] for j in range(7)]
def make_maze(self):
for x in range(self.maze_row):
cells = []
for y in range(self.maze_col):
cells.append(Cell.Cell(Point(x, y)))
self.maze_map.append(cells)
def makeGrid(self):
for i in range(20):
row = [Cell(j, i) for j in range(20)]
self._grid.append(row)
def solve_mine(gamemap, result):
def map_to_list(field):
field = field[1:]
another_map = []
line = []
for element in field:
if element == "\n":
another_map.append(line)
line = []
continue
if element != ' ':
if element.isdigit():
line.append(int(element))
else:
line.append(element)
return another_map
def check_boundary(x, y):
return (-1 < x < len(cellmap)) and (-1 < y < len(cellmap[row]))
def open(row, column):
if result[row][column] == 'x':
print(row, column)
sys.exit('KABOOM!')
return result[row][column]
gamemap = map_to_list(gamemap)
result = map_to_list(result)
cellmap = list(gamemap)
print('initial map')
print("\n".join(" ".join(map(str, row)) for row in cellmap))
for row in range(len(cellmap)):
for column in range(len(cellmap[row])):
cellmap[row][column] = Cell(cellmap[row][column], (row, column))
# print('*********************************************************')
for row in range(len(cellmap)):
for column in range(len(cellmap[row])):
if cellmap[row][column].weight == 0:
for i in range(-1, 2):
for j in range(-1, 2):
x = row + i
y = column + j
if check_boundary(x, y):
cellmap[x][y].weight = open(x, y)
cellmap[x][y].is_open = True
# print('*********************************************************')
smth_changed = True
while smth_changed:
smth_changed = False
groups = []
for row in range(len(cellmap)):
for column in range(len(cellmap[row])):
if cellmap[row][column].is_open:
group = Group()
for i in range(-1, 2):
for j in range(-1, 2):
x = row + i
y = column + j
if check_boundary(
x, y) and (cellmap[x][y].weight == '?'
or cellmap[x][y].weight == 'x'):
group.cells.add(cellmap[x][y])
group.weight = cellmap[row][column].weight
if len(group.cells) > 0:
groups.append(group)
repeat = True
# print("********************begin of func********************")
while repeat:
repeat = False
for current_group in groups:
for compare_group in groups:
if current_group != compare_group:
if current_group.cells == compare_group.cells and current_group.weight == compare_group.weight:
# print("deleting", compare_group)
groups.remove(compare_group)
continue
if current_group.cells <= compare_group.cells:
compare_group.cells -= current_group.cells
compare_group.weight -= current_group.weight
repeat = True
continue
elif current_group.cells >= compare_group.cells:
current_group.cells -= compare_group.cells
current_group.weight -= compare_group.weight
repeat = True
continue
else:
if not current_group.cells.isdisjoint(
compare_group.cells):
# print("MEETING", current_group, 'and', compare_group)
if current_group.weight > compare_group.weight:
bigger = current_group
smaller = compare_group
# print('bigger is', bigger)
else:
bigger = compare_group
smaller = current_group
# print('bigger is', bigger)
group = Group()
group.cells = current_group.cells.intersection(
compare_group.cells)
# print ('New group cells is', group.cells)
group.weight = bigger.weight - (
len(bigger.cells) - len(group.cells))
# print('New group weight is', group.weight)
if group.weight == smaller.weight:
groups.append(group)
bigger.cells -= group.cells
bigger.weight -= group.weight
smaller.cells -= group.cells
smaller.weight -= group.weight
# print('saving', bigger, smaller, group)
repeat = True
# print("***********************end of func************************")
for group in groups:
if group.weight == len(group.cells):
for cell in group.cells:
row = cell.pos[0]
column = cell.pos[1]
cellmap[row][column].is_mine = True
cellmap[row][column].weight = 'x'
if group.weight == 0:
for cell in group.cells:
row = cell.pos[0]
column = cell.pos[1]
cellmap[row][column].weight = open(row, column)
cellmap[row][column].is_open = True
smth_changed = True
# print('*********************************************************')
#
# for row in cellmap:
# print(row)
# print('*********************************************************')
for row in range(len(cellmap)):
for column in range(len(cellmap[row])):
if cellmap[row][column].weight == '?':
print("solved")
return ("?")
print("solved")
return "\n".join(" ".join(map(str, row)) for row in cellmap)
