Skip to content

v0.4.2

Latest

Choose a tag to compare

@github-actions github-actions released this 14 Nov 21:22
· 3 commits to main since this release
0a7f4cd

0.4.2 — 2026-11-14

Added

  • The paper page computes the devil's staircase live: the rotation number
    rho(A) is drawn in the browser at a drive frequency D the reader sets with a
    slider or number field (default 0.25). The values go into the page address,
    so a link reproduces the view. At D = 0.25 the live curve matches the
    published data within 1/256 below K_c = 1/(2 pi)
    (scripts/check_wasm_staircase.py, run in CI). The Lyapunov panel stays a
    static image.

  • The paper page computes the delayed-logistic attractor live: the (x, y)
    point cloud at a map parameter D the reader sets with a slider or number
    field (default 1.90, the kernel's [1.4, 3.5] clamp as the range), plus an
    iteration-count control bounded at 4096 plotted states. The values go
    into the page address, so a link reproduces the view. The map uses only
    +, -, *, so the browser orbit matches the published trajectories bit for
    bit (scripts/check_wasm_delayed_logistic.py, run in CI). The published
    twelve-panel figure stays below the live cloud.

  • The paper page computes the torus-doubling attractors live: the (X, Y)
    projection of map (I) or map (IV) at a map parameter D the reader sets
    with a slider or number field, plus an iteration-count control bounded
    at 4096 plotted states. A map selector switches between map (I)
    (A = 0.4, D in [1.9, 2.25]) and map (IV) (A = 0.3, D in [1.48, 1.53]),
    each window the published doubling sweep. The values go into the page
    address, so a link reproduces the view. The maps use only +, -, *, so
    the browser orbit matches the published trajectories bit for bit
    (scripts/check_wasm_torus_doubling.py, run in CI). The published
    three-panel figure stays below the live cloud.

  • The paper page computes the double devil's staircase live: the rotation
    numbers rho_theta and rho_phi of the modulated circle map are drawn in
    the browser over a bare-frequency window the reader sets with min/max
    fields, two preset buttons that reproduce the zoom panels' D windows, or
    a drag zoom, plus a forcing-strength slider (eps in [0, 0.2], default
    0.05) and a point-count control bounded at 512. The values go into the
    page address, so a link reproduces the view. A = 0.1 is subcritical, so
    the browser curve matches the published sweep to 1e-6 in rho_theta and
    1e-12 in rho_phi (scripts/check_wasm_modulated_circle.py, run in CI).
    The published figure stays below the live curves.

  • The paper page computes the CML space-time diagrams live: the field
    x_i^n of the chosen coupled-map lattice is drawn in the browser as one
    heat map (site i across, time n up, magma at the shown field's 1st/99th
    percentiles). A model selector switches between models A, B and C, an
    eps slider moves the coupling inside the chosen model's published
    window (A [0, 0.2] default 0.07; B [0, 0.1] default 0.024; C [0, 0.5]
    default 0.2), a site-count control sets N in [16, 512] (default 200),
    and a play button appends 250-row chunks computed from the window's
    last row while the oldest rows drop off. The values go into the page
    address, so a link reproduces the view. The published nine-panel figure
    stays below the live field.

  • The compiled extension exports delayed_logistic_attractor_tile and
    torus_doubling_attractor_tile. They iterate the delayed logistic map and
    the torus-doubling maps (I) and (IV) in Rust and return the same
    trajectories as the Python modules, bit for bit. The WebAssembly build
    exports both for the browser, with every input clamped. The paper pipeline
    still uses the Python path.

  • The compiled extension exports modulated_circle_rotation_tile and
    cml_spacetime_tile. They compute the modulated circle map's rotation
    numbers and the coupled-map-lattice space-time field (models A, B and C)
    in Rust and return the same results as the Python modules, bit for bit
    where numpy and Rust call the same sin (Linux x86-64, checked).
    The WebAssembly build exports both for the browser, with every input
    clamped. The paper pipeline still uses the Python path.

  • The compiled extension exports circle_map_lyapunov_sum,
    delayed_logistic_lyapunov_tile, torus_doubling_lyapunov_tile and
    coupled_delayed_lyapunov_tile. They compute the circle-map Lyapunov
    exponent and the delayed-logistic, torus-doubling (maps I and IV) and
    coupled-delayed spectra in Rust, agreeing with the Python reference to
    1e-9 absolute per exponent (the orbit is bit-identical; the Householder
    QR differs from np.linalg.qr only in the last bits). The WebAssembly
    build exports all four for the browser, with every input clamped. The
    paper pipeline still uses the Python path.

  • The compiled extension exports coupled_logistic_phase_tile,
    coupled_logistic_attractor_tile and coupled_delayed_projection_tile.
    They compute the coupled-logistic phase diagram, attractor portraits and
    coupled-delayed (x, z) projections in Rust. The WebAssembly build
    exports those three plus coupled_logistic_basin_grid and
    fractalization_attractor_tile (the latter calls the existing delayed
    logistic kernel), with every input clamped. They are exported; no page
    calls them yet. The paper pipeline still uses the Python path.

  • In debug mode (?debug=1, #live-debug in the page address, or
    localStorage.dynachaosDebug), each live figure shows one line of numbers
    under it with a copy button: the figure id, the browser name and version,
    the worker count, the milliseconds from the interact press to the first full
    paint, the median tile time, and the number of main-thread tasks over 50 ms.
    A phone has no console, so a report from one can now carry these numbers.
    The task count reads n/a where the browser has no long-task timing
    (Safari). With debug mode off the page adds no box and no observer.

Changed

  • Long-running WebAssembly kernel calls on the double-staircase and space-time live figures now run
    in a dedicated Web Worker instead of blocking the browser's main thread. Modulated circle rotation
    and coupled-map lattice spacetime evaluations execute asynchronously with results transferred back
    without detaching critical headers, and late-arriving results from superseded parameter states are
    dropped before painting. At a four-fold CPU throttle matching phone-class hardware, main-thread tasks
    during parameter slider moves and playback stay under 100 milliseconds, eliminating page freezes while
    preserving bit-identical numerical output.

  • The live space-time figure does less work on the main thread after each kernel reply. It reads
    its colour limits (the 1st and 99th percentiles) by selecting four values instead of sorting the
    whole 100000-value window, and it colours the cells without allocating an array per cell and
    without Math.round. The colour limits and the pixels are identical to before. Non-finite values
    are skipped in the limits, as the code comment already said; an input of minus infinity used to
    make the lower limit NaN. The work per reply in a micro-benchmark falls by about 80 percent, and
    the longest main-thread task during a slider move at a four-fold CPU throttle falls by more than
    half (at an eight-fold throttle, from 171 to 185 ms down to 68 to 71 ms).

  • The live Arnold-tongue figure displays fraction labels above the plot along a top axis matching
    the published figure, tracking the visible frequency window during drag zooms in the standard
    axis tick typography. The live space-time diagram uses the published panels' aspect ratio and
    fits inside the window.

  • Live canvas tick numbers use the same serif typeface as the axis labels, and padding reserves
    room measured against the drawn face. Rotated vertical axis labels no longer intersect tick
    numbers, and horizontal tick numbers remain inside the canvas width at both desktop and mobile
    sizes. Critical-line marks and their text labels follow the site's vermilion accent in light
    and dark schemes. Arnold-tongue tick numbers show no more decimal places than the published
    figure without creating ambiguous tick labels, and the double devil's staircase note clarifies
    that presets jump to the zoom panels' windows and the full frequency range.

  • Live figures use the quantities and symbols from the paper captions across visible labels, plot
    titles, and readouts, naming the devil's staircase sweep by nonlinearity K at drive frequency Ω.
    Parameter sliders display readable names instead of internal keys, the double-staircase note
    reflects the full set of three presets, and canvas marks and colour-bar labels render real
    subscripts and superscripts.

  • The paper page links to the figure gallery from its top, the gallery links back, and gallery images use the caption as alt text.

  • On a 390 px phone the reading controls wrap inside the screen, a figure opened from a link or a
    jump lands below the fixed bar, 'reset view' stays clear of the plot title, and the page no longer
    scrolls sideways; citations wrap at phone widths and stay on one line on wider screens. On 360 px
    phones, long links wrap, wide equations scroll inside their own box, and the help and
    return-to-default buttons have 44 px tap targets.

  • Figures opened from a shared link show a note reporting the applied values with a button to return
    to defaults, figures that compute in the browser carry a live tag beside the interact button, and the
    interaction hint under each live figure is shortened to one line with the full list behind a help toggle.

  • zero_one_statistic and zero_one_series run on the Rust core when the
    compiled extension is available. The results agree with the Python path to
    within 1e-9 for each random frequency. The Python path is still there, and
    DYNACHAOS_NO_RUST=1 still selects it. The Rust kernel computes the
    autocovariance by FFT, so its cost grows as N log N: at the default
    n_cut = N/10 and 100 frequencies it takes 0.34 s for N = 100000, where
    the Python path takes 15 s.

Fixed

  • The WebAssembly build no longer embeds the build machine's source paths.
    rustc had written the absolute path of rust/core into the module, so a
    module built in a home folder carried that folder name to every reader.
    scripts/build_wasm.py now remaps the home folder, the cargo and rustup
    folders and the repository root, and both build scripts fail if the built
    files still hold /home/, /Users/ or C:\Users
    (scripts/check_wasm_paths.py, also a CI step).