NumPy on Programmer.ie: Modern AI programming

Cellular Automata From First Principles 50: Vectorize the Update Loop

Mon, 10 Aug 2026 20:53:00 +0100

Cellular Automata From First Principles 50: Vectorize the Update Loop

A cellular automaton is local.

That does not mean we should update it cell by cell in Python.

For dense grids, the same local rule is applied everywhere. That regularity is exactly what array programming is good at.

Start with the obvious implementation

def life_step_slow(grid):
    height, width = grid.shape
    next_grid = np.zeros_like(grid)

    for y in range(height):
        for x in range(width):
            total = 0
            for dy in (-1, 0, 1):
                for dx in (-1, 0, 1):
                    if dx == 0 and dy == 0:
                        continue
                    total += grid[(y + dy) % height, (x + dx) % width]

            alive = grid[y, x] == 1
            next_grid[y, x] = (
                total == 3 or (alive and total == 2)
            )

    return next_grid

This is useful because it states the mechanism clearly.

Cellular Automata From First Principles 11: Diffusion as Local Exchange

Mon, 10 Aug 2026 18:40:00 +0100

Cellular Automata From First Principles 11: Diffusion as Local Exchange

Until now most cells have stored discrete state:

0 / 1
empty / tree / fire
road / car

Now let each cell store a continuous quantity.

For diffusion:

state[y, x] = concentration

The local transition is no longer birth, death or movement.

It is local exchange.

Start with a pulse

import numpy as np

size = 121

grid = np.zeros(
    (size, size),
    dtype=np.float64,
)

grid[
    size // 2,
    size // 2,
] = 1.0

At the beginning one cell contains all the concentration.

Cellular Automata From First Principles 09: Build a Forest Fire Simulation

Mon, 10 Aug 2026 18:36:00 +0100

Cellular Automata From First Principles 09: Build a Forest Fire Simulation

A forest fire is almost an ideal cellular-automaton exercise.

The visible states are obvious:

0 = empty
1 = tree
2 = burning

The interactions are local.

And small changes in fuel density or ignition assumptions can produce very different global outcomes.

This is not intended as a high-fidelity wildfire model.

It is a deliberately simplified spread model designed to isolate one mechanism:

Cellular Automata From First Principles 08: Add Randomness Without Losing the Model

Mon, 10 Aug 2026 18:34:00 +0100

Cellular Automata From First Principles 08: Add Randomness Without Losing the Model

So far every transition in the book has been deterministic.

Given the same state, the next state is fixed.

That makes deterministic automata unusually easy to debug: if we preserve the initial condition and rule, we preserve the trajectory.

But many useful models need another ingredient.

A tree may ignite.

An organism may reproduce.

A driver may hesitate.

Cellular Automata From First Principles 05: Conway's Game of Life

Mon, 10 Aug 2026 18:25:00 +0100

Cellular Automata From First Principles 05: Conway’s Game of Life

Conway’s Game of Life is one of the cleanest examples of complex two-dimensional behavior emerging from a tiny local rule.

The world is a grid of dead and live cells.

Each cell sees its eight surrounding neighbors.

Then four ideas decide the next generation:

underpopulation
survival
overpopulation
birth

The standard rule is usually written B3/S23:

a dead cell is born with exactly 3 live neighbors,
a live cell survives with 2 or 3 live neighbors.

Everything else becomes or remains dead.

Cellular Automata From First Principles 01: Build Your First Automaton

Mon, 10 Aug 2026 18:21:00 +0100

Cellular Automata From First Principles 01: Build Your First Automaton

In the previous chapter we reduced a cellular automaton to four things:

space
state
neighborhood
rule

Now we are going to build one.

Not a framework.

Not a library.

One update step.

That is enough to expose the whole mechanism.

Start with a one-dimensional world

Create a row of cells and turn on the centre cell:

import numpy as np

width = 41
state = np.zeros(width, dtype=np.uint8)
state[width // 2] = 1

print(state)

Conceptually: