umap-web 0.2.0

package/dist/init-DLiEtGpx.js

@@ -0,0 +1,802 @@
+//#region src/types.ts
+const silentLogger = {
+	info() {},
+	warn() {}
+};
+const consoleLogger = {
+	info(msg) {
+		console.log(`[umap-web] ${msg}`);
+	},
+	warn(msg) {
+		console.warn(`[umap-web] ${msg}`);
+	}
+};
+var UmapError = class extends Error {
+	name = "UmapError";
+};
+var UmapValidationError = class extends UmapError {
+	name = "UmapValidationError";
+};
+var UmapBackendError = class extends UmapError {
+	name = "UmapBackendError";
+};
+/** Surfaced through the logger on convergence problems (spectral fallback etc.). */
+var UmapConvergenceWarning = class extends UmapError {
+	name = "UmapConvergenceWarning";
+};
+function abortError() {
+	return new DOMException("The operation was aborted.", "AbortError");
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw signal.reason ?? abortError();
+}
+
+//#endregion
+//#region src/linalg.ts
+/** Cyclic Jacobi for a symmetric n×n matrix (row-major input, not modified). */
+function symmetricEigen(A, n, maxSweeps = 100) {
+	const a = A.slice();
+	const v = new Float64Array(n * n);
+	for (let i = 0; i < n; i++) v[i * n + i] = 1;
+	for (let sweep = 0; sweep < maxSweeps; sweep++) {
+		let off = 0;
+		for (let p = 0; p < n - 1; p++) for (let q = p + 1; q < n; q++) off += a[p * n + q] * a[p * n + q];
+		if (off < 1e-30) break;
+		for (let p = 0; p < n - 1; p++) for (let q = p + 1; q < n; q++) {
+			const apq = a[p * n + q];
+			if (Math.abs(apq) < 1e-300) continue;
+			const app = a[p * n + p];
+			const tau = (a[q * n + q] - app) / (2 * apq);
+			const t = Math.sign(tau) / (Math.abs(tau) + Math.sqrt(1 + tau * tau)) || 1 / (tau + Math.sqrt(1 + tau * tau));
+			const c = 1 / Math.sqrt(1 + t * t);
+			const s = t * c;
+			for (let i = 0; i < n; i++) {
+				const aip = a[i * n + p];
+				const aiq = a[i * n + q];
+				a[i * n + p] = c * aip - s * aiq;
+				a[i * n + q] = s * aip + c * aiq;
+			}
+			for (let i = 0; i < n; i++) {
+				const api = a[p * n + i];
+				const aqi = a[q * n + i];
+				a[p * n + i] = c * api - s * aqi;
+				a[q * n + i] = s * api + c * aqi;
+			}
+			for (let i = 0; i < n; i++) {
+				const vip = v[i * n + p];
+				const viq = v[i * n + q];
+				v[i * n + p] = c * vip - s * viq;
+				v[i * n + q] = s * vip + c * viq;
+			}
+		}
+	}
+	const values = new Float64Array(n);
+	for (let i = 0; i < n; i++) values[i] = a[i * n + i];
+	const order = Array.from({ length: n }, (_, i) => i).sort((x, y) => values[x] - values[y]);
+	const outVal = new Float64Array(n);
+	const outVec = new Float64Array(n * n);
+	for (let c = 0; c < n; c++) {
+		const src = order[c];
+		outVal[c] = values[src];
+		for (let r = 0; r < n; r++) outVec[c * n + r] = v[r * n + src];
+	}
+	return {
+		values: outVal,
+		vectors: outVec
+	};
+}
+/**
+* Modified Gram–Schmidt over columns stored contiguously (col-major: X[c*n..c*n+n)).
+* Columns with norm below dropTol (relative to their original norm) are dropped.
+* Returns the number of retained columns (retained columns are compacted in place).
+*/
+function mgsOrthonormalize(X, n, cols, dropTol = 1e-10) {
+	let kept = 0;
+	for (let c = 0; c < cols; c++) {
+		const src = c * n;
+		if (kept !== c) X.copyWithin(kept * n, src, src + n);
+		const base = kept * n;
+		let norm0 = 0;
+		for (let r = 0; r < n; r++) norm0 += X[base + r] * X[base + r];
+		norm0 = Math.sqrt(norm0);
+		for (let pass = 0; pass < 2; pass++) for (let p = 0; p < kept; p++) {
+			const pb = p * n;
+			let dot = 0;
+			for (let r = 0; r < n; r++) dot += X[pb + r] * X[base + r];
+			for (let r = 0; r < n; r++) X[base + r] = X[base + r] - dot * X[pb + r];
+		}
+		let norm = 0;
+		for (let r = 0; r < n; r++) norm += X[base + r] * X[base + r];
+		norm = Math.sqrt(norm);
+		if (norm > dropTol * Math.max(norm0, 1e-300) && norm > 1e-300) {
+			for (let r = 0; r < n; r++) X[base + r] = X[base + r] / norm;
+			kept++;
+		}
+	}
+	return kept;
+}
+
+//#endregion
+//#region src/init/pca.ts
+function pcaScores(X, dim, rng, center = true) {
+	const n = X.rows;
+	const d = X.cols;
+	const l = Math.min(d, dim + 7);
+	const mean = new Float64Array(d);
+	if (center) {
+		for (let i = 0; i < n; i++) for (let j = 0; j < d; j++) mean[j] = mean[j] + X.data[i * d + j];
+		for (let j = 0; j < d; j++) mean[j] = mean[j] / n;
+	}
+	const omega = new Float64Array(d * l);
+	for (let i = 0; i < omega.length; i++) omega[i] = rng.normal();
+	let Q = new Float64Array(n * l);
+	for (let i = 0; i < n; i++) for (let c = 0; c < l; c++) {
+		let acc = 0;
+		for (let j = 0; j < d; j++) acc += (X.data[i * d + j] - mean[j]) * omega[j * l + c];
+		Q[c * n + i] = acc;
+	}
+	orthonormalizeCols(Q, n, l);
+	for (let power = 0; power < 2; power++) {
+		const Z = new Float64Array(d * l);
+		for (let c = 0; c < l; c++) for (let i = 0; i < n; i++) {
+			const q = Q[c * n + i];
+			if (q === 0) continue;
+			for (let j = 0; j < d; j++) Z[c * d + j] = Z[c * d + j] + (X.data[i * d + j] - mean[j]) * q;
+		}
+		const Q2 = new Float64Array(n * l);
+		for (let c = 0; c < l; c++) for (let i = 0; i < n; i++) {
+			let acc = 0;
+			for (let j = 0; j < d; j++) acc += (X.data[i * d + j] - mean[j]) * Z[c * d + j];
+			Q2[c * n + i] = acc;
+		}
+		Q = Q2;
+		orthonormalizeCols(Q, n, l);
+	}
+	const B = new Float64Array(l * d);
+	for (let c = 0; c < l; c++) for (let i = 0; i < n; i++) {
+		const q = Q[c * n + i];
+		if (q === 0) continue;
+		for (let j = 0; j < d; j++) B[c * d + j] = B[c * d + j] + q * (X.data[i * d + j] - mean[j]);
+	}
+	const BBt = new Float64Array(l * l);
+	for (let a = 0; a < l; a++) for (let b = a; b < l; b++) {
+		let acc = 0;
+		for (let j = 0; j < d; j++) acc += B[a * d + j] * B[b * d + j];
+		BBt[a * l + b] = acc;
+		BBt[b * l + a] = acc;
+	}
+	const eig = symmetricEigen(BBt, l);
+	const scores = new Float64Array(n * dim);
+	for (let c = 0; c < dim; c++) {
+		const col = l - 1 - c;
+		const sigma = Math.sqrt(Math.max(eig.values[col], 0));
+		for (let i = 0; i < n; i++) {
+			let acc = 0;
+			for (let a = 0; a < l; a++) acc += Q[a * n + i] * eig.vectors[col * l + a];
+			scores[i * dim + c] = acc * sigma;
+		}
+	}
+	return scores;
+}
+function orthonormalizeCols(Q, n, cols) {
+	for (let c = 0; c < cols; c++) {
+		const base = c * n;
+		for (let pass = 0; pass < 2; pass++) for (let p = 0; p < c; p++) {
+			const pb = p * n;
+			let dot = 0;
+			for (let r = 0; r < n; r++) dot += Q[pb + r] * Q[base + r];
+			for (let r = 0; r < n; r++) Q[base + r] = Q[base + r] - dot * Q[pb + r];
+		}
+		let norm = 0;
+		for (let r = 0; r < n; r++) norm += Q[base + r] * Q[base + r];
+		norm = Math.sqrt(norm);
+		if (norm > 1e-300) for (let r = 0; r < n; r++) Q[base + r] = Q[base + r] / norm;
+	}
+}
+
+//#endregion
+//#region src/init/spectral.ts
+/** Connected components via BFS over an undirected CSR graph. */
+function connectedComponents(graph) {
+	const n = graph.rows;
+	const labels = new Int32Array(n).fill(-1);
+	const queue = new Int32Array(n);
+	let count = 0;
+	for (let s = 0; s < n; s++) {
+		if (labels[s] !== -1) continue;
+		labels[s] = count;
+		let head = 0;
+		let tail = 0;
+		queue[tail++] = s;
+		while (head < tail) {
+			const u = queue[head++];
+			for (let p = graph.indptr[u]; p < graph.indptr[u + 1]; p++) {
+				const v = graph.indices[p];
+				if (labels[v] === -1) {
+					labels[v] = count;
+					queue[tail++] = v;
+				}
+			}
+		}
+		count++;
+	}
+	return {
+		count,
+		labels
+	};
+}
+/**
+* Y = L S for a block S of `cols` column vectors, where
+* L = I − D^{-1/2} A D^{-1/2}. `scaled` holds the pre-scaled off-diagonal
+* values A_ij·dinvsqrt[j] (computed once per solve); dinvsqrt[i] is applied
+* after each row sum — the exact fp op order of the unfused loop, so results
+* are bit-identical to the reference implementation path, per column. All
+* columns share one pass over the CSR arrays (the SpMV is memory-bound; the
+* blocked walk reads `scaled`/`indices` once instead of once per column).
+*/
+function laplacianMatVecBlock(graph, scaled, dinvsqrt, S, cols, Y) {
+	const n = graph.rows;
+	const indptr = graph.indptr;
+	const indices = graph.indices;
+	if (cols === 3) {
+		for (let i = 0; i < n; i++) {
+			let a0 = 0;
+			let a1 = 0;
+			let a2 = 0;
+			const end = indptr[i + 1];
+			for (let p = indptr[i]; p < end; p++) {
+				const v = scaled[p];
+				const j = indices[p];
+				a0 += v * S[j];
+				a1 += v * S[n + j];
+				a2 += v * S[2 * n + j];
+			}
+			const di = dinvsqrt[i];
+			Y[i] = S[i] - di * a0;
+			Y[n + i] = S[n + i] - di * a1;
+			Y[2 * n + i] = S[2 * n + i] - di * a2;
+		}
+		return;
+	}
+	const acc = new Float64Array(cols);
+	for (let i = 0; i < n; i++) {
+		acc.fill(0);
+		const end = indptr[i + 1];
+		for (let p = indptr[i]; p < end; p++) {
+			const v = scaled[p];
+			const j = indices[p];
+			for (let c = 0; c < cols; c++) acc[c] += v * S[c * n + j];
+		}
+		const di = dinvsqrt[i];
+		for (let c = 0; c < cols; c++) Y[c * n + i] = S[c * n + i] - di * acc[c];
+	}
+}
+function scaleLaplacian(graph, dinvsqrt) {
+	const scaled = new Float64Array(graph.data.length);
+	for (let i = 0; i < graph.rows; i++) for (let p = graph.indptr[i]; p < graph.indptr[i + 1]; p++) scaled[p] = graph.data[p] * dinvsqrt[graph.indices[p]];
+	return scaled;
+}
+/**
+* LOBPCG for the m smallest eigenpairs of the normalized Laplacian of `graph`,
+* with diagonal (Jacobi) preconditioner. X0 is col-major n×m.
+*/
+function lobpcgSmallest(graph, dinvsqrt, X0, m, tol = 1e-4, maxIter = 200) {
+	const n = graph.rows;
+	const diag = new Float64Array(n).fill(1);
+	for (let i = 0; i < n; i++) for (let p = graph.indptr[i]; p < graph.indptr[i + 1]; p++) if (graph.indices[p] === i) diag[i] = 1 - graph.data[p] * dinvsqrt[i] * dinvsqrt[i];
+	const precond = new Float64Array(n);
+	for (let i = 0; i < n; i++) precond[i] = Math.abs(diag[i]) > 1e-12 ? 1 / diag[i] : 1;
+	const scaled = scaleLaplacian(graph, dinvsqrt);
+	let X = X0.slice();
+	let P = null;
+	let pCols = 0;
+	const values = new Float64Array(m);
+	const residuals = new Float64Array(m).fill(Infinity);
+	let converged = false;
+	let iter = 0;
+	const LXbuf = new Float64Array(n * m);
+	const Rbuf = new Float64Array(n * m);
+	const Wbuf = new Float64Array(n * m);
+	const Sbuf = new Float64Array(n * 3 * m);
+	const LSbuf = new Float64Array(n * 3 * m);
+	const xtlx = new Float64Array(m);
+	let newX = new Float64Array(n * m);
+	let newP = new Float64Array(n * m);
+	const applyL = (S, cols, out) => {
+		laplacianMatVecBlock(graph, scaled, dinvsqrt, S, cols, out);
+		return out;
+	};
+	for (iter = 0; iter < maxIter; iter++) {
+		mgsOrthonormalize(X, n, m);
+		const LX$1 = applyL(X, m, LXbuf);
+		for (let c = 0; c < m; c++) {
+			let dot = 0;
+			for (let r = 0; r < n; r++) dot += X[c * n + r] * LX$1[c * n + r];
+			xtlx[c] = dot;
+		}
+		const R = Rbuf;
+		let worst = 0;
+		for (let c = 0; c < m; c++) {
+			let rn = 0;
+			for (let r = 0; r < n; r++) {
+				const v = LX$1[c * n + r] - xtlx[c] * X[c * n + r];
+				R[c * n + r] = v;
+				rn += v * v;
+			}
+			residuals[c] = Math.sqrt(rn);
+			if (residuals[c] > worst) worst = residuals[c];
+			values[c] = xtlx[c];
+		}
+		if (worst <= tol) {
+			converged = true;
+			break;
+		}
+		const W = Wbuf;
+		for (let c = 0; c < m; c++) for (let r = 0; r < n; r++) W[c * n + r] = precond[r] * R[c * n + r];
+		const totalCols = m + m + pCols;
+		const S = Sbuf;
+		S.set(X.subarray(0, n * m), 0);
+		S.set(W, n * m);
+		if (P && pCols > 0) S.set(P.subarray(0, n * pCols), n * 2 * m);
+		const q = mgsOrthonormalize(S, n, totalCols);
+		if (q < m) break;
+		const LS = applyL(S, q, LSbuf);
+		const A$1 = new Float64Array(q * q);
+		for (let a = 0; a < q; a++) for (let b = a; b < q; b++) {
+			let dot = 0;
+			for (let r = 0; r < n; r++) dot += S[a * n + r] * LS[b * n + r];
+			A$1[a * q + b] = dot;
+			A$1[b * q + a] = dot;
+		}
+		const eig$1 = symmetricEigen(A$1, q);
+		newX.fill(0);
+		newP.fill(0);
+		for (let c = 0; c < m; c++) for (let a = 0; a < q; a++) {
+			const w = eig$1.vectors[c * q + a];
+			if (w === 0) continue;
+			const sBase = a * n;
+			const xBase = c * n;
+			for (let r = 0; r < n; r++) newX[xBase + r] = newX[xBase + r] + w * S[sBase + r];
+			if (a >= m) for (let r = 0; r < n; r++) newP[xBase + r] = newP[xBase + r] + w * S[sBase + r];
+		}
+		const oldX = X;
+		const oldP = P ?? new Float64Array(n * m);
+		X = newX;
+		P = newP;
+		newX = oldX;
+		newP = oldP;
+		pCols = m;
+	}
+	mgsOrthonormalize(X, n, m);
+	const LX = applyL(X, m, LXbuf);
+	const A = new Float64Array(m * m);
+	for (let a = 0; a < m; a++) for (let b = a; b < m; b++) {
+		let dot = 0;
+		for (let r = 0; r < n; r++) dot += X[a * n + r] * LX[b * n + r];
+		A[a * m + b] = dot;
+		A[b * m + a] = dot;
+	}
+	const eig = symmetricEigen(A, m);
+	const outVec = new Float64Array(n * m);
+	for (let c = 0; c < m; c++) for (let a = 0; a < m; a++) {
+		const w = eig.vectors[c * m + a];
+		if (w === 0) continue;
+		for (let r = 0; r < n; r++) outVec[c * n + r] = outVec[c * n + r] + w * X[a * n + r];
+	}
+	const LV = applyL(outVec, m, LXbuf);
+	for (let c = 0; c < m; c++) {
+		let rn = 0;
+		for (let r = 0; r < n; r++) {
+			const v = LV[c * n + r] - eig.values[c] * outVec[c * n + r];
+			rn += v * v;
+		}
+		residuals[c] = Math.sqrt(rn);
+	}
+	return {
+		values: eig.values,
+		vectors: outVec,
+		converged,
+		iterations: iter,
+		residuals
+	};
+}
+/**
+* lobpcgSmallest with an injected (possibly asynchronous) L·S operator — used
+* by the WebGPU backend to offload the SpMV. A verbatim duplicate of the sync
+* driver above (kept separate so the validated CPU path stays untouched);
+* only the applyL calls are awaited.
+*/
+async function lobpcgSmallestAsync(graph, dinvsqrt, X0, m, tol, maxIter, applyLAsync) {
+	const n = graph.rows;
+	const diag = new Float64Array(n).fill(1);
+	for (let i = 0; i < n; i++) for (let p = graph.indptr[i]; p < graph.indptr[i + 1]; p++) if (graph.indices[p] === i) diag[i] = 1 - graph.data[p] * dinvsqrt[i] * dinvsqrt[i];
+	const precond = new Float64Array(n);
+	for (let i = 0; i < n; i++) precond[i] = Math.abs(diag[i]) > 1e-12 ? 1 / diag[i] : 1;
+	let X = X0.slice();
+	let P = null;
+	let pCols = 0;
+	const values = new Float64Array(m);
+	const residuals = new Float64Array(m).fill(Infinity);
+	let converged = false;
+	let iter = 0;
+	const LXbuf = new Float64Array(n * m);
+	const Rbuf = new Float64Array(n * m);
+	const Wbuf = new Float64Array(n * m);
+	const Sbuf = new Float64Array(n * 3 * m);
+	const LSbuf = new Float64Array(n * 3 * m);
+	const xtlx = new Float64Array(m);
+	let newX = new Float64Array(n * m);
+	let newP = new Float64Array(n * m);
+	for (iter = 0; iter < maxIter; iter++) {
+		mgsOrthonormalize(X, n, m);
+		const LX$1 = await applyLAsync(X, m, LXbuf);
+		for (let c = 0; c < m; c++) {
+			let dot = 0;
+			for (let r = 0; r < n; r++) dot += X[c * n + r] * LX$1[c * n + r];
+			xtlx[c] = dot;
+		}
+		const R = Rbuf;
+		let worst = 0;
+		for (let c = 0; c < m; c++) {
+			let rn = 0;
+			for (let r = 0; r < n; r++) {
+				const v = LX$1[c * n + r] - xtlx[c] * X[c * n + r];
+				R[c * n + r] = v;
+				rn += v * v;
+			}
+			residuals[c] = Math.sqrt(rn);
+			if (residuals[c] > worst) worst = residuals[c];
+			values[c] = xtlx[c];
+		}
+		if (worst <= tol) {
+			converged = true;
+			break;
+		}
+		const W = Wbuf;
+		for (let c = 0; c < m; c++) for (let r = 0; r < n; r++) W[c * n + r] = precond[r] * R[c * n + r];
+		const totalCols = m + m + pCols;
+		const S = Sbuf;
+		S.set(X.subarray(0, n * m), 0);
+		S.set(W, n * m);
+		if (P && pCols > 0) S.set(P.subarray(0, n * pCols), n * 2 * m);
+		const q = mgsOrthonormalize(S, n, totalCols);
+		if (q < m) break;
+		const LS = await applyLAsync(S, q, LSbuf);
+		const A$1 = new Float64Array(q * q);
+		for (let a = 0; a < q; a++) for (let b = a; b < q; b++) {
+			let dot = 0;
+			for (let r = 0; r < n; r++) dot += S[a * n + r] * LS[b * n + r];
+			A$1[a * q + b] = dot;
+			A$1[b * q + a] = dot;
+		}
+		const eig$1 = symmetricEigen(A$1, q);
+		newX.fill(0);
+		newP.fill(0);
+		for (let c = 0; c < m; c++) for (let a = 0; a < q; a++) {
+			const w = eig$1.vectors[c * q + a];
+			if (w === 0) continue;
+			const sBase = a * n;
+			const xBase = c * n;
+			for (let r = 0; r < n; r++) newX[xBase + r] = newX[xBase + r] + w * S[sBase + r];
+			if (a >= m) for (let r = 0; r < n; r++) newP[xBase + r] = newP[xBase + r] + w * S[sBase + r];
+		}
+		const oldX = X;
+		const oldP = P ?? new Float64Array(n * m);
+		X = newX;
+		P = newP;
+		newX = oldX;
+		newP = oldP;
+		pCols = m;
+	}
+	mgsOrthonormalize(X, n, m);
+	const LX = await applyLAsync(X, m, LXbuf);
+	const A = new Float64Array(m * m);
+	for (let a = 0; a < m; a++) for (let b = a; b < m; b++) {
+		let dot = 0;
+		for (let r = 0; r < n; r++) dot += X[a * n + r] * LX[b * n + r];
+		A[a * m + b] = dot;
+		A[b * m + a] = dot;
+	}
+	const eig = symmetricEigen(A, m);
+	const outVec = new Float64Array(n * m);
+	for (let c = 0; c < m; c++) for (let a = 0; a < m; a++) {
+		const w = eig.vectors[c * m + a];
+		if (w === 0) continue;
+		for (let r = 0; r < n; r++) outVec[c * n + r] = outVec[c * n + r] + w * X[a * n + r];
+	}
+	const LV = await applyLAsync(outVec, m, LXbuf);
+	for (let c = 0; c < m; c++) {
+		let rn = 0;
+		for (let r = 0; r < n; r++) {
+			const v = LV[c * n + r] - eig.values[c] * outVec[c * n + r];
+			rn += v * v;
+		}
+		residuals[c] = Math.sqrt(rn);
+	}
+	return {
+		values: eig.values,
+		vectors: outVec,
+		converged,
+		iterations: iter,
+		residuals
+	};
+}
+/** Degree vector d_i = Σ_j A_ij and its inverse sqrt. */
+function degreeInvSqrt(graph) {
+	const n = graph.rows;
+	const deg = new Float64Array(n);
+	for (let i = 0; i < n; i++) for (let p = graph.indptr[i]; p < graph.indptr[i + 1]; p++) deg[i] = deg[i] + graph.data[p];
+	const dinvsqrt = new Float64Array(n);
+	for (let i = 0; i < n; i++) dinvsqrt[i] = deg[i] > 0 ? 1 / Math.sqrt(deg[i]) : 0;
+	return {
+		deg,
+		dinvsqrt
+	};
+}
+/** Single-component spectral layout: k+1 smallest eigenvectors, drop trivial. */
+function spectralLayoutSingle(graph, dim, rng, logger) {
+	const n = graph.rows;
+	const m = dim + 1;
+	const { deg, dinvsqrt } = degreeInvSqrt(graph);
+	const X0 = new Float64Array(n * m);
+	for (let c = 0; c < m; c++) for (let r = 0; r < n; r++) X0[c * n + r] = rng.normal();
+	let norm = 0;
+	for (let r = 0; r < n; r++) norm += deg[r];
+	norm = Math.sqrt(norm);
+	for (let r = 0; r < n; r++) X0[r] = Math.sqrt(deg[r]) / norm;
+	const res = lobpcgSmallest(graph, dinvsqrt, X0, m, 1e-4, 5 * Math.min(n, 60));
+	if (!res.converged) {
+		logger.warn("UmapConvergenceWarning: Spectral initialisation failed! The eigenvector solver failed. This is likely due to too small an eigengap. Consider adding some noise or jitter to your data. Falling back to random initialisation!");
+		const emb = new Float64Array(n * dim);
+		for (let i = 0; i < emb.length; i++) emb[i] = rng.uniform(-10, 10);
+		return {
+			embedding: emb,
+			usedFallback: true
+		};
+	}
+	const embedding = new Float64Array(n * dim);
+	for (let d = 0; d < dim; d++) {
+		const c = d + 1;
+		for (let r = 0; r < n; r++) embedding[r * dim + d] = res.vectors[c * n + r];
+	}
+	return {
+		embedding,
+		usedFallback: false
+	};
+}
+/** exp(−d²) affinity spectral embedding of component centroids (spectral.py:18-142). */
+function componentLayout(data, nComponents, labels, dim, rng) {
+	const meta = new Float64Array(nComponents * dim);
+	if (!data) {
+		for (let i = 0; i < meta.length; i++) meta[i] = rng.nextFloat() * 10;
+		return meta;
+	}
+	const d = data.cols;
+	const centroids = new Float64Array(nComponents * d);
+	const counts = new Int32Array(nComponents);
+	for (let i = 0; i < data.rows; i++) {
+		const c = labels[i];
+		counts[c]++;
+		for (let j = 0; j < d; j++) centroids[c * d + j] = centroids[c * d + j] + data.data[i * d + j];
+	}
+	for (let c = 0; c < nComponents; c++) for (let j = 0; j < d; j++) centroids[c * d + j] = centroids[c * d + j] / counts[c];
+	const aff = new Float64Array(nComponents * nComponents);
+	for (let a = 0; a < nComponents; a++) for (let b = 0; b < nComponents; b++) {
+		let s = 0;
+		for (let j = 0; j < d; j++) {
+			const diff = centroids[a * d + j] - centroids[b * d + j];
+			s += diff * diff;
+		}
+		aff[a * nComponents + b] = Math.exp(-s);
+	}
+	const n = nComponents;
+	const deg = new Float64Array(n);
+	for (let a = 0; a < n; a++) for (let b = 0; b < n; b++) deg[a] = deg[a] + aff[a * n + b];
+	const L = new Float64Array(n * n);
+	for (let a = 0; a < n; a++) for (let b = 0; b < n; b++) {
+		const norm = Math.sqrt(deg[a] * deg[b]);
+		L[a * n + b] = (a === b ? 1 : 0) - (norm > 0 ? aff[a * n + b] / norm : 0);
+	}
+	const eig = symmetricEigen(L, n);
+	let mx = 0;
+	for (let c = 0; c < dim; c++) {
+		const col = Math.min(c + 1, n - 1);
+		for (let a = 0; a < n; a++) {
+			const v = eig.vectors[col * n + a] / Math.sqrt(deg[a]);
+			meta[a * dim + c] = v;
+			if (Math.abs(v) > mx) mx = Math.abs(v);
+		}
+	}
+	let realMax = -Infinity;
+	for (let i = 0; i < meta.length; i++) if (meta[i] > realMax) realMax = meta[i];
+	if (realMax !== 0 && Number.isFinite(realMax)) for (let i = 0; i < meta.length; i++) meta[i] = meta[i] / realMax;
+	return meta;
+}
+/** multi_component_layout (spectral.py:145-260). */
+function multiComponentLayout(data, graph, nComponents, labels, dim, rng, logger) {
+	const n = graph.rows;
+	const result = new Float64Array(n * dim);
+	let meta;
+	if (nComponents > 2 * dim) meta = componentLayout(data, nComponents, labels, dim, rng);
+	else {
+		const k = Math.ceil(nComponents / 2);
+		meta = new Float64Array(nComponents * dim);
+		for (let c = 0; c < nComponents; c++) if (c < k) {
+			if (c < dim) meta[c * dim + c] = 1;
+		} else {
+			const idx = c - k;
+			if (idx < dim) meta[c * dim + idx] = -1;
+		}
+	}
+	let anyFallback = false;
+	for (let label = 0; label < nComponents; label++) {
+		const verts = [];
+		for (let i = 0; i < n; i++) if (labels[i] === label) verts.push(i);
+		const size = verts.length;
+		let minDist = Infinity;
+		for (let other = 0; other < nComponents; other++) {
+			if (other === label) continue;
+			let s = 0;
+			for (let c = 0; c < dim; c++) {
+				const diff = meta[label * dim + c] - meta[other * dim + c];
+				s += diff * diff;
+			}
+			const dd = Math.sqrt(s);
+			if (dd > 0 && dd < minDist) minDist = dd;
+		}
+		const dataRange = (Number.isFinite(minDist) ? minDist : 1) / 2;
+		if (size < 2 * dim || size <= dim + 1) {
+			for (const [vi, v] of verts.entries()) for (let c = 0; c < dim; c++) result[v * dim + c] = rng.uniform(-dataRange, dataRange) + meta[label * dim + c];
+			continue;
+		}
+		const remap = new Int32Array(n).fill(-1);
+		verts.forEach((v, i) => {
+			remap[v] = i;
+		});
+		const subIndptr = new Int32Array(size + 1);
+		let nnz = 0;
+		for (const v of verts) for (let p = graph.indptr[v]; p < graph.indptr[v + 1]; p++) if (remap[graph.indices[p]] >= 0) nnz++;
+		const subIndices = new Int32Array(nnz);
+		const subData = new Float64Array(nnz);
+		let w = 0;
+		verts.forEach((v, i) => {
+			for (let p = graph.indptr[v]; p < graph.indptr[v + 1]; p++) {
+				const t = remap[graph.indices[p]];
+				if (t >= 0) {
+					subIndices[w] = t;
+					subData[w] = graph.data[p];
+					w++;
+				}
+			}
+			subIndptr[i + 1] = w;
+		});
+		const compRes = spectralLayoutSingle({
+			indptr: subIndptr,
+			indices: subIndices,
+			data: subData,
+			rows: size,
+			cols: size
+		}, dim, rng, logger);
+		anyFallback ||= compRes.usedFallback;
+		let mx = 0;
+		for (let i = 0; i < compRes.embedding.length; i++) {
+			const v = Math.abs(compRes.embedding[i]);
+			if (v > mx) mx = v;
+		}
+		const expansion = mx > 0 ? dataRange / mx : 1;
+		verts.forEach((v, i) => {
+			for (let c = 0; c < dim; c++) result[v * dim + c] = compRes.embedding[i * dim + c] * expansion + meta[label * dim + c];
+		});
+	}
+	return {
+		embedding: result,
+		usedFallback: anyFallback
+	};
+}
+/**
+* spectral_layout: normalized-Laplacian eigenmaps of the fuzzy graph with
+* multi-component handling. Returns n×dim float64 (caller scales/noises/casts).
+*/
+function spectralLayout(data, graph, dim, rng, logger = silentLogger) {
+	const { count, labels } = connectedComponents(graph);
+	if (count > 1) return multiComponentLayout(data, graph, count, labels, dim, rng, logger);
+	return spectralLayoutSingle(graph, dim, rng, logger);
+}
+
+//#endregion
+//#region src/init/index.ts
+/** noisy_scale_coords (umap_.py:928-935): scale abs-max to maxCoord, add N(0, noise). */
+function noisyScaleCoords(coords, rng, maxCoord = 10, noise = 1e-4) {
+	let mx = 0;
+	for (let i = 0; i < coords.length; i++) {
+		const v = Math.abs(coords[i]);
+		if (v > mx) mx = v;
+	}
+	const expansion = mx > 0 ? maxCoord / mx : 1;
+	for (let i = 0; i < coords.length; i++) coords[i] = Math.fround(coords[i] * expansion) + rng.normal() * noise;
+}
+/** Final rescale applied to EVERY init (umap_.py:1188-1192): per-dim min-max → [0,10]. */
+function finalInitRescale(embedding, n, dim) {
+	const out = new Float32Array(n * dim);
+	for (let c = 0; c < dim; c++) {
+		let mn = Infinity;
+		let mx = -Infinity;
+		for (let i = 0; i < n; i++) {
+			const v = embedding[i * dim + c];
+			if (v < mn) mn = v;
+			if (v > mx) mx = v;
+		}
+		const range = mx - mn;
+		for (let i = 0; i < n; i++) out[i * dim + c] = range > 0 ? 10 * (embedding[i * dim + c] - mn) / range : 0;
+	}
+	return out;
+}
+/**
+* Produce the initial embedding for `graph` (pruned fuzzy graph) and `data`.
+* Data may be null when init doesn't need it (random / spectral without
+* multi-component meta layout data).
+*/
+function initializeEmbedding(init, data, graph, dim, rng, { logger = silentLogger } = {}) {
+	const n = graph.rows;
+	let emb;
+	let spectralFallback = false;
+	if (typeof init === "object") {
+		const e = init;
+		if (e.rows !== n || e.cols !== dim) throw new UmapValidationError(`init embedding must be ${n}x${dim}, got ${e.rows}x${e.cols}`);
+		emb = new Float64Array(n * dim);
+		const seen = /* @__PURE__ */ new Set();
+		let hasDup = false;
+		for (let i = 0; i < n; i++) {
+			const key = Array.from(e.data.subarray(i * dim, (i + 1) * dim)).join(",");
+			if (seen.has(key)) {
+				hasDup = true;
+				break;
+			}
+			seen.add(key);
+		}
+		for (let i = 0; i < e.data.length; i++) emb[i] = e.data[i];
+		if (hasDup) {
+			const sample = Math.min(n, 512);
+			let acc = 0;
+			let cnt = 0;
+			for (let i = 0; i < sample; i++) {
+				let best = Infinity;
+				for (let j = 0; j < n; j++) {
+					if (j === i) continue;
+					let s = 0;
+					for (let c = 0; c < dim; c++) {
+						const d = emb[i * dim + c] - emb[j * dim + c];
+						s += d * d;
+					}
+					if (s > 0 && s < best) best = s;
+				}
+				if (Number.isFinite(best)) {
+					acc += Math.sqrt(best);
+					cnt++;
+				}
+			}
+			const nndist = cnt > 0 ? acc / cnt : .001;
+			for (let i = 0; i < emb.length; i++) emb[i] = emb[i] + rng.normal() * .001 * nndist;
+		}
+	} else if (init === "random") {
+		emb = new Float64Array(n * dim);
+		for (let i = 0; i < emb.length; i++) emb[i] = rng.uniform(-10, 10);
+	} else if (init === "pca") {
+		if (!data) throw new UmapValidationError("init 'pca' requires dense data");
+		emb = pcaScores(data, dim, rng);
+		noisyScaleCoords(emb, rng, 10, 1e-4);
+	} else if (init === "spectral") {
+		const res = spectralLayout(data, graph, dim, rng, logger);
+		emb = res.embedding;
+		spectralFallback = res.usedFallback;
+		if (!res.usedFallback) noisyScaleCoords(emb, rng, 10, 1e-4);
+	} else throw new UmapValidationError(`unknown init '${String(init)}'`);
+	return {
+		embedding: finalInitRescale(emb, n, dim),
+		spectralFallback
+	};
+}
+
+//#endregion
+export { silentLogger as _, degreeInvSqrt as a, spectralLayout as c, symmetricEigen as d, UmapBackendError as f, consoleLogger as g, UmapValidationError as h, connectedComponents as i, pcaScores as l, UmapError as m, initializeEmbedding as n, lobpcgSmallest as o, UmapConvergenceWarning as p, noisyScaleCoords as r, lobpcgSmallestAsync as s, finalInitRescale as t, mgsOrthonormalize as u, throwIfAborted as v };
+//# sourceMappingURL=init-DLiEtGpx.js.map