# 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.