def test_binary_rule_powers_of_two_default(self):
rule_number = 6667021275756174439087127638698866559
radius = 3
timesteps = 49
init = np.array([[
1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0,
0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0,
0, 1, 1, 1, 1
]])
expected = cpl.evolve(
init,
timesteps=timesteps,
apply_rule=lambda n, c, t: cpl.binary_rule(n, rule_number),
r=radius)
powers_of_two = 2**np.arange(radius * 2 + 1)[::-1]
rule = list(map(int, bin(rule_number)[2:]))
rule_bin_array = np.pad(rule, ((2**(radius * 2 + 1)) - len(rule), 0),
'constant')
actual = cpl.evolve(
init,
timesteps=timesteps,
apply_rule=lambda n, c, t: cpl.binary_rule(
n, rule_bin_array, powers_of_two=powers_of_two),
r=radius)
np.testing.assert_equal(expected.tolist(), actual.tolist())
def test_binary_rule(self):
rule_number = 6667021275756174439087127638698866559
radius = 3
timesteps = 12
init = np.array(
[[1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1]])
actual = cpl.evolve(
init,
timesteps=timesteps,
apply_rule=lambda n, c, t: cpl.binary_rule(n, rule_number),
r=radius)
expected = np.array(
[[1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1],
[1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1],
[1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0],
[0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1],
[1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1],
[1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])
np.testing.assert_equal(expected.tolist(), actual.tolist())
def _create_totalistic_ca(self, expected, k, rule):
rows, _ = expected.shape
cellular_automaton = expected[0]
return cpl.evolve(
cellular_automaton,
timesteps=rows,
apply_rule=lambda n, c, t: cpl.totalistic_rule(n, k, rule))
def _create_reversible_ca(self, expected, rule):
rows, _ = expected.shape
cellular_automaton = expected[0]
r = cpl.ReversibleRule(cellular_automaton.tolist()[0], rule)
return cpl.evolve(cellular_automaton,
timesteps=rows,
apply_rule=r.apply_rule)
def test_evolve_apply_rule_3_steps(self):
cellular_automaton = np.array([[1, 2, 3, 4, 5]])
neighbourhoods = []
cell_identities = []
timesteps = []
def apply_rule(n, c, t):
neighbourhoods.append(n.tolist())
cell_identities.append(c)
timesteps.append(t)
return n[1]
cpl.evolve(cellular_automaton, timesteps=3, apply_rule=apply_rule)
np.testing.assert_equal(
neighbourhoods,
[[5, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 1], [5, 1, 2],
[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 1]])
np.testing.assert_equal(cell_identities,
[0, 1, 2, 3, 4, 0, 1, 2, 3, 4])
np.testing.assert_equal(timesteps, [1, 1, 1, 1, 1, 2, 2, 2, 2, 2])
def test_sequential_left_to_right(self):
expected = self._convert_to_numpy_matrix(
"rule60_sequential_simple_init.ca")
cellular_automaton = cpl.init_simple(21)
r = cpl.AsynchronousRule(
apply_rule=lambda n, c, t: cpl.nks_rule(n, 60),
update_order=range(1, 20))
cellular_automaton = cpl.evolve(cellular_automaton,
timesteps=19 * 20,
apply_rule=r.apply_rule)
np.testing.assert_equal(expected.tolist(),
cellular_automaton[::19].tolist())
def test_binary_rule_powers_of_two_nks(self):
rule_number = 30
radius = 1
size = 149
timesteps = 149
expected = cpl.evolve(cpl.init_simple(size=size),
timesteps=timesteps,
apply_rule=lambda n, c, t: cpl.binary_rule(
n, rule_number, scheme="nks"),
r=radius)
powers_of_two = 2**np.arange(radius * 2 + 1)[::-1]
rule = list(map(int, bin(rule_number)[2:]))
rule_bin_array = np.pad(rule, ((2**(radius * 2 + 1)) - len(rule), 0),
'constant').tolist()
actual = cpl.evolve(
cpl.init_simple(size=size),
timesteps=timesteps,
apply_rule=lambda n, c, t: cpl.binary_rule(
n, rule_bin_array, scheme="nks", powers_of_two=powers_of_two),
r=radius)
np.testing.assert_equal(expected.tolist(), actual.tolist())
def test_sequential_random(self):
expected = self._convert_to_numpy_matrix(
"rule90_sequential_simple_init.ca")
cellular_automaton = cpl.init_simple(21)
update_order = [
19, 11, 4, 9, 6, 16, 10, 2, 17, 1, 12, 15, 5, 3, 8, 18, 7, 13, 14
]
r = cpl.AsynchronousRule(
apply_rule=lambda n, c, t: cpl.nks_rule(n, 90),
update_order=update_order)
cellular_automaton = cpl.evolve(cellular_automaton,
timesteps=19 * 20,
apply_rule=r.apply_rule)
np.testing.assert_equal(expected.tolist(),
cellular_automaton[::19].tolist())
def test_dtype(self):
cellular_automaton = cpl.init_simple(11, dtype=np.float32)
cellular_automaton = cpl.evolve(
cellular_automaton,
timesteps=6,
apply_rule=lambda n, c, t: sum(n) / len(n))
np.testing.assert_almost_equal(
cellular_automaton.tolist(),
[[0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.333, 0.333, 0.333, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.111, 0.222, 0.333, 0.222, 0.111, 0.0, 0.0, 0.0],
[
0.0, 0.0, 0.037, 0.111, 0.222, 0.259, 0.222, 0.111, 0.037,
0.0, 0.0
],
[
0.0, 0.012, 0.049, 0.123, 0.198, 0.235, 0.198, 0.123, 0.049,
0.0123, 0.0
],
[
0.004, 0.021, 0.062, 0.123, 0.185, 0.210, 0.185, 0.123, 0.062,
0.021, 0.004
]],
decimal=3)
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
cellular_automaton = cpl.init_simple(200)
# cellular_automaton = cpl.init_random(200)
# evolve the cellular automaton for 100 time steps
cellular_automaton = cpl.evolve(cellular_automaton,
timesteps=100,
memoize=True,
apply_rule=lambda n, c, t: cpl.nks_rule(n, 30))
cpl.plot(cellular_automaton)
0, 0, 1, 0, 0,
0, 0, 1, 0, 0,
0, 0, 1, 0, 0,
0, 0, 0, 0, 0,
0, 0, 0, 0, 0,
0, 0, 0, 0, 0]
half_two = [
0, 0, 0, 0, 0,
0, 0, 0, 0, 0,
0, 0, 0, 0, 0,
0, 1, 1, 0, 0,
1, 0, 0, 0, 0,
1, 1, 1, 1, 1,
0, 0, 0, 0, 0]
half_zero = [-1 if x == 0 else x for x in half_zero]
half_one = [-1 if x == 0 else x for x in half_one]
half_two = [-1 if x == 0 else x for x in half_two]
cellular_automaton = np.array([half_two])
hopfield_net = cpl.HopfieldNet(num_cells=35)
hopfield_net.train(P)
cellular_automaton = cpl.evolve(cellular_automaton, timesteps=155,
apply_rule=hopfield_net.apply_rule, r=hopfield_net.r)
cpl.plot(hopfield_net.W)
cpl.plot2d_animate(np.reshape(cellular_automaton, (155, 7, 5)))
import cellpylib as cpl
import time
start = time.time()
cpl.evolve(cpl.init_simple(1000),
timesteps=500,
apply_rule=lambda n, c, t: cpl.nks_rule(n, 30),
memoize=True)
print(f"Elapsed: {time.time() - start:.2f} seconds")
import cellpylib as cpl # implements the rule 60 sequential automaton from the NKS Notes on # Chapter 9, section 10: "Sequential cellular automata" # http://www.wolframscience.com/nks/notes-9-10--sequential-cellular-automata/ cellular_automaton = cpl.init_simple(21) apply_rule = cpl.AsynchronousRule(apply_rule=lambda n, c, t: cpl.nks_rule(n, 60), update_order=range(1, 20)) cellular_automaton = cpl.evolve(cellular_automaton, timesteps=19*20, apply_rule=apply_rule) # get every 19th row, including the first, as a cycle is completed every 19 rows cpl.plot(cellular_automaton[::19])
import cellpylib as cpl
import numpy as np
initial = np.array([[17]], dtype=np.int)
def activity_rule(n, c, t):
n = n[1]
if n % 2 == 0:
# number is even
return n / 2
else:
return 3 * n + 1
cellular_automaton = cpl.evolve(initial,
apply_rule=activity_rule,
timesteps=lambda ca, t: True
if ca[-1][0] != 1 else False)
print([i[0] for i in cellular_automaton])
import cellpylib as cpl
import numpy as np
cellular_automaton = cpl.init_random(149)
print("density of 1s: %s" % (np.count_nonzero(cellular_automaton) / 149))
# M. Mitchell et al. discovered this rule using a Genetic Algorithm
rule_number = 6667021275756174439087127638698866559
cellular_automaton = cpl.evolve(cellular_automaton, timesteps=149,
apply_rule=lambda n, c, t: cpl.binary_rule(n, rule_number), r=3)
cpl.plot(cellular_automaton)
# Ajustado especificamente para a regra 90 e sua reversão
# plot the resulting CA evolution
try:
import cellpylib as cpl
except:
!pip install cellpylib
import cellpylib as cpl
from cellpylib import *
#import cellpylib as cpl
# initialize a CA with 200 cells (a random initialization is also available)
cellular_automaton = cpl.init_simple(200)
# evolve the CA for 100 time steps, using Rule 30 as defined in NKS
cellular_automaton = cpl.evolve(cellular_automaton, timesteps=100,
apply_rule=lambda n, c, t: cpl.nks_rule(n, 90))
# plot the resulting CA evolution
cpl.plot(cellular_automaton)
cellular_automaton = cpl.init_random(200)
r = cpl.ReversibleRule(cellular_automaton[0], 90)
cellular_automaton = cpl.evolve(cellular_automaton, timesteps=100,
apply_rule=r.apply_rule)
# plot the resulting reverse CA evolution
cpl.plot(cellular_automaton)
import matplotlib.pyplot as plt
import numpy as np
import cellpylib as cpl
# NKS page 442 - Rule 122R
cellular_automaton = np.array([[0] * 40 + [1] * 20 + [0] * 40])
r = cpl.ReversibleRule(cellular_automaton[0], 122)
cellular_automaton = cpl.evolve(cellular_automaton,
timesteps=1000,
apply_rule=r.apply_rule)
timestep = []
bientropies = []
shannon_entropies = []
average_cell_entropies = []
apentropies = []
for i, c in enumerate(cellular_automaton):
timestep.append(i)
bit_string = ''.join([str(x) for x in c])
bientropies.append(cpl.ktbien(bit_string))
shannon_entropies.append(cpl.shannon_entropy(bit_string))
average_cell_entropies.append(
cpl.average_cell_entropy(cellular_automaton[:i + 1]))
apentropies.append(cpl.apen(bit_string, m=1, r=0))
print("%s, %s, %s, %s" %
(i, bientropies[-1], shannon_entropies[-1], apentropies[-1]))
plt.figure(1)
plt.title("KTBiEn")
plt.plot(timestep, bientropies)
import numpy as np
import cellpylib as cpl
# NKS page 437 - Rule 214R
# run the CA forward for 32 steps to get the initial condition for the next evolution
cellular_automaton = cpl.init_simple(63)
r = cpl.ReversibleRule(cellular_automaton[0], 214)
cellular_automaton = cpl.evolve(cellular_automaton, timesteps=32,
apply_rule=r.apply_rule)
# use the last state of the CA as the initial, previous state for this evolution
r = cpl.ReversibleRule(cellular_automaton[-1], 214)
cellular_automaton = np.array([cellular_automaton[-2]])
cellular_automaton = cpl.evolve(cellular_automaton, timesteps=62,
apply_rule=r.apply_rule)
cpl.plot(cellular_automaton)
def test_evolve_apply_rule_1_step(self):
cellular_automaton = np.array([[1, 2, 3, 4, 5]])
cellular_automaton = cpl.evolve(cellular_automaton,
timesteps=1,
apply_rule=lambda n, c, t: 1)
np.testing.assert_equal(cellular_automaton.tolist(), [[1, 2, 3, 4, 5]])
for carule in range(5000):
print(carule)
k = 2 + np.random.randint(6)
rn = np.random.randint(int(k**(3 * k - 2)))
f = open("data5k/%.06d/rule.txt" % carule, "w")
# k, r, type, rule
# type: 0 = General, 1 = Totalistic
f.write("%d 1 1 %d" % (k, rn))
f.close()
for i in range(50):
ca = cpl.init_random(256)
ca = cpl.evolve(
ca,
timesteps=256,
apply_rule=lambda n, c, t: cpl.totalistic_rule(n, k=k, rule=rn),
r=1)
im = render(ca, k)
im.save("data5k/%.06d/%.06d.png" % (carule, i))
# In[16]:
counts = [np.sum(ca == i) for i in range(k)]
# In[17]:
counts
# In[ ]:
import cellpylib as cpl
cellular_automaton = cpl.init_simple(200)
# cellular_automaton = cpl.init_random(200, k=3)
# evolve the cellular automaton for 100 time steps
cellular_automaton = cpl.evolve(
cellular_automaton,
timesteps=100,
apply_rule=lambda n, c, t: cpl.totalistic_rule(n, k=3, rule=777))
cpl.plot(cellular_automaton)
