# 7.11. Implementing CAs¶

To generate the figures in this chapter, we will use a Python class called Cell1D that represents a 1-D cellular automaton, and a class called Cell1DViewer that plots the results. Both are defined in Cell1D.py in the repository for this book.

To store the state of the CA, we will use a NumPy array with one column for each cell and one row for each time step.

To explain how this implementation works, we’ll start with a CA that computes the parity of the cells in each neighborhood. The “parity” of a number is 0 if the number is even and 1 if it is odd.

We use the NumPy function zeros to create an array of zeros, then put a 1 in the middle of the first row.

rows = 5
cols = 11
array = np.zeros((rows, cols), dtype=np.uint8)
array[0, 5] = 1
print(array)

[[ 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.  0.  0.  0.  0.  0.  0.  0.]
[ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]
[ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]]


The data type uint8 indicates that the elements of array are unsigned 8-bit integers.

plot_ca displays the elements of an array graphically:

import matplotlib.pyplot as plt

def plot_ca(array, rows, cols):
cmap = plt.get_cmap('Blues')
plt.imshow(array, cmap=cmap, interpolation='none')


We import pyplot with the abbreviated name plt, which is conventional. The function get_cmap returns a colormap, which maps from the values in the array to colors. The colormap 'Blues' draws the “on” cells in dark blue and the “off” cells in light blue.

imshow displays the array as an “image”; that is, it draws a colored square for each element of the array. Setting interpolation to none indicates that imshow should not interpolate between on and off cells.

To compute the state of the CA during time step i, we have to add up consecutive elements of array and compute the parity of the sum. We can do that using a slice operator to select the elements and the modulus operator to compute parity:

def step(array, i):
rows, cols = array.shape
row = array[i-1]
for j in range(1, cols):
elts = row[j-1:j+2]
array[i, j] = sum(elts) % 2


rows and cols are the dimensions of the array. row is the previous row of the array.

Each time through the loop, we select three elements from row, add them up, compute the parity, and store the result in row i.

In this example, the lattice is finite, so the first and last cells have only one neighbor. To handle this special case, we don’t update the first and last column; they are always 0.