Random Walk / Drunkard's Walk

Math essence

Each walker: pos += step, where step is one of the 4/8 direction vectors scaled by step_len (cardinal/diagonal); or Pareto-tailed (Lévy) at probability levy_p; or vel = vel*decay + N(0, jitter) clipped to step_len (momentum). Periodic boundaries via pos %= dim (torus=True) or velocity reflection at the edges (torus=False). Canvas trail: canvas[p] = (1 - alpha) * canvas[p] + alpha * ink.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/shiffman_pearson_textbook/randomWalkDrunkard/reference.py

from __future__ import annotations

from typing import ClassVar

import numpy as np


class RandomWalkDrunkard:
    """Random-walk / drunkard's-walk — Nature of Code Ch. 1 / Generative Art Ch. 3.

    Many walkers each start at the canvas center and take a stochastic 2-D
    step every tick. Four walk variants are supported:

    - ``'cardinal'``: step to one of 4 axial neighbours (N, E, S, W).
    - ``'diagonal'``: step to one of 8 neighbours (axial + diagonals).
    - ``'levy'``: with probability ``levy_p`` step a long distance L (random
      angle, length drawn from a power-law tail), otherwise take a normal
      unit step (Lévy flights — Pearson *Generative Art* Ch. 3).
    - ``'momentum'``: walker has a velocity vector; on each tick the step is
      ``v += jitter``, and ``v`` decays geometrically (drunk with inertia —
      Shiffman *Nature of Code* Ch. 6 'A Smoother Perlin Walk' variant).

    Walkers are kept alive when they leave the canvas (``torus=True``) or
    bounce off the edges (``torus=False``). Each walker leaves a low-alpha
    trail on the canvas; intensity is incremented each visit so repeatedly
    visited pixels burn in.
    """

    family: ClassVar[str] = "shiffman_pearson_textbook"
    sketch: ClassVar[str] = "randomWalkDrunkard"

    def __init__(
        self,
        dim: int = 400,
        num_walkers: int = 400,
        step_len: float = 1.0,
        variant: str = "diagonal",
        levy_p: float = 0.02,
        levy_alpha: float = 1.5,
        momentum_decay: float = 0.92,
        momentum_jitter: float = 1.4,
        torus: bool = True,
        trail_alpha: float = 0.18,
        bg_color: tuple[int, int, int] = (15, 18, 30),
        ink_color: tuple[int, int, int] = (240, 220, 200),
        seed: int | None = None,
    ) -> None:
        self.dim = dim
        self.num_walkers = num_walkers
        self.step_len = step_len
        self.variant = variant
        self.levy_p = levy_p
        self.levy_alpha = levy_alpha
        self.momentum_decay = momentum_decay
        self.momentum_jitter = momentum_jitter
        self.torus = torus
        self.trail_alpha = trail_alpha
        self.bg_color = np.array(bg_color, dtype=np.float32)
        self.ink_color = np.array(ink_color, dtype=np.float32)
        self._seed = seed