Lorenz Attractor (3D ODE) — strange-attractor trajectory with depth shading

Math essence

Initial condition (x0, y0, z0) ~ (1, 1, 25). RK4 integration of the three ODEs over trajectory_length steps with fixed dt. Orthographic project (rotate by 'rotation' about y, drop z'). z_norm = (z - z_bias*22)/24 normalised into [0, 1]; per-step hue = index/N mapped through a + b*cos(2pi*(c*(h + palette_offset) + d)); pixels splatted with line_glow halo; depth = sigmoid(2.5*z_norm).

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/shader_legends_2/LorenzAttractor3D/reference.py

from __future__ import annotations

from typing import ClassVar

import numpy as np


def _rk4_lorenz(
    x0: float, y0: float, z0: float,
    sigma: float, rho: float, beta: float,
    dt: float, steps: int,
) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
    """RK4 integration of the Lorenz system

        x' = sigma (y - x)
        y' = x (rho - z) - y
        z' = x y - beta z

    Returns arrays (X, Y, Z) of the trajectory.  Steps use fixed
    dt and no early termination; callers can downsample the
    trajectory for rendering.
    """
    X = np.empty(steps, dtype=np.float32)
    Y = np.empty(steps, dtype=np.float32)
    Z = np.empty(steps, dtype=np.float32)
    X[0] = x0
    Y[0] = y0
    Z[0] = z0
    x, y, z = x0, y0, z0

    def f(x: float, y: float, z: float) -> tuple[float, float, float]:
        return (
            sigma * (y - x),
            x * (rho - z) - y,
            x * y - beta * z,
        )

    for k in range(1, steps):
        k1x, k1y, k1z = f(x, y, z)
        k2x, k2y, k2z = f(x + 0.5 * dt * k1x, y + 0.5 * dt * k1y, z + 0.5 * dt * k1z)
        k3x, k3y, k3z = f(x + 0.5 * dt * k2x, y + 0.5 * dt * k2y, z + 0.5 * dt * k2z)
        k4x, k4y, k4z = f(x + dt * k3x, y + dt * k3y, z + dt * k3z)
        x = x + (dt / 6.0) * (k1x + 2.0 * k2x + 2.0 * k3x + k4x)
        y = y + (dt / 6.0) * (k1y + 2.0 * k2y + 2.0 * k3y + k4y)
        z = z + (dt / 6.0) * (k1z + 2.0 * k2z + 2.0 * k3z + k4z)
        X[k] = x
        Y[k] = y
        Z[k] = z
    return X, Y, Z


class LorenzAttractor3D:
    """Lorenz attractor, 2D-projected with depth shading.

    The Lorenz system (1963, E. N. Lorenz) is a 3D ODE that emerges
    in atmospheric convection.  It is the canonical "strange
    attractor" — a deterministic, bounded, non-periodic trajectory
    shaped like a butterfly that chaos theory has used as an icon
    for six decades.