Random i64 in [lo, hi).

Subtract `base` from both schedule-counter buffers (keeps the f32 epoch coordinate precise over indefinitely long runs).

Replace the embedding and reset the schedule, epoch, and velocity — i.e. a full restart of the layout optimization from a new initial position.

Return the report HTML path for a benchmark suite.

(Re)seed the per-edge negative-sample counters for the current rate so the next negative sample for each edge falls ~`epn` epochs after `from_epoch`.

Reset the per-edge schedule counters (eons = eps, eonns = eps/rate) and clear the gradient accumulator.

* Turn a user-specified state (from the API) into an internal state. * An InternalState is just a EmbeddingAtlasState with all fields non-optional *

Return the results CSV path for a benchmark suite.

Compute row sums (degree vector).

Run all UMAP benchmarks.

Run a benchmark command that writes a JSON result file. Returns the parsed result dict with 'threads' added, or None on failure.

Run one CPU epoch in place at the current parameters.

Run one epoch on the GPU at the given (already-decayed) parameters. SGD splits the epoch into `n_sub` accumulate→apply rounds so later sub-batches se

Return path to a compiled Rust benchmark binary.

Switch optimizer. Resets the velocity buffer. Queued; runs in order after any in-flight `step`/`run`.

* Update live parameters. `learningRate` is used flat by `step` and as the * decay peak by `run`. `minDist`/`spread` re-fit the output curve. Safe

Push a value into a max-heap without checking for duplicates. Returns 1 if the value was inserted, 0 if rejected (distance too large).

Compute spectral embedding of the graph using the normalized Laplacian. Uses LOBPCG (Locally Optimal Block Preconditioned Conjugate Gradient) to find

Report sub-progress within the current stage. `progress` is 0.0 to 1.0 within this stage. `status` optionally overrides the stage name in the callbac

* Vite plugin that converts TypeScript interfaces to JSON schemas * @param {Object} options - Plugin options * @param {string} [options.tsconfig='ts

Enable verbose output. Default: false.

* Wrap a built wasm `Umap` instance in the stable JS UMAP interface. A * {@link createSequencer} mediates all wasm access so callers can safely step

Zero the velocity buffer (on optimizer switch / reinit).

Return display implementation name (rust, rust-gpu, python).

Build the HTML section with canvas elements for embedding visualization.

Gzip compress and base64 encode bytes.

Optimal rotation + translation (Kabsch). Returns (transformed, error).

Load, align, and normalize UMAP embeddings for all (n_points, metric, threads) groups. Returns list of dicts with gzipped+base64-encoded embeddin

Generate a random RGB image as PNG bytes.

Generate a random mono WAV file as bytes.

Prepare rows for Vega-Lite: add impl_display, cast numeric fields.

Read CSV file and return list of dicts.

Build an HTML table from result rows.

Run an embedder function over *data* in batches, return concatenated result.

Build a Vega-Lite spec for timing charts faceted by metric x threads (and dim for nndescent).

Element-wise addition: self += other.

Aggregate words by their stems and track the most frequent version. * Returns a map with stemmed words as keys, and the most frequent version and tot

Align emb to ref_emb using rotation + translation, allowing a flip. Tries the embedding as-is and with x-axis flipped, picks whichever gives

Angular hub-based split: uses top-3 highest-degree points to generate normalized hyperplanes between all pairs, picks the most balanced split.

Angular random projection split: picks 2 random points, computes normalized difference as hyperplane, splits by sign of projection.

Apply L*v = v - D^{-1/2} * A * (D^{-1/2} * v) to each column of a Block. All computation is done in f64 to avoid precision loss in the eigensolver.

Assemble a symmetric block Gram matrix from sub-blocks. blocks is a list of (row_block, col_block, sub_matrix) triples. Each sub_matrix is (rows × col

Async version of ``compute_projection``. Use this when calling from within a running async event loop (e.g. Jupyter notebooks)::

Search for k nearest neighbors of multiple query points (parallel).

Return environment dict for benchmark subprocesses.

Helper to create a storage buffer bind group layout entry.

Compute brute-force k-nearest neighbors for accuracy comparison.