* Create the id-based mapper table `(__main_id, __aux_id)` for an auxiliary table, * derived from its relation. No-op if the table declares no rela

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

* A d3 interpolator from fully transparent to a medium orange, ramping only the * alpha channel (the rgb stays constant, so the hue never shifts). Us

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).

* Compose the chunk → dispatch → concat pipeline. Calls that fit in one chunk * skip the pool overhead and run inline. * * `getConcurrency()` is co

Return environment dict for benchmark subprocesses.

Background color for bucket `k` of `levels`. The interpolator ramps alpha, * so the text underneath keeps its own color — we never set a foreground.

Helper to create a storage buffer bind group layout entry.

* Subscribe to the two signature derivations that drive all data loading. * * - reloadSources only depends on `{features}`. It does NOT include

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

* Combined aggregation query. * * The query is built around an exploded CTE — one row per * (data row, feature occurrence) — that the count and cla

Build the NNDescent index (async version). Use this on WASM with GPU where `pollster::block_on` cannot block. On native, prefer [`build`] which wraps

Call a registered function on the worker.

Check if the given rect is occupied, return true if any bit is true

Check if visited and mark as visited in one operation. Returns true if ALREADY visited (before marking).

Push a value into a max-heap, checking for duplicates first. Returns 1 if inserted, 0 if rejected or duplicate.

Returns the alpha value of a circle's pixel at (px, py). * The circle is centered at the center of pixel (0, 0) with the given radius. * The alpha v

UMAP / NNDescent benchmark suite.

Collect the edges that are due to be sampled at `current_epoch`, advancing the per-edge sampling schedule counters in place. Returns `(edge_index, n_

Compute distribution stats for all fields used in a chart.

Compute distances without threshold filtering — all distances are returned. Used for `init_rp_tree` where the heap is initially empty.