Mandelbrot Set (Escape-Time Fractal)

Math essence

Vectorised numpy: for each pixel, c = re + i*im; iterate z_re = z_re^2 - z_im^2 + c_re; z_im = 2*z_re*z_im + c_im until |z|^2 > escape_radius or max_iter. Iteration count drives palette t; escaped pixels get t = (iter + 1 - log(log|z^2|)/log 2) / max_iter, a continuous value used by the chosen palette (viridis, magma, ocean, rainbow). step(n) advances tick -> camera orbit + zoom -> re-render.

Parameters

Reference

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

from __future__ import annotations

from typing import ClassVar

import numpy as np


class MandelbrotSet:
    """Mandelbrot set — escape-time fractal on the complex plane.

    For each pixel mapped to a complex number ``c = x + yi`` in a window of
    the complex plane, iterate ``z = z² + c`` starting from ``z = 0`` until
    either ``|z|² > escape_radius`` or ``max_iter`` iterations are reached.
    Pixels that never escape (the Mandelbrot set itself) are rendered as
    the ``in_set_color``; pixels that escape are shaded by the number of
    iterations (smoothed with the standard log-correction for a continuous
    gradient).

    Step(n) advances the centre and zoom along a slow Mandelbrot-zoom
    trajectory (frame n is centred at ``c0 * exp(i * 2π * orbit_angle * n / orbit_period)``),
    producing the textbook deep-zoom animation. The default ``c0 = -0.7885``
    is the famous 'seahorse valley' deep-zoom locus.
    """

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

    def __init__(
        self,
        dim: int = 480,
        max_iter: int = 220,
        escape_radius: float = 2.0,
        center_re: float = -0.75,
        center_im: float = 0.0,
        zoom_start: float = 1.3,
        zoom_end: float = 1.3,
        orbit_radius: float = 0.0,
        orbit_period: int = 240,
        orbit_phase: float = 0.0,
        palette_mode: str = "viridis",
        in_set_color: tuple[int, int, int] = (8, 6, 18),
        seed: int | None = None,
    ) -> None:
        self.dim = dim
        self.max_iter = max_iter
        self.escape_radius = escape_radius
        self.center_re = center_re
        self.center_im = center_im
        self.zoom_start = zoom_start
        self.zoom_end = zoom_end
        self.orbit_radius = orbit_radius
        self.orbit_period = orbit_period
        self.orbit_phase = orbit_phase
        self.palette_mode = palette_mode
        self.in_set_color = np.array(in_set_color, dtype=np.float32)
        self._seed = seed
        self.reset()

    def reset(self, seed: int | None = None) -> None:
        if seed is not None: