Генерация строк правила 30 клеточных автоматов

Question

Правило 30 - это одномерный клеточный автомат, в котором текущее поколение учитывает только клетки предыдущего поколения. Существует два состояния, в которых может находиться ячейка: 1 или 0. Правила создания следующего поколения представлены в строке ниже и зависят от ячейки, находящейся непосредственно над текущей ячейкой, а также от ее непосредственных соседей.

Сотовый автомат применяется по следующему правилу (используя побитовое отображение операторы):

left_cell ^ (central_cell | right_cell)

Это правило формирует таблицу ниже:

Теперь я попытался внедрить эти правила в Python, используя numpy. Я определил начальное состояние, которое принимает width в качестве параметра и создает начальную строку нулей с 1 в середине.

def initial_state(width):
    initial = np.zeros((1, width), dtype=int)
    if width % 2 == 0:
        initial = np.insert(initial, int(width / 2), values=0, axis=1)
        initial[0, int(width / 2)] = 1
        return initial
    else:
        initial[0, int(width / 2)] = 1
        return initial

Функция ниже просто производит второе поколение с учетом начальной строки. Как создать для l oop, который продолжает генерировать новые поколения, пока первый элемент последней нижней строки не станет 1?

def rule30(array):
    row1 = np.pad(array,[(0,0), (1,1)], mode='constant')
    next_row = array.copy()
    for x in range(1, array.shape[0]+1):
        for y in range(1, array.shape[1]+1):
            if row1[x-1][y-1] == 1 ^ (row1[x-1][y] == 1 or row1[x-1][y+1] == 1):
                next_row[x - 1, y - 1] = 1
            else:
                next_row[x - 1, y - 1] = 0
        return np.concatenate((array, next_row))

Например, если введено значение

A = [0, 0, 0, 1, 0, 0, 0]

Вывод должен быть

>>> print(rule30(A))
[[0, 0, 0, 1, 0, 0, 0],
 [0, 0, 1, 1, 1, 0, 0],
 [0, 1, 1, 0, 0, 1, 0],
 [1, 1, 0, 1, 1, 1, 1]]

Answer 1

Вот код, основанный на строковых представлениях и поиске. Он использует некоторые идеи из комментариев выше. Кроме того, я добавил отступы для обработки краевых ячеек - условия были неясны по этому поводу. Также обратите внимание, что предлагаемая таблица шаблонов не симметрична c. Сравните новые состояния для '110' и '011'.

def rule30(a):
    patterns = {'111': '0', '110': '0', '101': '0', '100': '1',
                '011': '1', '010': '1', '001': '1', '000': '0', }
    a = '0' + a + '0'  # padding
    return ''.join([patterns[a[i:i+3]] for i in range(len(a)-2)])

a = '0001000'
result = [list(map (int, a))]

while a[0] != '1':
    a = rule30(a)
    result.append (list(map (int, a)))
print (result)  # list of lists 
print (np.array(result))  # np.array

список списков:

[[0, 0, 0, 1, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 0, 0, 1, 0], [1, 1, 0, 1, 1, 1, 1]]

np.array:

array([[0, 0, 0, 1, 0, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 1, 1, 0, 0, 1, 0],
       [1, 1, 0, 1, 1, 1, 1]])

Answer 2

Метод 1 - Numpy

Этого можно добиться, используя следующую небольшую модификацию вашего текущего кода - изменив возвращаемое значение от rule30 до return np.array(next_row). Тогда вы можете использовать следующую функцию:

def apply_rule(n):
    rv = initial_state(n)
    while rv[-1][0] == 0:
        rv = np.append(rv, rule30(rv[-1].reshape(1,-1)), axis=0)
    return rv

Использование:

>>> apply_rule(7)
array([[0, 0, 0, 1, 0, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 1, 1, 0, 0, 1, 0],
       [1, 1, 0, 1, 1, 1, 1]])

Или построено:

>>> plt.imshow(apply_rule(7), cmap='hot')

Метод 2 - Списки

В качестве альтернативы, вы можете использовать следующее решение без использования numpy, в котором используется несколько функций для применения логики правила 30 c ко всем каждая тройка в каждом дополненном списке, пока не будет выполнено условие остановки.

Код:

def rule(t):
    return t[0] ^ (t[1] or t[2])

def initial_state(width):
    initial = [0]*width
    if width%2:
        initial[width // 2] = 1
    else:
        initial.insert(width//2, 1)
    return initial

def get_triples(l):
    return zip(l,l[1:],l[2:])       

def rule30(l):
    return [rule(t) for t in get_triples([0] + l + [0])]

def apply_rule(width):
    rv = [initial_state(width)]
    while not rv[-1][0]:
        rv.append(rule30(rv[-1]))
    return rv

Использование:

>>> apply_rule(7)
[[0, 0, 0, 1, 0, 0, 0],
 [0, 0, 1, 1, 1, 0, 0],
 [0, 1, 1, 1, 0, 1, 0],
 [1, 1, 1, 0, 0, 1, 1]]
>>> [''.join(str(y) for y in x) for x in apply_rule(7)]
['0001000',
 '0011100',
 '0111010',
 '1110011']

Визуализация Matplotlib (с использованием любого метода):

import matplotlib.pyplot as plt
plt.figure(figsize=(10,6))
plt.imshow(apply_rule(250), cmap='hot')