graphwise 1.9.0 → 1.10.0

package/dist/logic-DyBzRg1A.js

@@ -0,0 +1,242 @@
+import { n as data_exports } from "./typegpu-DwnJf28i.js";
+//#region src/gpu/csr.ts
+/**
+* Compressed Sparse Row (CSR) matrix representation for GPU computation.
+*
+* CSR format is memory-efficient for sparse graphs and maps well to
+* GPU parallel operations. The format stores adjacency information
+* in three arrays: row offsets, column indices, and optional values.
+*/
+/**
+* Convert a ReadableGraph to CSR format.
+*
+* For undirected graphs, each edge is stored twice (once in each direction).
+* For directed graphs, edges are stored in the out-direction by default.
+*
+* @param graph - The graph to convert
+* @param direction - Edge direction to include (default: 'out' for directed, 'both' for undirected)
+* @returns CSR representation with index mapping
+*/
+function graphToCSR(graph, direction = graph.directed ? "out" : "both") {
+	const nodeToIndex = /* @__PURE__ */ new Map();
+	const indexToNode = [];
+	for (const nodeId of graph.nodeIds()) {
+		const index = indexToNode.length;
+		nodeToIndex.set(nodeId, index);
+		indexToNode.push(nodeId);
+	}
+	const nodeCount = indexToNode.length;
+	const degrees = new Uint32Array(nodeCount);
+	for (const nodeId of graph.nodeIds()) {
+		const srcIndex = nodeToIndex.get(nodeId);
+		if (srcIndex === void 0) continue;
+		degrees[srcIndex] = graph.degree(nodeId, direction);
+	}
+	let totalEdges = 0;
+	for (let i = 0; i < nodeCount; i++) totalEdges += degrees[i] ?? 0;
+	const rowOffsets = new Uint32Array(nodeCount + 1);
+	for (let i = 0; i < nodeCount; i++) rowOffsets[i + 1] = (rowOffsets[i] ?? 0) + (degrees[i] ?? 0);
+	const colIndices = new Uint32Array(totalEdges);
+	const values = new Float32Array(totalEdges);
+	for (const nodeId of graph.nodeIds()) {
+		const srcIndex = nodeToIndex.get(nodeId);
+		if (srcIndex === void 0) continue;
+		const baseOffset = rowOffsets[srcIndex] ?? 0;
+		let localOffset = 0;
+		for (const neighbourId of graph.neighbours(nodeId, direction)) {
+			const dstIndex = nodeToIndex.get(neighbourId);
+			if (dstIndex === void 0) continue;
+			const edgeIdx = baseOffset + localOffset;
+			colIndices[edgeIdx] = dstIndex;
+			values[edgeIdx] = graph.getEdge(nodeId, neighbourId)?.weight ?? 1;
+			localOffset++;
+		}
+	}
+	return {
+		csr: {
+			rowOffsets,
+			colIndices,
+			values,
+			nodeCount,
+			edgeCount: graph.directed ? graph.edgeCount : graph.edgeCount * 2
+		},
+		indexMap: {
+			nodeToIndex,
+			indexToNode
+		}
+	};
+}
+/**
+* Create TypeGPU typed buffers from a CSR matrix.
+*
+* Uses TypeGPU's typed buffer API for type-safe GPU computation.
+* Buffers are created with storage usage for compute operations.
+*
+* @param root - TypeGPU root instance
+* @param csr - CSR matrix to upload
+* @returns Typed buffer group
+*
+* @example
+* ```typescript
+* import { initGPU, csrToTypedBuffers, graphToCSR } from "graphwise/gpu";
+*
+* const root = await initGPU();
+* const { csr } = graphToCSR(graph);
+* const buffers = csrToTypedBuffers(root, csr);
+*
+* // Read data back to CPU
+* const rowOffsets = await buffers.rowOffsets.read();
+* console.log(rowOffsets); // Uint32Array
+* ```
+*/
+function csrToTypedBuffers(root, csr) {
+	const rowOffsetsArray = Array.from(csr.rowOffsets);
+	const colIndicesArray = Array.from(csr.colIndices);
+	const rowOffsetsBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.u32, csr.rowOffsets.length), rowOffsetsArray).$usage("storage"), "rowOffsetsBuffer");
+	const colIndicesBuffer = (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.u32, csr.colIndices.length), colIndicesArray).$usage("storage"), "colIndicesBuffer");
+	if (csr.values !== void 0) {
+		const valuesArray = Array.from(csr.values);
+		return {
+			rowOffsets: rowOffsetsBuffer,
+			colIndices: colIndicesBuffer,
+			values: (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(data_exports.arrayOf(data_exports.f32, csr.values.length), valuesArray).$usage("storage"), "valuesBuffer"),
+			nodeCount: csr.nodeCount,
+			edgeCount: csr.edgeCount
+		};
+	}
+	return {
+		rowOffsets: rowOffsetsBuffer,
+		colIndices: colIndicesBuffer,
+		nodeCount: csr.nodeCount,
+		edgeCount: csr.edgeCount
+	};
+}
+//#endregion
+//#region src/gpu/kernels/intersection/logic.ts
+/**
+* Binary search in a sorted subarray of colIndices.
+*
+* @param colIndices - CSR column indices array (must be sorted per row)
+* @param start - Start index (inclusive)
+* @param end - End index (exclusive)
+* @param target - Value to search for
+* @returns true if target is found between colIndices[start] and colIndices[end-1]
+*/
+function binarySearch(colIndices, start, end, target) {
+	let lo = start;
+	let hi = end;
+	while (lo < hi) {
+		const mid = lo + Math.floor((hi - lo) / 2);
+		const midVal = colIndices[mid] ?? 0;
+		if (midVal === target) return true;
+		else if (midVal < target) lo = mid + 1;
+		else hi = mid;
+	}
+	return false;
+}
+/**
+* Compute intersection stats for a single pair of nodes in CSR format.
+*
+* Neighbours must be sorted (CSR guarantees this from graphToCSR).
+*
+* @param rowOffsets - CSR row offset array
+* @param colIndices - CSR column indices array
+* @param u - First node index
+* @param v - Second node index
+* @returns Intersection result with sizes
+*/
+function intersectionPair(rowOffsets, colIndices, u, v) {
+	const uStart = rowOffsets[u] ?? 0;
+	const uEnd = rowOffsets[u + 1] ?? 0;
+	const vStart = rowOffsets[v] ?? 0;
+	const vEnd = rowOffsets[v + 1] ?? 0;
+	const sizeU = uEnd - uStart;
+	const sizeV = vEnd - vStart;
+	if (sizeU === 0 || sizeV === 0) return {
+		intersection: 0,
+		sizeU,
+		sizeV
+	};
+	let intersection = 0;
+	if (sizeU <= sizeV) {
+		for (let i = uStart; i < uEnd; i++) if (binarySearch(colIndices, vStart, vEnd, colIndices[i] ?? 0)) intersection++;
+	} else for (let i = vStart; i < vEnd; i++) if (binarySearch(colIndices, uStart, uEnd, colIndices[i] ?? 0)) intersection++;
+	return {
+		intersection,
+		sizeU,
+		sizeV
+	};
+}
+/**
+* Batch intersection stats for multiple node pairs.
+*
+* @param rowOffsets - CSR row offset array
+* @param colIndices - CSR column indices array
+* @param pairs - Array of [u, v] node index pairs
+* @returns Object with parallel arrays: intersections, sizeUs, sizeVs
+*/
+function intersectionBatch(rowOffsets, colIndices, pairs) {
+	const n = pairs.length;
+	const intersections = new Uint32Array(n);
+	const sizeUs = new Uint32Array(n);
+	const sizeVs = new Uint32Array(n);
+	for (let i = 0; i < n; i++) {
+		const pair = pairs[i];
+		if (pair !== void 0) {
+			const [u, v] = pair;
+			const result = intersectionPair(rowOffsets, colIndices, u, v);
+			intersections[i] = result.intersection;
+			sizeUs[i] = result.sizeU;
+			sizeVs[i] = result.sizeV;
+		}
+	}
+	return {
+		intersections,
+		sizeUs,
+		sizeVs
+	};
+}
+/**
+* Compute Jaccard from intersection stats.
+* J = intersection / (sizeU + sizeV - intersection)
+*/
+function jaccardFromIntersection(result) {
+	const union = result.sizeU + result.sizeV - result.intersection;
+	return union === 0 ? 0 : result.intersection / union;
+}
+/**
+* Compute Cosine similarity from intersection stats.
+* Cosine = intersection / sqrt(sizeU * sizeV)
+*/
+function cosineFromIntersection(result) {
+	const denominator = Math.sqrt(result.sizeU * result.sizeV);
+	return denominator === 0 ? 0 : result.intersection / denominator;
+}
+/**
+* Compute Sorensen-Dice from intersection stats.
+* SD = 2 * intersection / (sizeU + sizeV)
+*/
+function sorensenDiceFromIntersection(result) {
+	const denominator = result.sizeU + result.sizeV;
+	return denominator === 0 ? 0 : 2 * result.intersection / denominator;
+}
+/**
+* Compute Overlap coefficient from intersection stats.
+* Overlap = intersection / min(sizeU, sizeV)
+*/
+function overlapFromIntersection(result) {
+	const minSize = Math.min(result.sizeU, result.sizeV);
+	return minSize === 0 ? 0 : result.intersection / minSize;
+}
+/**
+* Compute Hub Promoted from intersection stats.
+* HP = intersection / min(sizeU, sizeV)
+* Note: Same formula as Overlap coefficient
+*/
+function hubPromotedFromIntersection(result) {
+	return overlapFromIntersection(result);
+}
+//#endregion
+export { overlapFromIntersection as a, graphToCSR as c, jaccardFromIntersection as i, hubPromotedFromIntersection as n, sorensenDiceFromIntersection as o, intersectionBatch as r, csrToTypedBuffers as s, cosineFromIntersection as t };
+
+//# sourceMappingURL=logic-DyBzRg1A.js.map

