def test_sequential_rule_2d(self):
cellular_automaton = cpl.init_simple2d(3, 3)
r = cpl.AsynchronousRule(
apply_rule=lambda n, c, t: cpl.totalistic_rule(n, k=2, rule=126),
update_order=range(0, 9))
cellular_automaton = cpl.evolve2d(cellular_automaton,
timesteps=18,
neighbourhood='Moore',
apply_rule=r.apply_rule)
expected = [[[0, 0, 0], [0, 1, 0], [0, 0, 0]],
[[1, 0, 0], [0, 1, 0], [0, 0, 0]],
[[1, 1, 0], [0, 1, 0], [0, 0, 0]],
[[1, 1, 1], [0, 1, 0], [0, 0, 0]],
[[1, 1, 1], [1, 1, 0], [0, 0, 0]],
[[1, 1, 1], [1, 1, 0], [0, 0, 0]],
[[1, 1, 1], [1, 1, 1], [0, 0, 0]],
[[1, 1, 1], [1, 1, 1], [1, 0, 0]],
[[1, 1, 1], [1, 1, 1], [1, 0, 0]],
[[1, 1, 1], [1, 1, 1], [1, 0, 0]],
[[0, 1, 1], [1, 1, 1], [1, 0, 0]],
[[0, 1, 1], [1, 1, 1], [1, 0, 0]],
[[0, 1, 1], [1, 1, 1], [1, 0, 0]],
[[0, 1, 1], [1, 1, 1], [1, 0, 0]],
[[0, 1, 1], [1, 1, 1], [1, 0, 0]],
[[0, 1, 1], [1, 1, 1], [1, 0, 0]],
[[0, 1, 1], [1, 1, 1], [1, 0, 0]],
[[0, 1, 1], [1, 1, 1], [1, 1, 0]]]
np.testing.assert_equal(expected, cellular_automaton.tolist())
def _create_ca(self, expected, rule, neighbourhood):
steps, _, _ = expected.shape
cellular_automaton = np.array([expected[0]])
return cpl.evolve2d(
cellular_automaton,
timesteps=steps,
r=1,
neighbourhood=neighbourhood,
apply_rule=lambda n, c, t: cpl.totalistic_rule(n, k=2, rule=rule))
def run_GOL(
initial_condition: np.ndarray,
timesteps: list,
board_width: int,
board_height: int,
rules: str,
):
"""
Runs a game of life simulation for the given time steps
:param initial_condition: the gene from the GA
:param timesteps: the initial time step, followed by the difference from initial to each next
:param board_width: the width of the board
:param board_height: the height of the board
:param rules: rules to use for the simulation
:return: Chromosome object for that individual
"""
full_board = np.zeros((1, board_width * 2, board_height * 2))
# shape from list to array
initial_board = initial_condition.reshape((board_height, board_width))
# Needs to be this format for the cpl package
initial_board = np.array([initial_board])
full_board[:,
int(board_width / 2):int(board_width * 1.5),
int(board_height / 2):int(board_height * 1.5)] = initial_board
rule_function = None
if rules == "b3s23":
rule_function = game_of_life_rule
elif rules == "b38s23":
rule_function = b38s23
elif rules == "b36s23":
rule_function = b36s23
# evolve the cellular automaton for max given time steps
result = cpl.evolve2d(
full_board,
timesteps=(timesteps[-1] + 1),
neighbourhood="Moore",
apply_rule=rule_function,
)
# return only the time steps requested
ca_at_time_steps = []
ca_at_time_steps_1d = []
for time_step in timesteps:
ca_at_time_steps.append(result[time_step])
# TODO: Change board size
ca_at_time_steps_1d.append(result[time_step].reshape(
(1, board_width * 2 * board_width * 2)))
return ca_at_time_steps, ca_at_time_steps_1d
#run_chromosome = np.array(np.random.randint(2, size=50 * 50))
# Board conditions
max_timestep = 100
board_width = int(math.sqrt(len(run_chromosome)))
board_height = int(math.sqrt(len(run_chromosome)))
full_board = np.zeros((board_width * 2, board_height * 2))
# shape from list to array
initial_board = run_chromosome.reshape((board_height, board_width))
# Needs to be this format for the cpl package
full_board[int(board_width / 2):int(board_width * 1.5),
int(board_height / 2):int(board_height * 1.5)] = initial_board
cellular_automaton = np.array([full_board])
# evolve the cellular automaton
cellular_automaton = cpl.evolve2d(
cellular_automaton,
timesteps=max_timestep,
neighbourhood="Moore",
apply_rule=b38s23,
)
cpl.plot2d_animate(cellular_automaton)
"""
for ca in cellular_automaton:
plt.imshow(ca, cmap='Greys')
plt.pause(.2)
plt.show()
"""
import cellpylib as cpl
# Glider
cellular_automaton = cpl.init_simple2d(60, 60)
cellular_automaton[:, [28, 29, 30, 30], [30, 31, 29, 31]] = 1
# Blinker
cellular_automaton[:, [40, 40, 40], [15, 16, 17]] = 1
# Light Weight Space Ship (LWSS)
cellular_automaton[:, [18, 18, 19, 20, 21, 21, 21, 21, 20],
[45, 48, 44, 44, 44, 45, 46, 47, 48]] = 1
# evolve the cellular automaton for 60 time steps
cellular_automaton = cpl.evolve2d(cellular_automaton,
timesteps=60,
neighbourhood='Moore',
apply_rule=cpl.game_of_life_rule)
cpl.plot2d_animate(cellular_automaton)
#%% rule table
import cellpylib as cpl
rule_table, actual_lambda, quiescent_state = cpl.random_rule_table(
lambda_val=0.45, k=4, r=2, strong_quiescence=True, isotropic=True)
cellular_automaton = cpl.init_random(128, k=4)
# use the built-in table_rule to use the generated rule table
cellular_automaton = cpl.evolve(
cellular_automaton,
timesteps=200,
apply_rule=lambda n, c, t: cpl.table_rule(n, rule_table),
r=2)
import cellpylib as cpl
sdsr_loop = cpl.SDSRLoop()
# the initial conditions consist of a single loop
cellular_automaton = sdsr_loop.init_loops(1, (100, 100), [40], [40])
cellular_automaton = cpl.evolve2d(cellular_automaton, timesteps=700,
apply_rule=sdsr_loop, memoize="recursive")
cpl.plot2d_animate(cellular_automaton)
import cellpylib as cpl
cellular_automaton = cpl.init_simple2d(60, 60)
# evolve the cellular automaton for 30 time steps
cellular_automaton = cpl.evolve2d(
cellular_automaton,
timesteps=30,
neighbourhood='Moore',
apply_rule=lambda n, c, t: cpl.totalistic_rule(n, k=2, rule=126))
cpl.plot2d(cellular_automaton)
import cellpylib as cpl
import numpy as np
n_rows = 45
n_cols = 45
sandpile = cpl.Sandpile(n_rows, n_cols)
initial = np.random.randint(5, size=n_rows * n_cols).reshape(
(1, n_rows, n_cols))
# we're using a closed boundary, so make the boundary cells 0
initial[0, 0, :], initial[0,
n_rows - 1, :], initial[0, :,
0], initial[0, :, n_cols -
1] = 0, 0, 0, 0
ca = cpl.evolve2d(initial,
timesteps=50,
apply_rule=sandpile,
neighbourhood="von Neumann")
cpl.plot2d_animate(ca)
ca_rows = 50
ca_cols = 50
num_timesteps = 120
num_layers = 6
val_spread = 'uniform'
cellular_automaton = cpl.init_random_fire_map2d(ca_rows,
ca_cols,
spread=val_spread)
val_string = ""
state_string = ""
neighborhood_string = ""
fire_cells = np.array([])
topo_cells = np.array([])
cellular_automaton = cpl.evolve2d(cellular_automaton,
timesteps=num_timesteps,
neighbourhood='Moore',
apply_rule=cpl.fire_spread_rule)
for i in range(num_timesteps):
#print (cellular_automaton[i][2][:][:])
fire_cells = np.append(fire_cells, (cellular_automaton[i][1][:][:]))
#topo_cells = np.append(topo_cells, (cellular_automaton[i][5][:][:]))
fire_cells = np.reshape(fire_cells, (num_timesteps, ca_rows, ca_cols))
#topo_cells = np.reshape(topo_cells, (num_timesteps, ca_rows, ca_cols))
cpl.plot2d_animate(fire_cells)
#cpl.plot2d(fire_cells, title = 'Uniform Fire Load (Wind and Topographic Features Considered)')
#cpl.plot2d_animate(topo_cells)
"""
#Prints out fuel load probability values
for row in range(ca_rows):
for col in range(ca_cols):
import cellpylib as cpl
import numpy as np
np.random.seed(0)
n_rows = 45
n_cols = 45
sandpile = cpl.Sandpile(n_rows, n_cols)
initial = np.random.randint(5, size=n_rows * n_cols).reshape(
(1, n_rows, n_cols))
# we're using a closed boundary, so make the boundary cells 0
initial[0, 0, :], initial[0,
n_rows - 1, :], initial[0, :,
0], initial[0, :, n_cols -
1] = 0, 0, 0, 0
ca = cpl.evolve2d(initial,
timesteps=cpl.until_fixed_point(),
apply_rule=sandpile,
neighbourhood="von Neumann")
print("Number of timesteps to reach fixed point: %s" % len(ca))
cpl.plot2d_animate(ca)
import cellpylib as cpl
langtons_loop = cpl.LangtonsLoop()
# the initial conditions consist of a single loop
cellular_automaton = langtons_loop.init_loops(1, (75, 75), [40], [25])
cellular_automaton = cpl.evolve2d(cellular_automaton,
timesteps=500,
apply_rule=langtons_loop,
memoize="recursive")
cpl.plot2d_animate(cellular_automaton)
import cellpylib as cpl
"""
We repeatedly drop a grain of sand in the middle, allowing the sandpile to grow.
After a grain is dropped, the system is allowed to evolve until a fixed point,
where no further change occurs, before the next grain is dropped.
"""
n = 50
sandpile = cpl.Sandpile(n, n)
ca = cpl.init_simple2d(n, n, val=5)
for i in range(300):
ca[-1, n // 2, n // 2] += 1
ca = cpl.evolve2d(ca,
apply_rule=sandpile,
timesteps=cpl.until_fixed_point(),
neighbourhood='Moore')
cpl.plot2d_animate(ca)
import cellpylib as cpl
cellular_automaton = cpl.init_simple2d(50, 50, val=0)
# During each timestep, we'll check each cell if it should be the one updated according to the
# update order. At the end of a timestep, the update order index is advanced, but if the
# update order is randomized at the end of each timestep, then this is equivalent to picking
# a cell randomly to update at each timestep.
apply_rule = cpl.AsynchronousRule(apply_rule=lambda n, c, t: 1,
num_cells=(50, 50),
randomize_each_cycle=True)
cellular_automaton = cpl.evolve2d(cellular_automaton,
timesteps=50,
neighbourhood='Moore',
apply_rule=apply_rule)
cpl.plot2d_animate(cellular_automaton, interval=200, autoscale=True)
import cellpylib as cpl
import numpy as np
cellular_automaton = cpl.init_simple2d(60, 60)
# the letter "E"
cellular_automaton[0][28][28] = 1
cellular_automaton[0][28][29] = 1
cellular_automaton[0][28][30] = 1
cellular_automaton[0][29][28] = 1
cellular_automaton[0][30][28] = 1
cellular_automaton[0][30][29] = 1
cellular_automaton[0][30][30] = 1
cellular_automaton[0][31][28] = 1
cellular_automaton[0][32][28] = 1
cellular_automaton[0][32][29] = 1
cellular_automaton[0][32][30] = 1
def activity_rule(n, c, t):
current_activity = n[1][1]
return (np.sum(n) - current_activity) % 2
cellular_automaton = cpl.evolve2d(cellular_automaton,
timesteps=20,
apply_rule=activity_rule,
neighbourhood="Moore")
cpl.plot2d_animate(cellular_automaton, interval=350)
def evolve(self, ts: int = 1):
self.sandbox = cpl.evolve2d(self.sandbox, timesteps=ts, neighbourhood='Moore',
apply_rule=lambda n,c,t: self.virus_spread_rule(n,c,t))
import cellpylib as cpl
ctrbl_rule = cpl.CTRBLRule(rule_table={
(0, 1, 0, 0, 0): 1,
(1, 1, 0, 0, 0): 0,
(0, 0, 0, 0, 0): 0,
(1, 0, 0, 0, 0): 1,
(0, 0, 1, 1, 0): 0,
(1, 1, 1, 1, 1): 1,
(0, 1, 0, 1, 0): 0,
(1, 1, 1, 0, 1): 1,
(1, 0, 1, 0, 1): 1,
(0, 1, 1, 1, 1): 1,
(0, 0, 1, 1, 1): 0,
(1, 1, 0, 0, 1): 1
},
add_rotations=True)
cellular_automaton = cpl.init_simple2d(rows=10, cols=10)
cellular_automaton = cpl.evolve2d(cellular_automaton,
timesteps=60,
apply_rule=ctrbl_rule,
neighbourhood="von Neumann")
cpl.plot2d_animate(cellular_automaton)
electron_head_count = np.count_nonzero(n == 1)
return 1 if electron_head_count == 1 or electron_head_count == 2 else 3
cellular_automata = np.array(
[[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 3, 1, 2, 3, 3, 3, 3, 1, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 3, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 3, 3, 3, 3, 2],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0, 0, 0, 0],
[0, 0, 0, 3, 3, 2, 1, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
[0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0]]])
cellular_automata = cpl.evolve2d(cellular_automata,
timesteps=25,
apply_rule=wireworld_rule,
neighbourhood="Moore")
cpl.plot2d_animate(cellular_automata,
show_grid=True,
show_margin=False,
scale=0.3,
colormap=ListedColormap(["black", "blue", "red", "yellow"]))
import cellpylib as cpl
import numpy as np
cellular_automaton = cpl.init_simple2d(60, 60)
# the letter "E"
cellular_automaton[0][28][28] = 0
cellular_automaton[0][28][29] = 1
cellular_automaton[0][28][30] = 2
cellular_automaton[0][29][28] = 3
cellular_automaton[0][30][28] = 4
cellular_automaton[0][30][29] = 5
cellular_automaton[0][30][30] = 6
cellular_automaton[0][31][28] = 7
cellular_automaton[0][32][28] = 8
cellular_automaton[0][32][29] = 9
cellular_automaton[0][32][30] = 10
def activity_rule(n, c, t):
current_activity = n[1][1]
return (np.sum(n) - current_activity) % 11
cellular_automaton = cpl.evolve2d(cellular_automaton, timesteps=23,
apply_rule=activity_rule, neighbourhood="von Neumann")
cpl.plot2d_animate(cellular_automaton, interval=350, colormap='viridis')
read_data = pd.read_excel("test_logs/" + test_name + "_results.xlsx")
fitness = list(read_data["max fitness"])
run_chromosome = get_best_chromosome_in_this_excel(fitness, chromosomes)
#run_chromosome = np.array(np.random.randint(2, size=50 * 50))
# Board conditions
max_timestep = 100
board_width = int(math.sqrt(len(run_chromosome)))
board_height = int(math.sqrt(len(run_chromosome)))
full_board = np.zeros((board_width*2, board_height*2))
# shape from list to array
initial_board = run_chromosome.reshape((board_height, board_width))
# Needs to be this format for the cpl package
full_board[int(board_width/2):int(board_width*1.5), int(board_height/2):int(board_height*1.5)] = initial_board
cellular_automaton = np.array([full_board])
# evolve the cellular automaton
cellular_automaton = cpl.evolve2d(
cellular_automaton,
timesteps=max_timestep,
neighbourhood="Moore",
apply_rule=cpl.game_of_life_rule,
)
cpl.plot2d_animate(cellular_automaton)
def evolve_configuration(configuration, steps=1):
return cpl.evolve2d(configuration,
timesteps=steps,
neighbourhood='Moore',
apply_rule=cpl.game_of_life_rule)
