Yes. First it is not a finished product and second I don't like Github.
Brian Prentice
Yes. First it is not a finished product and second I don't like Github.
Code: Select all
import copy
import importlib
import random
import traceback
from typing import List, Tuple
import CAComputeParse.CACompute as parser
import numpy as np
from PIL import Image
import RuleParser
param_map_array = []
def param_map(soup_size, x, y, max_generations, dict_grid):
global param_map_array
if RuleParser.n_states > 2:
colour_palette: List[Tuple[int, int, int]] = [(0, 0, 0)] + \
[(255, 255 // (RuleParser.n_states - 2) * x, 0)
for x in range(RuleParser.n_states - 1)]
else:
colour_palette: List[Tuple[int, int, int]] = [(0, 0, 0), (255, 255, 255)]
cells_changed = dict_grid.keys() # Running Simulation
for generations in range(max_generations):
if generations == 100: print(sorted(dict_grid.keys()))
copy_grid = copy.deepcopy(dict_grid)
cells_changed, dict_grid = parser.compute(cells_changed, copy_grid, dict_grid, generations)
keys_to_pop = []
for key in dict_grid:
if 0 <= key[0] <= soup_size * 3 and 0 <= key[1] <= soup_size * 3: # Checking Within Bounds
param_map_array[generations][soup_size * 3 * y + key[1]][soup_size * 3 * x + key[0]] = \
colour_palette[dict_grid[key]]
else:
keys_to_pop.append(key)
for key in keys_to_pop: # Delete cells outside boundary
dict_grid.pop(key)
def generate_param_map(soup_size, rows, columns, generations):
global param_map_array
for i in range(generations):
param_map_array.append(np.zeros((soup_size * 3 * rows + 1, soup_size * 3 * columns + 1, 3),
dtype=np.uint8))
dict_grid = {} # Generating Random Soup
for i in range(soup_size, soup_size * 2):
for j in range(soup_size, soup_size * 2):
if random.randint(0, 1):
dict_grid[(i, j)] = 1
for y in range(5):
for x in range(5):
print("Running", (x, y))
try:
rule = open(f"PMap/rule_{x}_{y}.ca_rule", "r")
rule_contents = rule.read()
rule.close()
new_rule = open("PMap/rule.ca_rule", "w+") # Transferring Rule
new_rule.write(rule_contents)
new_rule.close()
print(rule_contents)
parser.load("PMap/rule.ca_rule")
RuleParser.load("PMap/rule.ca_rule")
param_map(soup_size, x, y, generations, copy.deepcopy(dict_grid))
except Exception:
print(traceback.format_exc())
img_frames: List = [Image.fromarray(x) for x in param_map_array]
img_frames[0].save("pmap.gif", format='GIF', append_images=img_frames[1:],
save_all=True, loop=0)
print("Done!")
lemon41625 wrote: ↑May 10th, 2020, 8:22 amCould someone help me debug this code for the parameter maps?
dict_grid is where the pattern is stored.
The bug is that in each of the grid cells the rule is the same.
Code: Select all
rule_string = "0xgxlxn1cccdcgcickcl2cacccdcenanc3ca/0xn1cgcickcl2cccdcenc3ca"
outside_four_cells = {
"a": [0, 0, 0, 0],
"c": [1, 0, 0, 0],
"d": [0, 1, 0, 0],
"e": [0, 0, 1, 0],
"f": [0, 0, 0, 1],
"g": [1, 1, 0, 0],
"i": [0, 1, 1, 0],
"j": [0, 0, 1, 1],
"k": [1, 0, 0, 1],
"l": [1, 0, 1, 0],
"m": [0, 1, 0, 1],
"n": [1, 1, 1, 0],
"o": [0, 1, 1, 1],
"p": [1, 0, 1, 1],
"q": [1, 1, 0, 1],
"r": [1, 1, 1, 1]
}
hensel = {0: {"a": [0, 0, 0, 0, 0, 0, 0, 0]},
1: {"c": [1, 0, 0, 0, 0, 0, 0, 0], "e": [0, 1, 0, 0, 0, 0, 0, 0]},
2: {"c": [1, 0, 1, 0, 0, 0, 0, 0], "e": [0, 1, 0, 0, 0, 0, 0, 1],
"k": [0, 1, 0, 0, 1, 0, 0, 0], "a": [1, 1, 0, 0, 0, 0, 0, 0],
"i": [0, 1, 0, 0, 0, 1, 0, 0], "n": [1, 0, 0, 0, 1, 0, 0, 0]},
3: {"c": [1, 0, 1, 0, 1, 0, 0, 0], "e": [0, 1, 0, 1, 0, 0, 0, 1],
"k": [0, 1, 0, 0, 1, 0, 0, 1], "a": [1, 1, 0, 0, 0, 0, 0, 1],
"i": [1, 0, 0, 0, 0, 0, 1, 1], "n": [1, 0, 1, 0, 0, 0, 0, 1],
"y": [1, 0, 1, 0, 0, 1, 0, 0], "q": [1, 0, 0, 0, 1, 0, 0, 1],
"j": [0, 0, 1, 1, 0, 1, 0, 0], "r": [0, 1, 1, 0, 0, 1, 0, 0]},
4: {"c": [1, 0, 1, 0, 1, 0, 1, 0], "e": [0, 1, 0, 1, 0, 1, 0, 1],
"k": [0, 1, 1, 0, 1, 0, 0, 1], "a": [1, 0, 0, 0, 0, 1, 1, 1],
"i": [1, 0, 1, 1, 0, 0, 0, 1], "n": [1, 0, 0, 0, 1, 0, 1, 1],
"y": [1, 0, 1, 0, 0, 1, 1, 0], "q": [1, 1, 0, 0, 1, 0, 0, 1],
"j": [0, 0, 1, 1, 0, 1, 0, 1], "r": [0, 1, 1, 1, 0, 1, 0, 0],
"t": [1, 1, 1, 0, 0, 1, 0, 0], "w": [1, 0, 0, 0, 1, 1, 0, 1],
"z": [1, 1, 0, 0, 1, 1, 0, 0]},
5: {"c": [0, 1, 0, 1, 0, 1, 1, 1], "e": [1, 0, 1, 0, 1, 1, 1, 0],
"k": [1, 0, 1, 1, 0, 1, 1, 0], "a": [0, 0, 1, 1, 1, 1, 1, 0],
"i": [0, 1, 1, 1, 1, 1, 0, 0], "n": [0, 1, 0, 1, 1, 1, 1, 0],
"y": [0, 1, 0, 1, 1, 0, 1, 1], "q": [0, 1, 1, 1, 0, 1, 1, 0],
"j": [1, 1, 0, 0, 1, 0, 1, 1], "r": [1, 0, 0, 1, 1, 0, 1, 1]},
6: {"c": [0, 1, 0, 1, 1, 1, 1, 1], "e": [1, 0, 1, 1, 1, 1, 1, 0],
"k": [1, 0, 1, 1, 0, 1, 1, 1], "a": [0, 0, 1, 1, 1, 1, 1, 1],
"i": [1, 0, 1, 1, 1, 0, 1, 1], "n": [0, 1, 1, 1, 0, 1, 1, 1]},
7: {"c": [0, 1, 1, 1, 1, 1, 1, 1], "e": [1, 0, 1, 1, 1, 1, 1, 1]},
8: {"a": [1, 1, 1, 1, 1, 1, 1, 1]}}
def rotate(neighbours):
return neighbours[2:8] + neighbours[:2] + neighbours[9:12] + [neighbours[8]]
def reflect_1(neighbours):
return [neighbours[2], neighbours[1], neighbours[0], neighbours[7],
neighbours[6], neighbours[5], neighbours[4], neighbours[3],
neighbours[8], neighbours[11], neighbours[10], neighbours[9]]
def reflect_2(neighbours):
return [neighbours[6], neighbours[5], neighbours[4], neighbours[3],
neighbours[0], neighbours[1], neighbours[2], neighbours[7],
neighbours[10], neighbours[9], neighbours[8], neighbours[11]]
def rotate_4_reflect(neighbours):
lst = []
rotate_1 = rotate(neighbours)
rotate_2 = rotate(rotate_1)
rotate_3 = rotate(rotate_2)
lst.append(tuple(neighbours))
lst.append(tuple(reflect_1(neighbours)))
lst.append(tuple(reflect_2(neighbours)))
lst.append(tuple(rotate_1))
lst.append(tuple(reflect_1(rotate_1)))
lst.append(tuple(reflect_2(rotate_1)))
lst.append(tuple(rotate_2))
lst.append(tuple(reflect_1(rotate_2)))
lst.append(tuple(reflect_2(rotate_2)))
lst.append(tuple(rotate_3))
lst.append(tuple(reflect_1(rotate_3)))
lst.append(tuple(reflect_2(rotate_3)))
return lst
current_num = 0
current_trans = ""
birth_trans = []
birth_string = rule_string.split("/")[1]
for i in range(len(birth_string)):
try:
current_num = int(birth_string[i])
except ValueError:
current_trans += birth_string[i]
if len(current_trans) == 2:
if current_trans[0] != "x":
birth_trans += rotate_4_reflect(
hensel[current_num][current_trans[0]] + outside_four_cells[current_trans[1]])
else:
for key in hensel[current_num]:
birth_trans += rotate_4_reflect(
hensel[current_num][key] + outside_four_cells[current_trans[1]])
current_trans = ""
current_num = 0
current_trans = ""
survival_trans = []
survival_string = rule_string.split("/")[0]
for i in range(len(survival_string)):
try:
current_num = int(survival_string[i])
except ValueError:
current_trans += survival_string[i]
if len(current_trans) == 2:
if current_trans[0] != "x":
survival_trans += rotate_4_reflect(
hensel[current_num][current_trans[0]] + outside_four_cells[current_trans[1]])
else:
for key in hensel[current_num]:
survival_trans += rotate_4_reflect(
hensel[current_num][key] + outside_four_cells[current_trans[1]])
current_trans = ""
birth_trans, survival_trans = set(birth_trans), set(survival_trans)
# Information about the Rule (Must be filled)
n_states = 2 # Number of States
alternating_period = 1 # For alternating rules / neighbourhoods
colour_palette = None # Colours of the different states
rule_name = "Range 2 Isotropic Von Neumann" # Rule Name
# Neighbourhood of the Rule (Relative Distance from Central Cell)
def get_neighbourhood(generation): # Note (y, x) not (x, y)
return [(1, -1), (1, 0), (1, 1), (0, 1),
(-1, 1), (-1, 0), (-1, -1), (0, -1),
(2, 0), (0, 2), (-2, 0), (0, -2)]
# Transition Function of Rule, Last Element of Neighbours is the Central Cell
def transition_func(neighbours, generation):
if neighbours[-1] == 1:
if tuple(neighbours[:-1]) in survival_trans:
return 1
return 0
elif neighbours[-1] == 0:
if tuple(neighbours[:-1]) in birth_trans:
return 1
return 0
# Does the next state of the cell depend on its neighbours?
# If yes, return next state
# If no, return -1
def depend_on_neighbours(state, generation):
return -1
I have scipy installed since I use Anaconda. Also use jupyter notebook (actually google colab) for making neural nets (because free gpu)martin.novy wrote: ↑May 10th, 2020, 10:15 amlemon41625 wrote: ↑May 10th, 2020, 8:22 amCould someone help me debug this code for the parameter maps?
dict_grid is where the pattern is stored.
The bug is that in each of the grid cells the rule is the same.
my own code, PyMartinCA, badly needs compatibility with Python 3,
and several refactorizations ...
I have to learn details about classes in Python
by the way, i guess, i cannot assume, that anybody here uses,
or wants to try,
jupyter notebook or ipython console ?
and i guess, i cannot assume,
that anybody here has scipy installed ?
Why whould primodia behave similiarly to LtL?by the way, I guess Primordia could be comparable in behavior to some LtL (but Primordia is much faster).
what is the meaning of these constants: 3lemon41625 wrote: ↑May 10th, 2020, 8:22 amCould someone help me debug this code for the parameter maps?
dict_grid is where the pattern is stored.
if 0 <= key[0] <= soup_size * 3 and 0 <= key[1] <= soup_size * 3: # Checking Within Bounds
param_map_array[generations][soup_size * 3 * y + key[1]][soup_size * 3 * x + key[0]] = \
param_map_array.append(np.zeros((soup_size * 3 * rows + 1, soup_size * 3 * columns + 1, 3),
The bug is that in each of the grid cells the rule is the same.
The program transfers the rule contents into the rule file. If you were to actually execute the parameter map function, there will be many more rule files in the PMap folder.martin.novy wrote: ↑May 11th, 2020, 9:56 amit seems to me, that right now
https://github.com/jedlimlx/Cellular-Au ... le.ca_rule
defines only one rule
Rulestring: b4s2,4
and what is the meaning of the 3 at the end :lemon41625 wrote: ↑May 11th, 2020, 10:36 amThe 3 represents that the size of the grid where the soup is placed is 3x the soup size.
It represents the 3 colour channels.martin.novy wrote: ↑May 11th, 2020, 12:02 pmand what is the meaning of the 3 at the end :lemon41625 wrote: ↑May 11th, 2020, 10:36 amThe 3 represents that the size of the grid where the soup is placed is 3x the soup size.
param_map_array.append(np.zeros((soup_size * 3 * rows + 1, soup_size * 3 * columns + 1, 3),
dtype=np.uint8))
...
i can make a demo ... tomorrow , i hope
my parameter map demo ... jupyter notebook (actually google colab)lemon41625 wrote: ↑May 10th, 2020, 8:22 amCould someone help me debug this code for the parameter maps?
dict_grid is where the pattern is stored.
The bug is that in each of the grid cells the rule is the same.
can you try in CAViewerlemon41625 wrote: ↑May 9th, 2020, 4:57 am
In the rulestring section, you can input rulestrings like b3,"x+3"s2,3,"y+3".
Code: Select all
param_map_dialog.run_param.connect(lambda: param_map.generate_param_map(50, 5, 5, 500))
i cannot find, who (module.function ) and where
Code: Select all
new_rule = open("PMap/rule.ca_rule", "w+") # Transferring Rule
Code: Select all
new_rule = open("PMap/rule.ca_rule", "w+")
oh, sorry, i didn't notice, what i asked about was 6 lines above what i saw
Code: Select all
import CAComputeParse.CACompute as parser
parser.load("PMap/rule.ca_rule")
is it possible to temporarily , for debugging,lemon41625 wrote: ↑May 14th, 2020, 7:42 pmNo, I wish I could use print but I can't. To get debug info, you need to write to a file.
Code: Select all
#running apt install twice is almost a no operation
/usr/bin/sudo apt install python3-pyqt5 python3-pyperclip python3-numpy python3-pil
/usr/bin/sudo apt install cython3
cd CAViewer/
cd CACompute
touch __init__.py
cp -i Compute.cpp compute.cpp
#python3 setup.py --help
python3 setup.py build_ext --inplace
cd ..
cd CAComputeParse/
touch __init__.py
cp -i Compute.cpp compute.cpp
python3 setup.py build_ext --inplace
cd ..
#export DISPLAY=:0
echo python3 Main.py
When you say then it worked do you mean the parameter map thing worked?martin.novy wrote: ↑May 15th, 2020, 7:08 amthen python3 Main.py ... failed, because
the compilation produced
CAViewer/CAComputeParse/CAComputeParse/CACompute.cpython-36m-x86_64-linux-gnu.so
the path
CAViewer/CAComputeParse/CAComputeParse/
is a bit strange?
week ago, the compilation produced
CAViewer/CAComputeParse/CACompute.cpython-36m-x86_64-linux-gnu.so ... a shorter path ... CAViewer/CAComputeParse
my naive fix was to copy the file CACompute.cpython to
CAViewer/CAComputeParse/CACompute.cpython-36m-x86_64-linux-gnu.so
then it worked
how do *you* compile it?
sorry, no, I mean: I was able to start thelemon41625 wrote: ↑May 15th, 2020, 7:21 am
When you say then it worked do you mean the parameter map thing worked?
lemon41625 wrote: ↑May 14th, 2020, 10:49 am"PMap/rule.ca_rule" is for the parameter maps.
parser.load reloads the rule.
Code: Select all
Name: uhjhj_2_1
Neighbourhood Range: 2
Neighbourhood:
0,0,0,0,0
0,1,1,1,0
0,1,0,1,0
0,1,1,1,0
0,0,0,0,0
State Weights: 0,1
Rulespace: Single State
B/S Conditions: Outer Totalistic
Rulestring: b2,3,5s2,3,4
Colour Palette:
None
Code: Select all
parser.load("PMap/rule.ca_rule")
max_generations=1 #3
dict_grid={(1,1):1,(1,2):1,(1,3):1}
cells_changed = dict_grid.keys() # Running Simulation
for generations in range(max_generations):
copy_grid = copy.deepcopy(dict_grid)
cells_changed, dict_grid = parser.compute(cells_changed, copy_grid, dict_grid, generations)
dict_grid
Code: Select all
# distutils: language=c++
import re
from libcpp.vector cimport vector
from libcpp.pair cimport pair
from libcpp.map cimport map
from libcpp cimport bool
from libcpp.string cimport string
from libcpp.algorithm cimport sort
from libcpp.unordered_map cimport unordered_map
from libcpp.unordered_set cimport unordered_set
cdef vector[vector[int]] colour_palette
cdef string rule_name
cdef string rule_space, bsconditions
cdef int n_states
cdef vector[unordered_map[pair[int, int], int]] index_map
cdef vector[vector[int]] state_weights
cdef vector[vector[pair[int, int]]] neighbourhood, original_neighbourhood
cdef vector[vector[int]] neighbourhood_weights
cdef int alternating_period, birth_state
cdef vector[unordered_set[int]] birth, survival, forcing, killing, living, \
regen_birth, regen_survival, activity_list, other_birth, other_survival, \
other_regen_birth, other_regen_survival, other_forcing, other_killing, other_living
cdef vector[unordered_set[pair[int, int]]] birth_semi_1, survival_semi_1, forcing_semi_1, killing_semi_1, living_semi_1, \
regen_birth_semi_1, regen_survival_semi_1
cdef vector[string] naive_lst, direction_lst
cdef vector[int] corner_lst, xy_lst
cdef int corner, xy
cdef string direction
cdef extern from "compute.cpp":
pass
cpdef load(filename):
global colour_palette, rule_name, rule_space, n_states, state_weights, neighbourhood, neighbourhood_weights,\
alternating_period, birth, survival, forcing, killing, living, \
regen_birth, regen_survival, activity_list, birth_state, other_birth, other_survival, bsconditions, \
original_neighbourhood, index_map, other_forcing, other_killing, other_living, naive_lst, direction_lst, \
corner_lst, xy_lst, birth_semi_1, survival_semi_1, forcing_semi_1, killing_semi_1, living_semi_1,\
regen_birth_semi_1, regen_survival_semi_1
colour_palette.clear()
rule_name = b""
rule_space = b""
bsconditions = b""
n_states = 0
state_weights.clear()
neighbourhood.clear()
neighbourhood_weights.clear()
original_neighbourhood.clear()
alternating_period = 0
birth_state = 0
birth.clear()
survival.clear()
forcing.clear()
killing.clear()
living.clear()
index_map.clear()
activity_list.clear()
regen_birth.clear()
regen_survival.clear()
other_birth.clear()
other_survival.clear()
other_forcing.clear()
other_killing.clear()
other_living.clear()
other_regen_birth.clear()
other_regen_survival.clear()
birth_semi_1.clear()
survival_semi_1.clear()
forcing_semi_1.clear()
killing_semi_1.clear()
living_semi_1.clear()
regen_birth_semi_1.clear()
regen_survival_semi_1.clear()
naive_lst.clear()
direction_lst.clear()
corner_lst.clear()
xy_lst.clear()
corner = -1
xy = -1
direction = b"o"
cdef string rule
cdef int neighbourhood_count = 0
cdef vector[vector[int]] current_neighbourhood_weights
cdef vector[vector[vector[int]]] unflattened_neighbourhood_weights
cdef unordered_set[pair[int, int]] set_neighbourhood
cdef pair[int, int] neighbour, neighbour2
cdef bool parsing_neighbourhood = False
cdef int colour_palette_count = 0
cdef vector[int] temp
cdef bool parsing_colour_palette = False
cdef string section
cdef vector[string] rule_string
cdef int neighbourhood_range = 0
cdef int i, j
cdef vector[vector[int]] weights
cdef vector[pair[int, int]] pair_temp
cdef unordered_map[pair[int, int], int] map_temp
cdef vector[int] k
cdef int num, alt
cdef unordered_set[int] set_temp
cdef unordered_set[pair[int, int]] temp_semi_1
cdef vector[int] extended
file = open(filename, "r")
rule = file.read().encode("utf-8")
for section in rule.split(b"\n"):
if section.find(b"Neighbourhood:") != -1 or section.find(b"#") != -1:
neighbourhood_count = 0
parsing_neighbourhood = True
current_neighbourhood_weights.clear()
continue
elif parsing_neighbourhood:
temp.clear()
for x in section.split(b","):
temp.push_back(int(x))
current_neighbourhood_weights.push_back(temp)
neighbourhood_count += 1
if neighbourhood_count == neighbourhood_range * 2 + 1:
parsing_neighbourhood = False
unflattened_neighbourhood_weights.push_back(current_neighbourhood_weights)
continue
if section.find(b"Colour Palette:") != -1:
parsing_colour_palette = True
continue
elif parsing_colour_palette:
if section.find(b"None") != -1:
colour_palette.clear()
parsing_colour_palette = False
continue
temp.clear()
for x in section.split(b","):
temp.push_back(int(re.sub(b"[() ]", b"", x)))
colour_palette.push_back(temp)
colour_palette_count += 1
if colour_palette_count == n_states:
parsing_colour_palette = False
continue
if section.find(b"Name:") != -1:
rule_name = section.replace(b"Name: ", b"")
elif section.find(b"Neighbourhood Range:") != -1:
neighbourhood_range = int(section.replace(b"Neighbourhood Range: ", b""))
elif section.find(b"State Weights:") != -1:
for x in section.replace(b"State Weights: ", b"").split(b"|"):
temp.clear()
for y in x.split(b","):
temp.push_back(int(y))
state_weights.push_back(temp)
n_states = state_weights[0].size()
elif section.find(b"Rulespace:") != -1:
rule_space = section.replace(b"Rulespace: ", b"")
elif section.find(b"B/S Conditions:") != -1:
bsconditions = section.replace(b"B/S Conditions: ", b"")
elif section.find(b"Rulestring:") != -1:
rule_string = section.replace(b"Rulestring: ", b"").split(b"|")
alternating_period = state_weights.size()
for weights in unflattened_neighbourhood_weights:
pair_temp.clear()
for i in range(-neighbourhood_range, neighbourhood_range + 1):
for j in range(-neighbourhood_range, neighbourhood_range + 1):
if weights[i + neighbourhood_range][j + neighbourhood_range] != 0:
pair_temp.push_back(pair[int, int] (i, j))
neighbourhood.push_back(pair_temp)
if bsconditions == b"Double Totalistic":
original_neighbourhood = neighbourhood
neighbourhood.clear()
for i in range(alternating_period):
set_neighbourhood.clear()
for neighbour in original_neighbourhood[i]:
for neighbour2 in original_neighbourhood[i]:
set_neighbourhood.insert(pair[int, int] (neighbour.first + neighbour2.first,
neighbour.second + neighbour2.second))
set_neighbourhood.insert(neighbour)
pair_temp.clear()
pair_temp.insert(pair_temp.end(), set_neighbourhood.begin(), set_neighbourhood.end())
neighbourhood.push_back(pair_temp)
map_temp.clear()
for j in range(len(neighbourhood[i])):
map_temp[neighbourhood[i][j]] = j
index_map.push_back(map_temp)
for weights in unflattened_neighbourhood_weights:
temp.clear()
for k in weights:
for j in k:
if j != 0:
temp.push_back(j)
neighbourhood_weights.push_back(temp)
if rule_space == b"Single State":
for individual_rule_string in rule_string:
if bsconditions == b"Outer Totalistic":
if individual_rule_string.find(b"/") != -1:
set_temp.clear()
for x in individual_rule_string.split(b"/")[1].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
birth.push_back(set_temp)
set_temp.clear()
for x in individual_rule_string.split(b"/")[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
survival.push_back(set_temp)
try: naive_lst.push_back(individual_rule_string.split(b"/")[2])
except IndexError: naive_lst.push_back(b"-1")
else:
set_temp.clear()
for x in re.split(b"b|s|nn", individual_rule_string)[1].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
birth.push_back(set_temp)
set_temp.clear()
for x in re.split(b"b|s|nn", individual_rule_string)[2].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
survival.push_back(set_temp)
try: naive_lst.push_back(re.split(b"b|s|nn", individual_rule_string)[3])
except IndexError: naive_lst.push_back(b"-1")
elif bsconditions == b"Double Totalistic":
if individual_rule_string.find(b"/") != -1:
set_temp.clear()
for x in re.findall(b"\((.*?)\)", individual_rule_string.split(b"/")[1])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
birth.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", individual_rule_string.split(b"/")[0])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
survival.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", individual_rule_string.split(b"/")[1]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_birth.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", individual_rule_string.split(b"/")[0]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_survival.push_back(set_temp)
try: naive_lst.push_back(individual_rule_string.split(b"/")[2])
except IndexError: naive_lst.push_back(b"-1")
else:
set_temp.clear()
for x in re.findall(b"\((.*?)\)", re.split(b"b|s|nn", individual_rule_string)[1])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
birth.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", re.split(b"b|s|nn", individual_rule_string)[2])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
survival.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", re.split(b"b|s|nn", individual_rule_string)[1]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_birth.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", re.split(b"b|s|nn", individual_rule_string)[2]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_survival.push_back(set_temp)
try: naive_lst.push_back(re.split(b"b|s|nn", individual_rule_string)[3])
except IndexError: naive_lst.push_back(b"-1")
elif bsconditions == b"Range 1 Moore Semi Totalistic":
if individual_rule_string.find(b"/") != -1:
temp_semi_1.clear()
current_trans = []
for x in individual_rule_string.split(b"/")[1]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
birth_semi_1.push_back(temp_semi_1)
temp_semi_1.clear()
current_trans = []
for x in individual_rule_string.split(b"/")[0]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
survival_semi_1.push_back(temp_semi_1)
file = open("log.log", "a")
file.write(str(birth_semi_1) + " " + str(survival_semi_1) + "\n")
file.close()
try: naive_lst.push_back(individual_rule_string.split(b"/")[2])
except IndexError: naive_lst.push_back(b"-1")
else:
temp_semi_1.clear()
current_trans = []
for x in re.split(b"b|s|nn", individual_rule_string)[1]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
birth_semi_1.push_back(temp_semi_1)
temp_semi_1.clear()
for x in re.split(b"b|s|nn", individual_rule_string)[2]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
survival_semi_1.push_back(temp_semi_1)
try: naive_lst.push_back(re.split(b"b|s|nn", individual_rule_string)[3])
except IndexError: naive_lst.push_back(b"-1")
elif rule_space == b"BSFKL":
for individual_rule_string in rule_string:
if bsconditions == b"Outer Totalistic":
if individual_rule_string.find(b"/") != -1:
set_temp.clear()
for x in individual_rule_string.split(b"/")[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
birth.push_back(set_temp)
set_temp.clear()
for x in individual_rule_string.split(b"/")[1].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
survival.push_back(set_temp)
set_temp.clear()
for x in individual_rule_string.split(b"/")[2].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
forcing.push_back(set_temp)
set_temp.clear()
for x in individual_rule_string.split(b"/")[3].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
killing.push_back(set_temp)
set_temp.clear()
for x in individual_rule_string.split(b"/")[4].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
living.push_back(set_temp)
try: naive_lst.push_back(individual_rule_string.split(b"/")[5])
except IndexError: naive_lst.push_back(b"-1")
else:
set_temp.clear()
for x in re.split(b"b|s|f|k|l|nn", individual_rule_string)[1].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
birth.push_back(set_temp)
set_temp.clear()
for x in re.split(b"b|s|f|k|l|nn", individual_rule_string)[2].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
survival.push_back(set_temp)
set_temp.clear()
for x in re.split(b"b|s|f|k|l|nn", individual_rule_string)[3].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
forcing.push_back(set_temp)
set_temp.clear()
for x in re.split(b"b|s|f|k|l|nn", individual_rule_string)[4].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
killing.push_back(set_temp)
set_temp.clear()
for x in re.split(b"b|s|f|k|l|nn", individual_rule_string)[5].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
living.push_back(set_temp)
try: naive_lst.push_back(re.split(b"b|s|f|k|l|nn", individual_rule_string)[6])
except IndexError: naive_lst.push_back(b"-1")
elif bsconditions == b"Double Totalistic":
if individual_rule_string.find(b"/") != -1:
set_temp.clear()
for x in re.findall(b"\((.*?)\)", individual_rule_string.split(b"/")[0])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
birth.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", individual_rule_string.split(b"/")[1])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
survival.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", individual_rule_string.split(b"/")[2])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
forcing.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", individual_rule_string.split(b"/")[3])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
killing.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", individual_rule_string.split(b"/")[4])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
living.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", individual_rule_string.split(b"/")[0]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_birth.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", individual_rule_string.split(b"/")[1]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_survival.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", individual_rule_string.split(b"/")[2]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_forcing.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", individual_rule_string.split(b"/")[3]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_killing.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", individual_rule_string.split(b"/")[4]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_living.push_back(set_temp)
try: naive_lst.push_back(individual_rule_string.split(b"/")[5])
except IndexError: naive_lst.push_back(b"-1")
else:
set_temp.clear()
for x in re.findall(b"\((.*?)\)", re.split(b"b|s|f|k|l|nn", individual_rule_string)[1])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
birth.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", re.split(b"b|s|f|k|l|nn", individual_rule_string)[2])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
survival.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", re.split(b"b|s|f|k|l|nn", individual_rule_string)[3])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
forcing.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", re.split(b"b|s|f|k|l|nn", individual_rule_string)[4])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
killing.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", re.split(b"b|s|f|k|l|nn", individual_rule_string)[5])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
living.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", re.split(b"b|s|f|k|l|nn", individual_rule_string)[1]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_birth.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", re.split(b"b|s|f|k|l|nn", individual_rule_string)[2]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_survival.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", re.split(b"b|s|f|k|l|nn", individual_rule_string)[3]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_forcing.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", re.split(b"b|s|f|k|l|nn", individual_rule_string)[4]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_killing.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", re.split(b"b|s|f|k|l|nn", individual_rule_string)[5]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_living.push_back(set_temp)
try: naive_lst.push_back(re.split(b"b|s|f|k|l|nn", individual_rule_string)[6])
except IndexError: naive_lst.push_back(b"-1")
elif bsconditions == b"Range 1 Moore Semi Totalistic":
if individual_rule_string.find(b"/") != -1:
current_trans = []
temp_semi_1.clear()
for x in individual_rule_string.split(b"/")[0]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
birth_semi_1.push_back(temp_semi_1)
current_trans = []
temp_semi_1.clear()
for x in individual_rule_string.split(b"/")[1]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
survival_semi_1.push_back(temp_semi_1)
current_trans = []
temp_semi_1.clear()
for x in individual_rule_string.split(b"/")[2]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
forcing_semi_1.push_back(temp_semi_1)
current_trans = []
temp_semi_1.clear()
for x in individual_rule_string.split(b"/")[3]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
killing_semi_1.push_back(temp_semi_1)
current_trans = []
temp_semi_1.clear()
for x in individual_rule_string.split(b"/")[4]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
living_semi_1.push_back(temp_semi_1)
try: naive_lst.push_back(individual_rule_string.split(b"/")[5])
except IndexError: naive_lst.push_back(b"-1")
else:
current_trans = []
temp_semi_1.clear()
for x in re.split(b"b|s|f|k|l|nn", individual_rule_string)[1]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
birth_semi_1.push_back(temp_semi_1)
current_trans = []
temp_semi_1.clear()
for x in re.split(b"b|s|f|k|l|nn", individual_rule_string)[2]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
survival_semi_1.push_back(temp_semi_1)
current_trans = []
temp_semi_1.clear()
for x in re.split(b"b|s|f|k|l|nn", individual_rule_string)[3]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
forcing_semi_1.push_back(temp_semi_1)
current_trans = []
temp_semi_1.clear()
for x in re.split(b"b|s|f|k|l|nn", individual_rule_string)[4]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
killing_semi_1.push_back(temp_semi_1)
current_trans = []
temp_semi_1.clear()
for x in re.split(b"b|s|f|k|l|nn", individual_rule_string)[5]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
living_semi_1.push_back(temp_semi_1)
try: naive_lst.push_back(re.split(b"b|s|f|k|l|nn", individual_rule_string)[6])
except IndexError: naive_lst.push_back(b"-1")
elif rule_space == b"Extended Generations":
for individual_rule_string in rule_string:
if bsconditions == b"Outer Totalistic":
if individual_rule_string.find(b"/") != -1:
set_temp.clear()
for x in individual_rule_string.split(b"/")[1].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
birth.push_back(set_temp)
set_temp.clear()
for x in individual_rule_string.split(b"/")[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
survival.push_back(set_temp)
extended.clear()
for x in individual_rule_string.split(b"/")[2].split(b"-"):
extended.push_back(int(x))
try: naive_lst.push_back(int(individual_rule_string.split(b"/")[3]))
except IndexError: naive_lst.push_back(b"-1")
else:
set_temp.clear()
for x in re.split(b"b|s|d|nn", individual_rule_string)[1].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
birth.push_back(set_temp)
set_temp.clear()
for x in re.split(b"b|s|d|nn", individual_rule_string)[2].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
survival.push_back(set_temp)
extended.clear()
for x in re.split(b"b|s|d|nn", individual_rule_string)[3].split(b"-"):
extended.push_back(int(x))
try: naive_lst.push_back(re.split(b"b|s|d|nn", individual_rule_string)[4])
except IndexError: naive_lst.push_back(b"-1")
elif bsconditions == b"Double Totalistic":
if individual_rule_string.find(b"/") != -1:
set_temp.clear()
for x in re.findall(b"\((.*?)\)", individual_rule_string.split(b"/")[1])[0].split(b","):
set_temp.insert(int(x))
birth.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", individual_rule_string.split(b"/")[0])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
survival.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", individual_rule_string.split(b"/")[1]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_birth.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", individual_rule_string.split(b"/")[0]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_survival.push_back(set_temp)
extended.clear()
for x in individual_rule_string.split(b"/")[2].split(b"-"):
extended.push_back(int(x))
try: naive_lst.push_back(individual_rule_string.split(b"/")[3])
except IndexError: naive_lst.push_back(b"-1")
else:
set_temp.clear()
for x in re.findall(b"\((.*?)\)", re.split(b"[bsd]", individual_rule_string)[1])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
birth.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", re.split(b"[bsd]", individual_rule_string)[2])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
survival.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", re.split(b"[bsd]", individual_rule_string)[1]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_birth.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", re.split(b"[bsd]", individual_rule_string)[2]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_survival.push_back(set_temp)
extended.clear()
for x in re.split(b"[bsd]", individual_rule_string)[3].split(b"-"):
extended.push_back(int(x))
try: naive_lst.push_back(re.split(b"b|s|d|nn", individual_rule_string)[4])
except IndexError: naive_lst.push_back(b"-1")
elif bsconditions == b"Range 1 Moore Semi Totalistic":
if individual_rule_string.find(b"/") != -1:
temp_semi_1.clear()
current_trans = []
for x in individual_rule_string.split(b"/")[1]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
birth_semi_1.push_back(temp_semi_1)
temp_semi_1.clear()
current_trans = []
for x in individual_rule_string.split(b"/")[0]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
survival_semi_1.push_back(temp_semi_1)
file = open("log.log", "a")
file.write(str(birth_semi_1) + " " + str(survival_semi_1) + "\n")
file.close()
try: naive_lst.push_back(individual_rule_string.split(b"/")[3])
except IndexError: naive_lst.push_back(b"-1")
else:
temp_semi_1.clear()
current_trans = []
for x in re.split(b"b|s|d|nn", individual_rule_string)[1]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
birth_semi_1.push_back(temp_semi_1)
temp_semi_1.clear()
for x in re.split(b"b|s|d|nn", individual_rule_string)[2]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
survival_semi_1.push_back(temp_semi_1)
extended.clear()
for x in re.split(b"b|s|d|nn", individual_rule_string)[3].split(b"-"):
extended.push_back(int(x))
try: naive_lst.push_back(re.split(b"b|s|nn", individual_rule_string)[4])
except IndexError: naive_lst.push_back(b"-1")
num, alt = 1, 1
set_temp.clear()
for i in extended:
for j in range(num, i + num):
if alt > 0:
set_temp.insert(j)
num += 1
alt *= -1
activity_list.push_back(set_temp)
elif rule_space == b"Regenerating Generations":
for individual_rule_string in rule_string:
if bsconditions == b"Outer Totalistic":
if individual_rule_string.find(b"/") != -1:
birth_state = int(individual_rule_string.split(b"/")[1])
set_temp.clear()
for x in individual_rule_string.split(b"/")[2].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
birth.push_back(set_temp)
set_temp.clear()
for x in individual_rule_string.split(b"/")[3].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
survival.push_back(set_temp)
set_temp.clear()
for x in individual_rule_string.split(b"/")[4].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
regen_birth.push_back(set_temp)
set_temp.clear()
for x in individual_rule_string.split(b"/")[5].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
regen_survival.push_back(set_temp)
try: naive_lst.push_back(individual_rule_string.split(b"/")[6])
except IndexError: naive_lst.push_back(b"-1")
else:
birth_state = int(re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[2])
set_temp.clear()
for x in re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[3].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
birth.push_back(set_temp)
set_temp.clear()
for x in re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[4].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
survival.push_back(set_temp)
set_temp.clear()
for x in re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[5].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
regen_birth.push_back(set_temp)
set_temp.clear()
for x in re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[6].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
regen_survival.push_back(set_temp)
try: naive_lst.push_back(re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[7])
except IndexError: naive_lst.push_back(b"-1")
elif bsconditions == b"Double Totalistic":
if individual_rule_string.find(b"/") != -1:
birth_state = int(individual_rule_string.split(b"/")[1])
set_temp.clear()
for x in re.findall(b"\((.*?)\)", individual_rule_string.split(b"/")[2])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
birth.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", individual_rule_string.split(b"/")[3])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
survival.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", individual_rule_string.split(b"/")[2]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_birth.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", individual_rule_string.split(b"/")[3]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_survival.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", individual_rule_string.split(b"/")[4])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
regen_birth.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", individual_rule_string.split(b"/")[5])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
regen_survival.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", individual_rule_string.split(b"/")[4]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_regen_birth.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", individual_rule_string.split(b"/")[5]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_regen_survival.push_back(set_temp)
try: naive_lst.push_back(individual_rule_string.split(b"/")[6])
except IndexError: naive_lst.push_back(b"-1")
else:
birth_state = int(re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[2])
set_temp.clear()
for x in re.findall(b"\((.*?)\)", re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[3])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
birth.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[4])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
survival.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[3]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_birth.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[4]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_survival.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[5])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
regen_birth.push_back(set_temp)
set_temp.clear()
for x in re.findall(b"\((.*?)\)", re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[6])[0].split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
regen_survival.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[5]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_regen_birth.push_back(set_temp)
set_temp.clear()
for x in re.sub(b"\(.*?\)", b"", re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[6]).split(b","):
if x.find(b"-") != -1:
for i in range(int(x.split(b"-")[0]), int(x.split(b"-")[1]) + 1):
set_temp.insert(i)
else:
set_temp.insert(int(x))
other_regen_survival.push_back(set_temp)
try: naive_lst.push_back(re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[7])
except IndexError: naive_lst.push_back(b"-1")
elif bsconditions == b"Range 1 Moore Semi Totalistic":
if individual_rule_string.find(b"/") != -1:
birth_state = int(individual_rule_string.split(b"/")[1])
current_trans = []
temp_semi_1.clear()
for x in individual_rule_string.split(b"/")[2]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
birth_semi_1.push_back(temp_semi_1)
current_trans = []
temp_semi_1.clear()
for x in individual_rule_string.split(b"/")[3]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
survival_semi_1.push_back(temp_semi_1)
current_trans = []
temp_semi_1.clear()
for x in individual_rule_string.split(b"/")[4]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
regen_birth_semi_1.push_back(temp_semi_1)
current_trans = []
temp_semi_1.clear()
for x in individual_rule_string.split(b"/")[5]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
regen_survival_semi_1.push_back(temp_semi_1)
try: naive_lst.push_back(individual_rule_string.split(b"/")[6])
except IndexError: naive_lst.push_back(b"-1")
else:
birth_state = int(re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[2])
current_trans = []
temp_semi_1.clear()
for x in re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[3]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
birth_semi_1.push_back(temp_semi_1)
current_trans = []
temp_semi_1.clear()
for x in re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[4]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
survival_semi_1.push_back(temp_semi_1)
current_trans = []
temp_semi_1.clear()
for x in re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[5]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
regen_birth_semi_1.push_back(temp_semi_1)
current_trans = []
temp_semi_1.clear()
for x in re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[6]:
current_trans.append(int(str(x)))
if len(current_trans) == 2:
temp_semi_1.insert(pair[int, int] (current_trans[0] - 48, current_trans[1] - 48))
current_trans = []
regen_survival_semi_1.push_back(temp_semi_1)
try: naive_lst.push_back(re.split(b"rg|l|b|s|rb|rs|nn", individual_rule_string)[7])
except IndexError: naive_lst.push_back(b"-1")
for x in naive_lst:
if x != b"-1":
corner_lst.push_back(int(x.decode("utf-8")[0]))
direction_lst.push_back(str(x.decode("utf-8")[1]).encode("utf-8"))
xy_lst.push_back(int(x.decode("utf-8")[2]))
else:
corner_lst.push_back(-1)
direction_lst.push_back(b"")
xy_lst.push_back(-1)
cpdef vector[pair[int, int]] get_neighbourhood(int generations):
return neighbourhood[generations % alternating_period]
cpdef int get_n_states():
return n_states
cpdef vector[vector[int]] get_colour_palette():
return colour_palette
cpdef string get_rule_name():
return rule_name
cdef int transition_func(vector[int] neighbours, int generations):
cdef int n_living = 0, n_destructive = 0, n = 0, n_birth = 0, n_survival = 0, index, found_index, idx, \
n_regen_birth = 0, n_regen_survival = 0, n_forcing = 0, n_killing = 0, n1 = 0, n2 = 0, \
n_edge = 0, n_corner = 0, n_edge_destructive = 0, n_corner_destructive = 0
cdef pair[int, int] neighbour, neighbour2, alive_semi_1, destructive_semi_1
file = open("log.log", "a")
file.write(str(birth) + " " + str(survival) + "\n")
file.close()
if rule_space == b"BSFKL":
if bsconditions == b"Outer Totalistic":
for i in range(neighbours.size() - 1):
if neighbours[i] == 1:
n_living += neighbourhood_weights[generations % alternating_period][i]
elif neighbours[i] == 2:
n_destructive += neighbourhood_weights[generations % alternating_period][i]
if neighbours[neighbours.size() - 1] == 1:
if killing[generations % alternating_period].find(n_destructive) != \
killing[generations % alternating_period].end():
return 0
elif survival[generations % alternating_period].find(n_living) != \
survival[generations % alternating_period].end():
return 1
return 2
elif neighbours[neighbours.size() - 1] == 2:
if living[generations % alternating_period].find(n_living) != \
living[generations % alternating_period].end():
return 0
return 2
else:
if forcing[generations % alternating_period].find(n_destructive) != \
forcing[generations % alternating_period].end() and \
birth[generations % alternating_period].find(n_living) != \
birth[generations % alternating_period].end():
return 1
return 0
elif bsconditions == b"Double Totalistic":
n_birth = 0
n_survival = 0
n_living = 0
n_forcing = 0
n_killing = 0
for neighbour in original_neighbourhood[generations % alternating_period]:
n1, n2 = 0, 0
idx = 0
for neighbour2 in original_neighbourhood[generations % alternating_period]:
if neighbours[index_map[generations % alternating_period][pair[int, int]
(neighbour.first + neighbour2.first, neighbour.second + neighbour2.second)]] == 1:
n1 += neighbourhood_weights[generations % alternating_period][idx]
if neighbours[index_map[generations % alternating_period][pair[int, int]
(neighbour.first + neighbour2.first, neighbour.second + neighbour2.second)]] == 2:
n2 += neighbourhood_weights[generations % alternating_period][idx]
idx += 1
if other_birth[generations % alternating_period].find(n1) != \
other_birth[generations % alternating_period].end():
n_birth += 1
if other_survival[generations % alternating_period].find(n1) != \
other_survival[generations % alternating_period].end():
n_survival += 1
if other_living[generations % alternating_period].find(n1) != \
other_living[generations % alternating_period].end():
n_living += 1
if other_forcing[generations % alternating_period].find(n2) != \
other_forcing[generations % alternating_period].end():
n_forcing += 1
if other_killing[generations % alternating_period].find(n2) != \
other_killing[generations % alternating_period].end():
n_killing += 1
if neighbours[neighbours.size() - 1] == 1:
if killing[generations % alternating_period].find(n_killing) != \
killing[generations % alternating_period].end():
return 0
elif survival[generations % alternating_period].find(n_survival) != \
survival[generations % alternating_period].end():
return 1
return 2
elif neighbours[neighbours.size() - 1] == 2:
if living[generations % alternating_period].find(n_living) != \
living[generations % alternating_period].end():
return 0
return 2
else:
if forcing[generations % alternating_period].find(n_forcing) != \
forcing[generations % alternating_period].end() and \
birth[generations % alternating_period].find(n_birth) != \
birth[generations % alternating_period].end():
return 1
return 0
elif bsconditions == b"Range 1 Moore Semi Totalistic":
for i in range(len(neighbours) - 1):
if neighbourhood[generations % alternating_period][i] == pair[int, int] (0, -1) or \
neighbourhood[generations % alternating_period][i] == pair[int, int] (0, 1) or \
neighbourhood[generations % alternating_period][i] == pair[int, int] (1, 0) or \
neighbourhood[generations % alternating_period][i] == pair[int, int] (-1, 0):
if neighbours[i] == 1:
n_edge += 1
elif neighbours[i] == 2:
n_edge_destructive += 1
else:
if neighbours[i] == 1:
n_corner += 1
elif neighbours[i] == 2:
n_corner_destructive += 1
alive_semi_1 = pair[int, int] (n_corner, n_edge)
destructive_semi_1 = pair[int, int] (n_corner_destructive, n_edge_destructive)
if neighbours[neighbours.size() - 1] == 1:
if killing_semi_1[generations % alternating_period].find(destructive_semi_1) != \
killing_semi_1[generations % alternating_period].end():
return 0
elif survival_semi_1[generations % alternating_period].find(alive_semi_1) != \
survival_semi_1[generations % alternating_period].end():
return 1
return 2
elif neighbours[neighbours.size() - 1] == 2:
if living_semi_1[generations % alternating_period].find(alive_semi_1) != \
living_semi_1[generations % alternating_period].end():
return 0
return 2
else:
if forcing_semi_1[generations % alternating_period].find(destructive_semi_1) != \
forcing_semi_1[generations % alternating_period].end() and \
birth_semi_1[generations % alternating_period].find(alive_semi_1) != \
birth_semi_1[generations % alternating_period].end():
return 1
return 0
elif rule_space == b"Extended Generations":
if bsconditions == b"Outer Totalistic":
for i in range(neighbours.size() - 1):
n += neighbourhood_weights[generations % alternating_period][i] * \
state_weights[generations % alternating_period][neighbours[i]]
if activity_list[generations % alternating_period].find(neighbours[neighbours.size() - 1]) != \
activity_list[generations % alternating_period].end():
if survival[generations % alternating_period].find(n) != \
survival[generations % alternating_period].end():
return neighbours[neighbours.size() - 1]
return (neighbours[neighbours.size() - 1] + 1) % n_states
elif neighbours[neighbours.size() - 1] == 0:
if birth[generations % alternating_period].find(n) != \
birth[generations % alternating_period].end():
return 1
return 0
elif bsconditions == b"Double Totalistic":
n_birth = 0
n_survival = 0
for neighbour in original_neighbourhood[generations % alternating_period]:
n = 0
idx = 0
for neighbour2 in original_neighbourhood[generations % alternating_period]:
n += neighbourhood_weights[generations % alternating_period][idx] * \
state_weights[generations % alternating_period][neighbours[index_map[
generations % alternating_period][pair[int, int]
(neighbour.first + neighbour2.first, neighbour.second + neighbour2.second)]]]
idx += 1
if other_birth[generations % alternating_period].find(n) != \
other_birth[generations % alternating_period].end():
n_birth += 1
if other_survival[generations % alternating_period].find(n) != \
other_survival[generations % alternating_period].end():
n_survival += 1
if activity_list[generations % alternating_period].find(neighbours[neighbours.size() - 1]) != \
activity_list[generations % alternating_period].end():
if survival[generations % alternating_period].find(n_survival) != \
survival[generations % alternating_period].end():
return 1
return 2
elif neighbours[neighbours.size() - 1] == 0:
if birth[generations % alternating_period].find(n_birth) != \
birth[generations % alternating_period].end():
return 1
return 0
elif bsconditions == b"Range 1 Moore Semi Totalistic":
n_edge, n_corner = 0, 0
for i in range(len(neighbours) - 1):
if neighbourhood[generations % alternating_period][i] == pair[int, int] (0, -1) or \
neighbourhood[generations % alternating_period][i] == pair[int, int] (0, 1) or \
neighbourhood[generations % alternating_period][i] == pair[int, int] (1, 0) or \
neighbourhood[generations % alternating_period][i] == pair[int, int] (-1, 0):
n_edge += state_weights[generations % alternating_period][neighbours[i]]
else:
n_corner += state_weights[generations % alternating_period][neighbours[i]]
if neighbours[neighbours.size() - 1] == 0:
if birth_semi_1[generations % alternating_period].find(pair[int, int] (n_corner, n_edge)) != \
birth_semi_1[generations % alternating_period].end():
return 1
return 0
elif neighbours[neighbours.size() - 1] == 1:
if survival_semi_1[generations % alternating_period].find(pair[int, int] (n_corner, n_edge)) != \
survival_semi_1[generations % alternating_period].end():
return 1
return 2
elif rule_space == b"Single State":
if bsconditions == b"Outer Totalistic":
for i in range(neighbours.size() - 1):
n += neighbourhood_weights[generations % alternating_period][i] * \
state_weights[generations % alternating_period][neighbours[i]]
if neighbours[neighbours.size() - 1] == 1:
if survival[generations % alternating_period].find(n) != \
survival[generations % alternating_period].end():
return 1
return 0
else:
if birth[generations % alternating_period].find(n) != \
birth[generations % alternating_period].end():
return 1
return 0
elif bsconditions == b"Double Totalistic":
n_birth = 0
n_survival = 0
for neighbour in original_neighbourhood[generations % alternating_period]:
n = 0
idx = 0
for neighbour2 in original_neighbourhood[generations % alternating_period]:
n += neighbourhood_weights[generations % alternating_period][idx] * \
state_weights[generations % alternating_period][neighbours[index_map[
generations % alternating_period][pair[int, int]
(neighbour.first + neighbour2.first, neighbour.second + neighbour2.second)]]]
idx += 1
if other_birth[generations % alternating_period].find(n) != \
other_birth[generations % alternating_period].end():
n_birth += 1
if other_survival[generations % alternating_period].find(n) != \
other_survival[generations % alternating_period].end():
n_survival += 1
if neighbours[neighbours.size() - 1] == 1:
if survival[generations % alternating_period].find(n_survival) != \
survival[generations % alternating_period].end():
return 1
return 0
elif neighbours[neighbours.size() - 1] == 0:
if birth[generations % alternating_period].find(n_birth) != \
birth[generations % alternating_period].end():
return 1
return 0
elif bsconditions == b"Range 1 Moore Semi Totalistic":
n_edge, n_corner = 0, 0
for i in range(len(neighbours) - 1):
if neighbourhood[generations % alternating_period][i] == pair[int, int] (0, -1) or \
neighbourhood[generations % alternating_period][i] == pair[int, int] (0, 1) or \
neighbourhood[generations % alternating_period][i] == pair[int, int] (1, 0) or \
neighbourhood[generations % alternating_period][i] == pair[int, int] (-1, 0):
n_edge += neighbours[i]
else:
n_corner += neighbours[i]
if neighbours[neighbours.size() - 1] == 0:
if birth_semi_1[generations % alternating_period].find(pair[int, int] (n_corner, n_edge)) != \
birth_semi_1[generations % alternating_period].end():
return 1
return 0
elif neighbours[neighbours.size() - 1] == 1:
if survival_semi_1[generations % alternating_period].find(pair[int, int] (n_corner, n_edge)) != \
survival_semi_1[generations % alternating_period].end():
return 1
return 0
elif rule_space == b"Regenerating Generations":
if bsconditions == b"Outer Totalistic":
for i in range(neighbours.size() - 1):
n += neighbourhood_weights[generations % alternating_period][i] * \
state_weights[generations % alternating_period][neighbours[i]]
if neighbours[neighbours.size() - 1] == 0:
if birth[generations % alternating_period].find(n) != \
birth[generations % alternating_period].end():
return birth_state
return 0
elif neighbours[neighbours.size() - 1] == 1:
if survival[generations % alternating_period].find(n) != \
survival[generations % alternating_period].end():
return 1
return 2
else:
if regen_birth[generations % alternating_period].find(n) != \
regen_birth[generations % alternating_period].end():
return neighbours[neighbours.size() - 1] - 1
elif regen_survival[generations % alternating_period].find(n) != \
regen_survival[generations % alternating_period].end():
return neighbours[neighbours.size() - 1]
return (neighbours[neighbours.size() - 1] + 1) % n_states
elif bsconditions == b"Double Totalistic":
n_birth, n_survival, n_regen_birth, n_regen_survival = 0, 0, 0, 0
for neighbour in original_neighbourhood[generations % alternating_period]:
n = 0
idx = 0
for neighbour2 in original_neighbourhood[generations % alternating_period]:
n += neighbourhood_weights[generations % alternating_period][idx] * \
state_weights[generations % alternating_period][neighbours[index_map[
generations % alternating_period][pair[int, int]
(neighbour.first + neighbour2.first, neighbour.second + neighbour2.second)]]]
idx += 1
if other_birth[generations % alternating_period].find(n) != \
other_birth[generations % alternating_period].end():
n_birth += 1
if other_survival[generations % alternating_period].find(n) != \
other_survival[generations % alternating_period].end():
n_survival += 1
if other_regen_birth[generations % alternating_period].find(n) != \
other_regen_birth[generations % alternating_period].end():
n_regen_birth += 1
if other_regen_survival[generations % alternating_period].find(n) != \
other_regen_survival[generations % alternating_period].end():
n_regen_survival += 1
if neighbours[neighbours.size() - 1] == 0:
if birth[generations % alternating_period].find(n_birth) != \
birth[generations % alternating_period].end():
return birth_state
return 0
elif neighbours[neighbours.size() - 1] == 1:
if survival[generations % alternating_period].find(n_survival) != \
survival[generations % alternating_period].end():
return 1
return 2
else:
if regen_birth[generations % alternating_period].find(n_regen_birth) != \
regen_birth[generations % alternating_period].end():
return neighbours[neighbours.size() - 1] - 1
elif regen_survival[generations % alternating_period].find(n_regen_survival) != \
regen_survival[generations % alternating_period].end():
return neighbours[neighbours.size() - 1]
return (neighbours[neighbours.size() - 1] + 1) % n_states
elif bsconditions == b"Range 1 Moore Semi Totalistic":
n_edge, n_corner = 0, 0
for i in range(len(neighbours) - 1):
if neighbourhood[generations % alternating_period][i] == pair[int, int] (0, -1) or \
neighbourhood[generations % alternating_period][i] == pair[int, int] (0, 1) or \
neighbourhood[generations % alternating_period][i] == pair[int, int] (1, 0) or \
neighbourhood[generations % alternating_period][i] == pair[int, int] (-1, 0):
n_edge += state_weights[generations % alternating_period][neighbours[i]]
else:
n_corner += state_weights[generations % alternating_period][neighbours[i]]
if neighbours[neighbours.size() - 1] == 0:
if birth_semi_1[generations % alternating_period].find(pair[int, int] (n_edge, n_corner)) != \
birth_semi_1[generations % alternating_period].end():
return birth_state
return 0
elif neighbours[neighbours.size() - 1] == 1:
if survival_semi_1[generations % alternating_period].find(pair[int, int] (n_edge, n_corner)) != \
survival_semi_1[generations % alternating_period].end():
return 1
return 2
else:
if regen_birth_semi_1[generations % alternating_period].find(pair[int, int] (n_edge, n_corner)) != \
regen_birth_semi_1[generations % alternating_period].end():
return neighbours[neighbours.size() - 1] - 1
elif regen_survival_semi_1[generations % alternating_period].find(
pair[int, int] (n_edge, n_corner)) != \
regen_survival_semi_1[generations % alternating_period].end():
return neighbours[neighbours.size() - 1]
return (neighbours[neighbours.size() - 1] + 1) % n_states
cdef int depend_on_neighbours(int state, int generations):
if rule_space == b"BSFKL" or rule_space == b"Single State" or rule_space == b"Regenerating Generations":
return -1
elif rule_space == b"Extended Generations":
if activity_list[generations % alternating_period].find(state) != \
activity_list[generations % alternating_period].end() or state == 0:
return -1
else:
return (state + 1) % n_states
cdef unordered_map[pair[int, int], int] depends_cache
cdef map[pair[vector[int], int], int] transition_func_cache
cdef bool compare_pairs(pair[int, int] a, pair[int, int] b):
if direction == b"o":
if corner == 0:
if xy == 0:
if a.second == b.second:
return a.first < b.first
return a.second < b.second
elif xy == 1:
if a.first == b.first:
return a.second < b.second
return a.first < b.first
elif corner == 1:
if xy == 0:
if a.second == b.second:
return a.first < b.first
return a.second > b.second
elif xy == 1:
if a.first == b.first:
return a.second > b.second
return a.first < b.first
elif corner == 2:
if xy == 0:
if a.second == b.second:
return a.first > b.first
return a.second < b.second
elif xy == 1:
if a.first == b.first:
return a.second < b.second
return a.first > b.first
elif corner == 3:
if xy == 0:
if a.second == b.second:
return a.first > b.first
return a.second > b.second
elif xy == 1:
if a.first == b.first:
return a.second > b.second
return a.first > b.first
elif direction == b"d":
if corner == 0:
if xy == 0:
if a.first + a.second == b.first + b.second:
return a.first < b.first
return a.first + a.second < b.first + b.second
elif xy == 1:
if a.first + a.second == b.first + b.second:
return a.first > b.first
return a.first + a.second < b.first + b.second
elif corner == 1:
if xy == 0:
if a.first - a.second == b.first - b.second:
return a.first < b.first
return a.first - a.second < b.first - b.second
elif xy == 1:
if a.first - a.second == b.first - b.second:
return a.first > b.first
return a.first - a.second < b.first - b.second
elif corner == 2:
if xy == 0:
if a.first - a.second == b.first - b.second:
return a.first < b.first
return a.first - a.second > b.first - b.second
elif xy == 1:
if a.first - a.second == b.first - b.second:
return a.first > b.first
return a.first - a.second > b.first - b.second
elif corner == 3:
if xy == 0:
if a.first + a.second == b.first + b.second:
return a.first < b.first
return a.first + a.second > b.first + b.second
elif xy == 1:
if a.first + a.second == b.first + b.second:
return a.first > b.first
return a.first + a.second > b.first + b.second
cpdef compute(unordered_set[pair[int, int]] cells_changed,
unordered_map[pair[int, int], int] copy_grid, unordered_map[pair[int, int], int] dict_grid,
int generations):
global corner, direction, xy
cdef vector[int] neighbours
neighbours.reserve(neighbourhood[generations % alternating_period].size() + 1)
cdef unordered_set[pair[int, int]] cells_to_check
cdef int i, j
cdef int ans
cdef vector[pair[int, int]] cells_to_check_vector
cdef pair[int, int] coordinates, coordinates2
cdef pair[int, int] neighbour
for coor in cells_changed:
for neighbour in neighbourhood[generations % alternating_period]:
coordinates.first = coor.first + neighbour.first
coordinates.second = coor.second + neighbour.second
cells_to_check.insert(coordinates)
cells_to_check.insert(coor)
if alternating_period > 1:
if generations % (alternating_period - 1) == 0:
cells_changed.clear()
else:
cells_changed.clear()
corner = corner_lst[generations % alternating_period]
direction = direction_lst[generations % alternating_period]
xy = xy_lst[generations % alternating_period]
if corner == -1:
for coordinates in cells_to_check:
neighbours.clear()
ans = -1
if copy_grid.find(coordinates) == copy_grid.end():
if depends_cache.find(pair[int, int] (0, generations % alternating_period)) == \
depends_cache.end():
ans = depend_on_neighbours(0, generations % alternating_period)
depends_cache[pair[int, int] (0, generations % alternating_period)] = ans
else:
ans = depends_cache[pair[int, int] (0, generations % alternating_period)]
else:
if depends_cache.find(pair[int, int] (copy_grid[coordinates],
generations % alternating_period)) == \
depends_cache.end():
ans = depend_on_neighbours(copy_grid[coordinates], generations % alternating_period)
depends_cache[pair[int, int] (copy_grid[coordinates], generations % alternating_period)] = ans
else:
ans = depends_cache[pair[int, int] (copy_grid[coordinates], generations % alternating_period)]
if ans == -1:
for neighbour in neighbourhood[generations % alternating_period]:
coordinates2 = pair[int, int] (coordinates.first + neighbour.first,
coordinates.second + neighbour.second)
if copy_grid.find(coordinates2) != copy_grid.end():
neighbours.push_back(copy_grid[coordinates2])
else:
neighbours.push_back(0)
if copy_grid.find(coordinates) != copy_grid.end():
neighbours.push_back(copy_grid[coordinates])
if transition_func_cache.find(
pair[vector[int], int] (neighbours, generations % alternating_period)) == \
transition_func_cache.end():
if ans == -1:
ans = transition_func(neighbours, generations % alternating_period)
transition_func_cache[
pair[vector[int], int] (neighbours, generations % alternating_period)] = ans
else:
if ans == -1: ans = transition_func_cache[
pair[vector[int], int] (neighbours, generations % alternating_period)]
if ans == 0:
dict_grid.erase(coordinates)
cells_changed.insert(coordinates)
elif ans != copy_grid[coordinates]:
dict_grid[coordinates] = ans
cells_changed.insert(coordinates)
else:
neighbours.push_back(0)
if transition_func_cache.find(
pair[vector[int], int] (neighbours, generations % alternating_period)) == \
transition_func_cache.end():
if ans == -1:
ans = transition_func(neighbours, generations % alternating_period)
transition_func_cache[
pair[vector[int], int] (neighbours, generations % alternating_period)] = ans
else:
if ans == -1: ans = transition_func_cache[
pair[vector[int], int] (neighbours, generations % alternating_period)]
if ans != 0:
dict_grid.insert(pair[pair[int, int], int] (coordinates, ans))
cells_changed.insert(coordinates)
else:
cells_to_check_vector.assign(cells_to_check.begin(), cells_to_check.end())
sort(cells_to_check_vector.begin(), cells_to_check_vector.end(), compare_pairs)
for coordinates in cells_to_check_vector:
neighbours.clear()
ans = -1
if dict_grid.find(coordinates) == dict_grid.end():
if depends_cache.find(pair[int, int] (0, generations % alternating_period)) == \
depends_cache.end():
ans = depend_on_neighbours(0, generations % alternating_period)
depends_cache[pair[int, int] (0, generations % alternating_period)] = ans
else:
ans = depends_cache[pair[int, int] (0, generations % alternating_period)]
else:
if depends_cache.find(pair[int, int] (dict_grid[coordinates],
generations % alternating_period)) == \
depends_cache.end():
ans = depend_on_neighbours(dict_grid[coordinates], generations % alternating_period)
depends_cache[pair[int, int] (dict_grid[coordinates], generations % alternating_period)] = ans
else:
ans = depends_cache[pair[int, int] (dict_grid[coordinates], generations % alternating_period)]
if ans == -1:
for neighbour in neighbourhood[generations % alternating_period]:
coordinates2 = pair[int, int] (coordinates.first + neighbour.first,
coordinates.second + neighbour.second)
if dict_grid.find(coordinates2) != dict_grid.end():
neighbours.push_back(dict_grid[coordinates2])
else:
neighbours.push_back(0)
if dict_grid.find(coordinates) != dict_grid.end():
neighbours.push_back(dict_grid[coordinates])
if transition_func_cache.find(
pair[vector[int], int] (neighbours, generations % alternating_period)) == \
transition_func_cache.end():
if ans == -1:
ans = transition_func(neighbours, generations % alternating_period)
transition_func_cache[
pair[vector[int], int] (neighbours, generations % alternating_period)] = ans
else:
if ans == -1: ans = transition_func_cache[
pair[vector[int], int] (neighbours, generations % alternating_period)]
if ans == 0:
dict_grid.erase(coordinates)
cells_changed.insert(coordinates)
elif ans != dict_grid[coordinates]:
dict_grid[coordinates] = ans
cells_changed.insert(coordinates)
else:
neighbours.push_back(0)
if transition_func_cache.find(
pair[vector[int], int] (neighbours, generations % alternating_period)) == \
transition_func_cache.end():
if ans == -1:
ans = transition_func(neighbours, generations % alternating_period)
transition_func_cache[
pair[vector[int], int] (neighbours, generations % alternating_period)] = ans
else:
if ans == -1: ans = transition_func_cache[
pair[vector[int], int] (neighbours, generations % alternating_period)]
if ans != 0:
dict_grid.insert(pair[pair[int, int], int] (coordinates, ans))
cells_changed.insert(coordinates)
return cells_changed, dict_grid