package/dist/logic-DyBzRg1A.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logic-DyBzRg1A.js","names":[],"sources":["../src/gpu/csr.ts","../src/gpu/kernels/intersection/logic.ts"],"sourcesContent":["/**\n * Compressed Sparse Row (CSR) matrix representation for GPU computation.\n *\n * CSR format is memory-efficient for sparse graphs and maps well to\n * GPU parallel operations. The format stores adjacency information\n * in three arrays: row offsets, column indices, and optional values.\n */\n\nimport { d, type StorageFlag, type TgpuBuffer } from \"typegpu\";\nimport type { NodeId, Direction, NodeData, EdgeData } from \"../graph/types\";\nimport type { ReadableGraph } from \"../graph\";\nimport type { GraphwiseGPURoot } from \"./root\";\n\n/**\n * CSR matrix representation of a graph adjacency structure.\n *\n * The rowOffsets array has length nodeCount + 1, where rowOffsets[i]\n * gives the start index in colIndices for node i's neighbours.\n * The neighbours of node i are colIndices[rowOffsets[i] : rowOffsets[i+1]].\n */\nexport interface CSRMatrix {\n\t/** Row offsets array (length: nodeCount + 1) */\n\treadonly rowOffsets: Uint32Array;\n\t/** Column indices array (length: edgeCount for directed, 2*edgeCount for undirected) */\n\treadonly colIndices: Uint32Array;\n\t/** Optional edge weights aligned with colIndices */\n\treadonly values?: Float32Array;\n\t/** Number of nodes in the graph */\n\treadonly nodeCount: number;\n\t/** Number of directed edges (undirected edges counted once) */\n\treadonly edgeCount: number;\n}\n\n/**\n * Mapping from node IDs to CSR indices.\n *\n * Required because CSR uses dense integer indices while graphs\n * may use arbitrary string identifiers.\n */\nexport interface CSRIndexMap {\n\t/** Map from NodeId to CSR row index */\n\treadonly nodeToIndex: ReadonlyMap<NodeId, number>;\n\t/** Map from CSR row index to NodeId */\n\treadonly indexToNode: readonly NodeId[];\n}\n\n/**\n * Combined CSR matrix with index mapping.\n */\nexport interface CSRGraph {\n\treadonly csr: CSRMatrix;\n\treadonly indexMap: CSRIndexMap;\n}\n\n/**\n * Group of TypeGPU typed buffers holding a CSR matrix.\n *\n * Uses TypeGPU's typed buffer API for type-safe GPU computation.\n * Buffers are created with storage usage for compute operations.\n */\nexport interface TypedBufferGroup {\n\t/** Buffer containing rowOffsets data (u32 array) */\n\treadonly rowOffsets: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.u32>>> &\n\t\tStorageFlag;\n\t/** Buffer containing colIndices data (u32 array) */\n\treadonly colIndices: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.u32>>> &\n\t\tStorageFlag;\n\t/** Buffer containing values data (f32 array, optional) */\n\treadonly values?: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.f32>>> &\n\t\tStorageFlag;\n\t/** Number of nodes */\n\treadonly nodeCount: number;\n\t/** Number of edges */\n\treadonly edgeCount: number;\n}\n\n/**\n * Convert a ReadableGraph to CSR format.\n *\n * For undirected graphs, each edge is stored twice (once in each direction).\n * For directed graphs, edges are stored in the out-direction by default.\n *\n * @param graph - The graph to convert\n * @param direction - Edge direction to include (default: 'out' for directed, 'both' for undirected)\n * @returns CSR representation with index mapping\n */\nexport function graphToCSR<N extends NodeData, E extends EdgeData>(\n\tgraph: ReadableGraph<N, E>,\n\tdirection: Direction = graph.directed ? \"out\" : \"both\",\n): CSRGraph {\n\t// Build node index mapping\n\tconst nodeToIndex = new Map<NodeId, number>();\n\tconst indexToNode: NodeId[] = [];\n\n\tfor (const nodeId of graph.nodeIds()) {\n\t\tconst index = indexToNode.length;\n\t\tnodeToIndex.set(nodeId, index);\n\t\tindexToNode.push(nodeId);\n\t}\n\n\tconst nodeCount = indexToNode.length;\n\n\t// Count edges per node to build row offsets\n\tconst degrees = new Uint32Array(nodeCount);\n\n\tfor (const nodeId of graph.nodeIds()) {\n\t\tconst srcIndex = nodeToIndex.get(nodeId);\n\t\tif (srcIndex === undefined) continue;\n\t\tdegrees[srcIndex] = graph.degree(nodeId, direction);\n\t}\n\n\t// Calculate total edge count\n\tlet totalEdges = 0;\n\tfor (let i = 0; i < nodeCount; i++) {\n\t\ttotalEdges += degrees[i] ?? 0;\n\t}\n\n\t// Build rowOffsets array\n\tconst rowOffsets = new Uint32Array(nodeCount + 1);\n\tfor (let i = 0; i < nodeCount; i++) {\n\t\trowOffsets[i + 1] = (rowOffsets[i] ?? 0) + (degrees[i] ?? 0);\n\t}\n\n\t// Build colIndices and values arrays\n\tconst colIndices = new Uint32Array(totalEdges);\n\tconst values = new Float32Array(totalEdges);\n\n\tfor (const nodeId of graph.nodeIds()) {\n\t\tconst srcIndex = nodeToIndex.get(nodeId);\n\t\tif (srcIndex === undefined) continue;\n\n\t\tconst baseOffset = rowOffsets[srcIndex] ?? 0;\n\t\tlet localOffset = 0;\n\n\t\tfor (const neighbourId of graph.neighbours(nodeId, direction)) {\n\t\t\tconst dstIndex = nodeToIndex.get(neighbourId);\n\t\t\tif (dstIndex === undefined) continue;\n\n\t\t\tconst edgeIdx = baseOffset + localOffset;\n\t\t\tcolIndices[edgeIdx] = dstIndex;\n\n\t\t\t// Get edge weight if available\n\t\t\tconst edge = graph.getEdge(nodeId, neighbourId);\n\t\t\tvalues[edgeIdx] = edge?.weight ?? 1.0;\n\n\t\t\tlocalOffset++;\n\t\t}\n\t}\n\n\tconst csr: CSRMatrix = {\n\t\trowOffsets,\n\t\tcolIndices,\n\t\tvalues,\n\t\tnodeCount,\n\t\tedgeCount: graph.directed ? graph.edgeCount : graph.edgeCount * 2,\n\t};\n\n\tconst indexMap: CSRIndexMap = {\n\t\tnodeToIndex,\n\t\tindexToNode,\n\t};\n\n\treturn { csr, indexMap };\n}\n\n/**\n * Create TypeGPU typed buffers from a CSR matrix.\n *\n * Uses TypeGPU's typed buffer API for type-safe GPU computation.\n * Buffers are created with storage usage for compute operations.\n *\n * @param root - TypeGPU root instance\n * @param csr - CSR matrix to upload\n * @returns Typed buffer group\n *\n * @example\n * ```typescript\n * import { initGPU, csrToTypedBuffers, graphToCSR } from \"graphwise/gpu\";\n *\n * const root = await initGPU();\n * const { csr } = graphToCSR(graph);\n * const buffers = csrToTypedBuffers(root, csr);\n *\n * // Read data back to CPU\n * const rowOffsets = await buffers.rowOffsets.read();\n * console.log(rowOffsets); // Uint32Array\n * ```\n */\nexport function csrToTypedBuffers(\n\troot: GraphwiseGPURoot,\n\tcsr: CSRMatrix,\n): TypedBufferGroup {\n\t// Convert typed arrays to regular arrays for TypeGPU\n\tconst rowOffsetsArray = Array.from(csr.rowOffsets);\n\tconst colIndicesArray = Array.from(csr.colIndices);\n\n\t// Row offsets buffer (u32 array)\n\tconst rowOffsetsBuffer = root\n\t\t.createBuffer(d.arrayOf(d.u32, csr.rowOffsets.length), rowOffsetsArray)\n\t\t.$usage(\"storage\");\n\n\t// Column indices buffer (u32 array)\n\tconst colIndicesBuffer = root\n\t\t.createBuffer(d.arrayOf(d.u32, csr.colIndices.length), colIndicesArray)\n\t\t.$usage(\"storage\");\n\n\t// Values buffer (f32 array, optional)\n\tif (csr.values !== undefined) {\n\t\tconst valuesArray = Array.from(csr.values);\n\t\tconst valuesBuffer = root\n\t\t\t.createBuffer(d.arrayOf(d.f32, csr.values.length), valuesArray)\n\t\t\t.$usage(\"storage\");\n\n\t\treturn {\n\t\t\trowOffsets: rowOffsetsBuffer,\n\t\t\tcolIndices: colIndicesBuffer,\n\t\t\tvalues: valuesBuffer,\n\t\t\tnodeCount: csr.nodeCount,\n\t\t\tedgeCount: csr.edgeCount,\n\t\t};\n\t}\n\n\treturn {\n\t\trowOffsets: rowOffsetsBuffer,\n\t\tcolIndices: colIndicesBuffer,\n\t\tnodeCount: csr.nodeCount,\n\t\tedgeCount: csr.edgeCount,\n\t};\n}\n","/**\n * Pure CPU implementation of batch neighbourhood intersection.\n *\n * Computes intersection size and neighbourhood sizes for multiple node pairs.\n * This is the foundation for ALL Jaccard-family MI variants:\n *   J(A,B) = |A ∩ B| / |A ∪ B| = intersection / (sizeA + sizeB - intersection)\n *   Cosine(A,B) = |A ∩ B| / sqrt(|A| * |B|)\n *   Sorensen-Dice(A,B) = 2|A ∩ B| / (|A| + |B|)\n *   Overlap(A,B) = |A ∩ B| / min(|A|, |B|)\n *\n * Uses binary search optimisation: iterate smaller neighbourhood, search in larger.\n *\n * @module gpu/kernels/intersection/logic\n */\n\n/**\n * Result of computing intersection for a single pair.\n */\nexport interface IntersectionResult {\n\t/** Size of the intersection |N(u) ∩ N(v)| */\n\treadonly intersection: number;\n\t/** Size of first neighbourhood |N(u)| */\n\treadonly sizeU: number;\n\t/** Size of second neighbourhood |N(v)| */\n\treadonly sizeV: number;\n}\n\n/**\n * Binary search in a sorted subarray of colIndices.\n *\n * @param colIndices - CSR column indices array (must be sorted per row)\n * @param start - Start index (inclusive)\n * @param end - End index (exclusive)\n * @param target - Value to search for\n * @returns true if target is found between colIndices[start] and colIndices[end-1]\n */\nexport function binarySearch(\n\tcolIndices: Uint32Array,\n\tstart: number,\n\tend: number,\n\ttarget: number,\n): boolean {\n\tlet lo = start;\n\tlet hi = end;\n\n\twhile (lo < hi) {\n\t\tconst mid = lo + Math.floor((hi - lo) / 2);\n\t\tconst midVal = colIndices[mid] ?? 0;\n\n\t\tif (midVal === target) {\n\t\t\treturn true;\n\t\t} else if (midVal < target) {\n\t\t\tlo = mid + 1;\n\t\t} else {\n\t\t\thi = mid;\n\t\t}\n\t}\n\n\treturn false;\n}\n\n/**\n * Compute intersection stats for a single pair of nodes in CSR format.\n *\n * Neighbours must be sorted (CSR guarantees this from graphToCSR).\n *\n * @param rowOffsets - CSR row offset array\n * @param colIndices - CSR column indices array\n * @param u - First node index\n * @param v - Second node index\n * @returns Intersection result with sizes\n */\nexport function intersectionPair(\n\trowOffsets: Uint32Array,\n\tcolIndices: Uint32Array,\n\tu: number,\n\tv: number,\n): IntersectionResult {\n\tconst uStart = rowOffsets[u] ?? 0;\n\tconst uEnd = rowOffsets[u + 1] ?? 0;\n\tconst vStart = rowOffsets[v] ?? 0;\n\tconst vEnd = rowOffsets[v + 1] ?? 0;\n\n\tconst sizeU = uEnd - uStart;\n\tconst sizeV = vEnd - vStart;\n\n\t// Empty neighbourhoods → intersection = 0\n\tif (sizeU === 0 || sizeV === 0) {\n\t\treturn { intersection: 0, sizeU, sizeV };\n\t}\n\n\t// Count intersection by iterating smaller neighbourhood, binary searching in larger\n\tlet intersection = 0;\n\n\tif (sizeU <= sizeV) {\n\t\t// Iterate u's neighbours, search in v's\n\t\tfor (let i = uStart; i < uEnd; i++) {\n\t\t\tconst neighbour = colIndices[i] ?? 0;\n\t\t\tif (binarySearch(colIndices, vStart, vEnd, neighbour)) {\n\t\t\t\tintersection++;\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// Iterate v's neighbours, search in u's\n\t\tfor (let i = vStart; i < vEnd; i++) {\n\t\t\tconst neighbour = colIndices[i] ?? 0;\n\t\t\tif (binarySearch(colIndices, uStart, uEnd, neighbour)) {\n\t\t\t\tintersection++;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn { intersection, sizeU, sizeV };\n}\n\n/**\n * Batch intersection stats for multiple node pairs.\n *\n * @param rowOffsets - CSR row offset array\n * @param colIndices - CSR column indices array\n * @param pairs - Array of [u, v] node index pairs\n * @returns Object with parallel arrays: intersections, sizeUs, sizeVs\n */\nexport function intersectionBatch(\n\trowOffsets: Uint32Array,\n\tcolIndices: Uint32Array,\n\tpairs: readonly (readonly [number, number])[],\n): {\n\tintersections: Uint32Array;\n\tsizeUs: Uint32Array;\n\tsizeVs: Uint32Array;\n} {\n\tconst n = pairs.length;\n\tconst intersections = new Uint32Array(n);\n\tconst sizeUs = new Uint32Array(n);\n\tconst sizeVs = new Uint32Array(n);\n\n\tfor (let i = 0; i < n; i++) {\n\t\tconst pair = pairs[i];\n\t\tif (pair !== undefined) {\n\t\t\tconst [u, v] = pair;\n\t\t\tconst result = intersectionPair(rowOffsets, colIndices, u, v);\n\t\t\tintersections[i] = result.intersection;\n\t\t\tsizeUs[i] = result.sizeU;\n\t\t\tsizeVs[i] = result.sizeV;\n\t\t}\n\t}\n\n\treturn { intersections, sizeUs, sizeVs };\n}\n\n/**\n * Compute Jaccard from intersection stats.\n * J = intersection / (sizeU + sizeV - intersection)\n */\nexport function jaccardFromIntersection(result: IntersectionResult): number {\n\tconst union = result.sizeU + result.sizeV - result.intersection;\n\treturn union === 0 ? 0 : result.intersection / union;\n}\n\n/**\n * Compute Cosine similarity from intersection stats.\n * Cosine = intersection / sqrt(sizeU * sizeV)\n */\nexport function cosineFromIntersection(result: IntersectionResult): number {\n\tconst denominator = Math.sqrt(result.sizeU * result.sizeV);\n\treturn denominator === 0 ? 0 : result.intersection / denominator;\n}\n\n/**\n * Compute Sorensen-Dice from intersection stats.\n * SD = 2 * intersection / (sizeU + sizeV)\n */\nexport function sorensenDiceFromIntersection(\n\tresult: IntersectionResult,\n): number {\n\tconst denominator = result.sizeU + result.sizeV;\n\treturn denominator === 0 ? 0 : (2 * result.intersection) / denominator;\n}\n\n/**\n * Compute Overlap coefficient from intersection stats.\n * Overlap = intersection / min(sizeU, sizeV)\n */\nexport function overlapFromIntersection(result: IntersectionResult): number {\n\tconst minSize = Math.min(result.sizeU, result.sizeV);\n\treturn minSize === 0 ? 0 : result.intersection / minSize;\n}\n\n/**\n * Compute Hub Promoted from intersection stats.\n * HP = intersection / min(sizeU, sizeV)\n * Note: Same formula as Overlap coefficient\n */\nexport function hubPromotedFromIntersection(\n\tresult: IntersectionResult,\n): number {\n\treturn overlapFromIntersection(result);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAsFA,SAAgB,WACf,OACA,YAAuB,MAAM,WAAW,QAAQ,QACrC;CAEX,MAAM,8BAAc,IAAI,KAAqB;CAC7C,MAAM,cAAwB,EAAE;AAEhC,MAAK,MAAM,UAAU,MAAM,SAAS,EAAE;EACrC,MAAM,QAAQ,YAAY;AAC1B,cAAY,IAAI,QAAQ,MAAM;AAC9B,cAAY,KAAK,OAAO;;CAGzB,MAAM,YAAY,YAAY;CAG9B,MAAM,UAAU,IAAI,YAAY,UAAU;AAE1C,MAAK,MAAM,UAAU,MAAM,SAAS,EAAE;EACrC,MAAM,WAAW,YAAY,IAAI,OAAO;AACxC,MAAI,aAAa,KAAA,EAAW;AAC5B,UAAQ,YAAY,MAAM,OAAO,QAAQ,UAAU;;CAIpD,IAAI,aAAa;AACjB,MAAK,IAAI,IAAI,GAAG,IAAI,WAAW,IAC9B,eAAc,QAAQ,MAAM;CAI7B,MAAM,aAAa,IAAI,YAAY,YAAY,EAAE;AACjD,MAAK,IAAI,IAAI,GAAG,IAAI,WAAW,IAC9B,YAAW,IAAI,MAAM,WAAW,MAAM,MAAM,QAAQ,MAAM;CAI3D,MAAM,aAAa,IAAI,YAAY,WAAW;CAC9C,MAAM,SAAS,IAAI,aAAa,WAAW;AAE3C,MAAK,MAAM,UAAU,MAAM,SAAS,EAAE;EACrC,MAAM,WAAW,YAAY,IAAI,OAAO;AACxC,MAAI,aAAa,KAAA,EAAW;EAE5B,MAAM,aAAa,WAAW,aAAa;EAC3C,IAAI,cAAc;AAElB,OAAK,MAAM,eAAe,MAAM,WAAW,QAAQ,UAAU,EAAE;GAC9D,MAAM,WAAW,YAAY,IAAI,YAAY;AAC7C,OAAI,aAAa,KAAA,EAAW;GAE5B,MAAM,UAAU,aAAa;AAC7B,cAAW,WAAW;AAItB,UAAO,WADM,MAAM,QAAQ,QAAQ,YAAY,EACvB,UAAU;AAElC;;;AAiBF,QAAO;EAAE,KAbc;GACtB;GACA;GACA;GACA;GACA,WAAW,MAAM,WAAW,MAAM,YAAY,MAAM,YAAY;GAChE;EAOa,UALgB;GAC7B;GACA;GACA;EAEuB;;;;;;;;;;;;;;;;;;;;;;;;;AA0BzB,SAAgB,kBACf,MACA,KACmB;CAEnB,MAAM,kBAAkB,MAAM,KAAK,IAAI,WAAW;CAClD,MAAM,kBAAkB,MAAM,KAAK,IAAI,WAAW;CAGlD,MAAM,oBAAA,WAAA,0BAAA,MAAA,IAAmB,KACvB,aAAa,aAAE,QAAQ,aAAE,KAAK,IAAI,WAAW,OAAO,EAAE,gBAAgB,CACtE,OAAO,UAAA,EAAA,mBAAA;CAGT,MAAM,oBAAA,WAAA,0BAAA,MAAA,IAAmB,KACvB,aAAa,aAAE,QAAQ,aAAE,KAAK,IAAI,WAAW,OAAO,EAAE,gBAAgB,CACtE,OAAO,UAAA,EAAA,mBAAA;AAGT,KAAI,IAAI,WAAW,KAAA,GAAW;EAC7B,MAAM,cAAc,MAAM,KAAK,IAAI,OAAO;AAK1C,SAAO;GACN,YAAY;GACZ,YAAY;GACZ,SAPK,WAAA,0BAAA,MAAA,IAAe,KACnB,aAAa,aAAE,QAAQ,aAAE,KAAK,IAAI,OAAO,OAAO,EAAE,YAAY,CAC9D,OAAO,UAAA,EAAA,eAAA;GAMR,WAAW,IAAI;GACf,WAAW,IAAI;GACf;;AAGF,QAAO;EACN,YAAY;EACZ,YAAY;EACZ,WAAW,IAAI;EACf,WAAW,IAAI;EACf;;;;;;;;;;;;;AC/LF,SAAgB,aACf,YACA,OACA,KACA,QACU;CACV,IAAI,KAAK;CACT,IAAI,KAAK;AAET,QAAO,KAAK,IAAI;EACf,MAAM,MAAM,KAAK,KAAK,OAAO,KAAK,MAAM,EAAE;EAC1C,MAAM,SAAS,WAAW,QAAQ;AAElC,MAAI,WAAW,OACd,QAAO;WACG,SAAS,OACnB,MAAK,MAAM;MAEX,MAAK;;AAIP,QAAO;;;;;;;;;;;;;AAcR,SAAgB,iBACf,YACA,YACA,GACA,GACqB;CACrB,MAAM,SAAS,WAAW,MAAM;CAChC,MAAM,OAAO,WAAW,IAAI,MAAM;CAClC,MAAM,SAAS,WAAW,MAAM;CAChC,MAAM,OAAO,WAAW,IAAI,MAAM;CAElC,MAAM,QAAQ,OAAO;CACrB,MAAM,QAAQ,OAAO;AAGrB,KAAI,UAAU,KAAK,UAAU,EAC5B,QAAO;EAAE,cAAc;EAAG;EAAO;EAAO;CAIzC,IAAI,eAAe;AAEnB,KAAI,SAAS;OAEP,IAAI,IAAI,QAAQ,IAAI,MAAM,IAE9B,KAAI,aAAa,YAAY,QAAQ,MADnB,WAAW,MAAM,EACkB,CACpD;OAKF,MAAK,IAAI,IAAI,QAAQ,IAAI,MAAM,IAE9B,KAAI,aAAa,YAAY,QAAQ,MADnB,WAAW,MAAM,EACkB,CACpD;AAKH,QAAO;EAAE;EAAc;EAAO;EAAO;;;;;;;;;;AAWtC,SAAgB,kBACf,YACA,YACA,OAKC;CACD,MAAM,IAAI,MAAM;CAChB,MAAM,gBAAgB,IAAI,YAAY,EAAE;CACxC,MAAM,SAAS,IAAI,YAAY,EAAE;CACjC,MAAM,SAAS,IAAI,YAAY,EAAE;AAEjC,MAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;EAC3B,MAAM,OAAO,MAAM;AACnB,MAAI,SAAS,KAAA,GAAW;GACvB,MAAM,CAAC,GAAG,KAAK;GACf,MAAM,SAAS,iBAAiB,YAAY,YAAY,GAAG,EAAE;AAC7D,iBAAc,KAAK,OAAO;AAC1B,UAAO,KAAK,OAAO;AACnB,UAAO,KAAK,OAAO;;;AAIrB,QAAO;EAAE;EAAe;EAAQ;EAAQ;;;;;;AAOzC,SAAgB,wBAAwB,QAAoC;CAC3E,MAAM,QAAQ,OAAO,QAAQ,OAAO,QAAQ,OAAO;AACnD,QAAO,UAAU,IAAI,IAAI,OAAO,eAAe;;;;;;AAOhD,SAAgB,uBAAuB,QAAoC;CAC1E,MAAM,cAAc,KAAK,KAAK,OAAO,QAAQ,OAAO,MAAM;AAC1D,QAAO,gBAAgB,IAAI,IAAI,OAAO,eAAe;;;;;;AAOtD,SAAgB,6BACf,QACS;CACT,MAAM,cAAc,OAAO,QAAQ,OAAO;AAC1C,QAAO,gBAAgB,IAAI,IAAK,IAAI,OAAO,eAAgB;;;;;;AAO5D,SAAgB,wBAAwB,QAAoC;CAC3E,MAAM,UAAU,KAAK,IAAI,OAAO,OAAO,OAAO,MAAM;AACpD,QAAO,YAAY,IAAI,IAAI,OAAO,eAAe;;;;;;;AAQlD,SAAgB,4BACf,QACS;AACT,QAAO,wBAAwB,OAAO"}