ConwayLife.com

Code: Select all

/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
python3   Main.py 

Code: Select all

# 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 = "LtL_r3_12141219"  # Rule Name

...

Code: Select all

import numpy as np

r=3
diam=2*r+1
abirth=np.zeros(diam*diam+1)
asurvival=abirth
abirth[12:15]=1
asurvival[12:20]=1


# 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 = "LtL_r3_12141219"  # Rule Name


range_3_moore = []
for i in range(-3, 4):
    for j in range(-3, 4):
        if i == 0 and j == 0: continue
        range_3_moore.append((i, j))


# Neighbourhood of the Rule (Relative Distance from Central Cell)
def get_neighbourhood(generation):  # Note (y, x) not (x, y)
    return range_3_moore


# Transition Function of Rule, Last Element of Neighbours is the Central Cell
def transition_func(neighbours, generation):
    n=sum(neighbours)

    if neighbours[-1] == 1:
        return asurvival[n]
    else:
        return abirth[n]


# 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

Code: Select all

#Rule = Rule Table
#States = 3
#Counts = 19
#SW 1,0,2
#NW 0,0,0,0,0
#NW 0,1,1,1,0
#NW 0,1,1,1,0
#NW 0,1,1,1,0
#NW 0,0,0,0,0
#RT 0,0,0,0,0,0,1,0,0,0,0,0,2,0,0,0,0,0,0
#RT 0,0,0,0,2,1,1,0,0,0,0,0,0,0,0,0,0,0,0
#RT 0,0,0,0,0,0,0,0,0,0,0,0,2,2,1,0,0,0,0
#Rows = 4
#Columns = 4
#L .3A$.B.A$AB.A$.2A

Code: Select all

# forked from CAViewer/Rules/Others/Rule_1/transFunc.py

rule_table_string = """
0,0,0,0,0,0,1,0,0,0,0,0,2,0,0,0,0,0,0
0,0,0,0,2,1,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,2,2,1,0,0,0,0
"""


lst = []
rule_table = []
###for i in rule_table_string.split("\n")[1:]:
for i in rule_table_string.split("\n")[1:-1]:
    lst = []
    ###for j in i.split(",")[:-1]:
    for j in i.split(","):
        lst.append(int(j))

    rule_table.append(lst)

###
###print(rule_table)

# Information about the Rule (Must be filled)
n_states = len(rule_table)  # Number of States
alternating_period = 1  # For alternating rules / neighbourhoods
colour_palette = None  # Colours of the different states
rule_name = "bipolar00"  # Rule Name

###
###print(n_states)


# 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), #(1, 2),
             (0, -1), (0, 0), (0, 1), #(0, 2),
             (-1, -1), (-1, 0), (-1, 1)#, (-1, 2),
            ]

###
###print(get_neighbourhood(0))


# Transition Function of Rule, Last Element of Neighbours is the Central Cell
def transition_func(neighbours, generation):
    n = 0
    weights = [
                1, 1, 1,# 2,               #3,
                1, 1, 1,# 2,               #2,
                1, 1, 1# 2,
               ]
    state_weights = [1, 0, 2]

    for i in range(len(neighbours) - 1):
        n += ( ###weights[i] * 
         state_weights[neighbours[i]]  )

    try:
        if n >= 0:
            return rule_table[neighbours[-1]][n]
        else:
            return 0
    except IndexError:
        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

Code: Select all

SQC;Rule=Rule-Table;States=3;Counts=19;SW=1,0,2;NW=0,0,0,0,0;NW=0,1,1,1,0;NW=0,1,1,1,0;NW=0,1,1,1,0;NW=0,0,0,0,0;RT=0,0,0,0,0,0,1,0,0,0,0,0,2,0,0,0,0,0,0;RT=0,0,0,0,2,1,1,0,0,0,0,0,0,0,0,0,0,0,0;RT=0,0,0,0,0,0,0,0,0,0,0,0,2,2,1,0,0,0,0

Code: Select all

if state < S : state += 1

Code: Select all

[-------========++++++++========----------]
0         (M)   K (L)     (N)            8S
 shrink  stable  growth  stable  shrink

Code: Select all

			var c = worldOld[i][j];
			var c0 = c;
			var n = worldOld[i-1][j-1] + worldOld[i-1][j] + worldOld[i-1][j+1] 
				+ worldOld[i][j-1] + worldOld[i][j+1] 
				+ worldOld[i+1][j-1] + worldOld[i+1][j] + worldOld[i+1][j+1];
			if (n<pK-pM || n>pK+pL+pN) c--; else if (n>=pK && n<=pK+pL) c++;
			c = Bound(c, 0, states);
			world[i][j] = c;

Code: Select all

rule_string = "rg3/l1/b3/s2,3/rb3,6/rs5,8"
birth = set([int(x) for x in rule_string.split("/")[2].replace("b", "").split(",")])
survival = set([int(x) for x in rule_string.split("/")[3].replace("s", "").split(",")])
regen_birth = set([int(x) for x in rule_string.split("/")[4].replace("rb", "").split(",")])
regen_survival = set([int(x) for x in rule_string.split("/")[5].replace("rs", "").split(",")])

birth_state = int(rule_string.split("/")[1].replace("l", ""))

# Information about the Rule (Must be filled)
n_states = int(rule_string.split("/")[0].replace("rg", ""))  # Number of States
alternating_period = 1  # For alternating rules / neighbourhoods
colour_palette = None  # Colours of the different states
rule_name = "RegenLife"  # 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, 1), (-1, 1), (-1, -1),
            (1, 0), (0, 1), (-1, 0), (0, -1)]


# Transition Function of Rule, Last Element of Neighbours is the Central Cell
def transition_func(neighbours, generation):
    n = 0
    for i in neighbours[:-1]:
        if i == 1: n += 1

    if neighbours[-1] == 0:
        if n in birth:
            return birth_state
        return 0
    elif neighbours[-1] == 1:
        if n in survival:
            return 1
        return 2
    else:
        if n in regen_birth:
            return neighbours[-1] - 1
        elif n in regen_survival:
            return neighbours[-1]
        return (neighbours[-1] + 1) % n_states


# 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