Mulberry32 PRNG (stratified scatter)

Math essence

State update: a += 0x6D2B79F5 (mod 2^32); t = imul(a^(a>>15), 1|a); t = t + imul(t^(t>>7), 61|t) ^ t; output = (t ^ (t>>14)) / 2^32. Each step advances the seed by seed_walk Mulberry32 iterations and uses the next 3*N draws to jitter, hue and place N stratified points on a cols x rows grid.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/hodgin_iquilezles/Mulberry32RNG/reference.py

from __future__ import annotations

from typing import ClassVar

import numpy as np


class Mulberry32RNG:
    """Mulberry32 — Inigo Quilez / Tommy Ettinger (32-bit PRNG foundation).

    Mulberry32 is a tiny, fast, 32-bit-state pseudo-random number generator
    popularised by Tommy Ettinger in the demoscene and graphics communities
    and used pervasively by Quilez and others as the RNG inside shadertoy
    and procedural sketches:

        uint32_t mulberry32(uint32_t a) {
            a |= 0; a = a + 0x6D2B79F5 | 0;
            uint32_t t = Math.imul(a ^ a >>> 15, 1 | a);
            t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
            return ((t ^ t >>> 14) >>> 0) / 4294967296;
        }

    Here we use the state machine to drive a layered "stratified" 2D
    scatter pattern (a classic Quilez visual idiom: pick a base lattice
    with N "bins", then perturb every point by a small mulberry32 noise
    vector).  Each ``step`` advances the seed and re-rolls the points,
    producing a deterministic noise pattern that changes by tiny, smooth
    amounts as the seed is mixed through Mulberry32's Weyl sequence.
    """

    family: ClassVar[str] = "hodgin_iquilezles"
    sketch: ClassVar[str] = "mulberry32rng"

    def __init__(
        self,
        dim: int = 400,
        cols: int = 24,
        rows: int = 24,
        jitter: float = 0.45,
        point_size: int = 4,
        seed_walk: int = 1,
        palette: str = "iq",
        **_,
    ) -> None:
        self.dim = dim
        self.cols = int(cols)
        self.rows = int(rows)
        self.jitter = float(jitter)
        self.point_size = int(point_size)
        self.seed_walk = int(seed_walk)
        self.palette = palette
        self.reset()

    @staticmethod
    def _u32(x: int) -> int:
        return x & 0xFFFFFFFF

    def _next_state(self, state: int) -> tuple[int, float]:
        a = self._u32(state + 0x6D2B79F5)
        t = np.uint32(a)