Wolfram Elementary 1-D Cellular Automaton

Math essence

cells_t+1[i] = R[(cells_t[i-1] << 2) | (cells_t[i] << 1) | cells_t[i+1]] where R[0..7] are the bits of the selected rule number 0..255. The ring buffer uses np.roll for periodic boundary conditions.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/reas_processing/wolframCA1D/reference.py

from __future__ import annotations

from typing import ClassVar

import numpy as np


def _rule_to_bits(rule: int) -> np.ndarray:
    rule &= 0xFF
    bits = np.zeros(8, dtype=np.uint8)
    for k in range(8):
        bits[k] = (rule >> (7 - k)) & 1
    return bits


class WolframCA1D:
    """Wolfram elementary 1-D cellular automaton.

    A one-dimensional binary line evolves under a 3-neighborhood rule
    (each new cell depends on its left neighbor, itself, and its right
    neighbor). The 8 possible 3-bit neighborhoods are mapped to 0 or 1
    by an 8-bit Wolfram rule (rules 0..255). Each step appends a new
    row to a square history canvas so the evolution unfurls downward,
    exactly as in the Processing example by Daniel Shiffman that is
    cited as a companion to Casey Reas's *Processings*.

    Reference: <https://processing.org/examples/wolfram.html>
    """

    family: ClassVar[str] = "reas_processing"
    sketch: ClassVar[str] = "wolframCA1D"

    def __init__(
        self,
        dim: int = 400,
        rule: int = 110,
        seed_alive: bool = True,
        seed_row: str = "middle",
        palette: str = "ink",
        bg_color: tuple[int, int, int] = (245, 240, 230),
        ink_color: tuple[int, int, int] = (20, 25, 40),
        seed: int | None = None,
    ) -> None:
        self.dim = dim
        self.rule = rule
        self.seed_alive = seed_alive
        self.seed_row = seed_row
        self.bg_color = np.array(bg_color, dtype=np.uint8)
        self.ink_color = np.array(ink_color, dtype=np.uint8)
        self._seed = seed
        self.reset()

    def reset(self, seed: int | None = None) -> None:
        if seed is not None:
            self._seed = seed
        self.rng = np.random.default_rng(self._seed)
        self.rules = _rule_to_bits(self.rule)
        self.cells = np.zeros(self.dim, dtype=np.uint8)
        if self.seed_alive:
            self.cells[self.dim // 2] = 1