graphwise 1.8.1 → 1.9.1

package/dist/gpu/index.js

@@ -1,400 +1,2 @@
-//#region src/gpu/types.ts
-/**
-* Error thrown when GPU backend is requested but unavailable.
-*/
-var GPUNotAvailableError = class extends Error {
-	constructor(reason) {
-		super(`WebGPU not available: ${reason}`);
-		this.name = "GPUNotAvailableError";
-	}
-};
-//#endregion
-//#region src/gpu/csr.ts
-/**
-* 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 GPU buffers from a CSR matrix.
-*
-* Buffers are created with:
-* - rowOffsets/colIndices: STORAGE | COPY_DST
-* - values: STORAGE | COPY_DST (if present)
-*
-* @param device - GPU device to create buffers on
-* @param csr - CSR matrix to upload
-* @returns GPU buffer group
-*/
-function csrToGPUBuffers(device, csr) {
-	const rowOffsetsBuffer = device.createBuffer({
-		size: csr.rowOffsets.byteLength,
-		usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-		mappedAtCreation: false
-	});
-	device.queue.writeBuffer(rowOffsetsBuffer, 0, csr.rowOffsets);
-	const colIndicesBuffer = device.createBuffer({
-		size: csr.colIndices.byteLength,
-		usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-		mappedAtCreation: false
-	});
-	device.queue.writeBuffer(colIndicesBuffer, 0, csr.colIndices);
-	let valuesBuffer;
-	if (csr.values !== void 0) {
-		valuesBuffer = device.createBuffer({
-			size: csr.values.byteLength,
-			usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-			mappedAtCreation: false
-		});
-		device.queue.writeBuffer(valuesBuffer, 0, csr.values);
-	}
-	if (valuesBuffer !== void 0) return {
-		rowOffsets: rowOffsetsBuffer,
-		colIndices: colIndicesBuffer,
-		values: valuesBuffer,
-		nodeCount: csr.nodeCount,
-		edgeCount: csr.edgeCount
-	};
-	return {
-		rowOffsets: rowOffsetsBuffer,
-		colIndices: colIndicesBuffer,
-		nodeCount: csr.nodeCount,
-		edgeCount: csr.edgeCount
-	};
-}
-/**
-* Create a result buffer for reading compute output.
-*
-* @param device - GPU device
-* @param byteLength - Size of the buffer in bytes
-* @returns GPU buffer configured for map reading
-*/
-function createResultBuffer(device, byteLength) {
-	return device.createBuffer({
-		size: byteLength,
-		usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_READ
-	});
-}
-/**
-* Read data from a GPU buffer to CPU.
-*
-* @param device - GPU device
-* @param buffer - Buffer to read from
-* @returns ArrayBuffer containing the buffer data
-*/
-async function readBufferToCPU(device, buffer) {
-	await buffer.mapAsync(GPUMapMode.READ);
-	const data = buffer.getMappedRange().slice(0);
-	buffer.unmap();
-	return data;
-}
-//#endregion
-//#region src/gpu/detect.ts
-/**
-* Detect WebGPU availability in the current environment.
-*
-* Checks for:
-* - Browser: navigator.gpu
-* - Node.js: global GPU constructor (Node.js 21+ with --experimental-webgpu)
-* - Deno: global GPU constructor
-*
-* @returns Detection result with availability status and reason
-*/
-function detectWebGPU() {
-	if (typeof navigator !== "undefined" && "gpu" in navigator) return { available: true };
-	if (typeof globalThis !== "undefined" && "GPU" in globalThis) return { available: true };
-	const reasons = [];
-	if (typeof navigator === "undefined" && typeof globalThis === "undefined") reasons.push("no global scope detected");
-	else if (typeof navigator !== "undefined" && !("gpu" in navigator)) reasons.push("navigator.gpu not present (browser may not support WebGPU)");
-	else if (typeof globalThis !== "undefined" && !("GPU" in globalThis)) reasons.push("global GPU not present (Node.js requires v21+ with --experimental-webgpu flag)");
-	return {
-		available: false,
-		reason: reasons.length > 0 ? reasons.join("; ") : "unknown environment"
-	};
-}
-/**
-* Check if WebGPU is available (convenience function).
-*
-* @returns true if WebGPU is available, false otherwise
-*/
-function isWebGPUAvailable() {
-	return detectWebGPU().available;
-}
-/**
-* Assert that WebGPU is available, throwing an error if not.
-*
-* @throws Error if WebGPU is not available
-*/
-function assertWebGPUAvailable() {
-	const result = detectWebGPU();
-	if (!result.available) throw new Error(`WebGPU required but not available: ${result.reason ?? "unknown reason"}`);
-}
-//#endregion
-//#region src/gpu/context.ts
-/**
-* GPU context management for WebGPU compute operations.
-*
-* Provides device acquisition, buffer pooling, and shader compilation
-* with caching for efficient GPU resource management.
-*/
-/**
-* Type guard to check if an object has a WebGPU-compatible requestAdapter method.
-*/
-function hasRequestAdapter(obj) {
-	if (typeof obj !== "object" || obj === null) return false;
-	if (!("requestAdapter" in obj)) return false;
-	const descriptor = Object.getOwnPropertyDescriptor(obj, "requestAdapter");
-	return descriptor !== void 0 && typeof descriptor.value === "function";
-}
-/**
-* Manages GPU device, buffers, and compiled shaders.
-*
-* Use the singleton pattern via getGPUContext() for most use cases,
-* or create separate contexts for isolated GPU resource pools.
-*/
-var GPUContext = class {
-	device = null;
-	shaderCache = /* @__PURE__ */ new Map();
-	bufferPool = [];
-	destroyedBuffers = /* @__PURE__ */ new WeakSet();
-	/**
-	* Check if this context has an acquired GPU device.
-	*/
-	get isReady() {
-		return this.device !== null;
-	}
-	/**
-	* Get the GPU device, throwing if not acquired.
-	*/
-	getDevice() {
-		if (this.device === null) throw new Error("GPUContext not initialised. Call acquireDevice() first.");
-		return this.device;
-	}
-	/**
-	* Acquire a GPU device from the adapter.
-	*
-	* @param options - Context creation options
-	* @returns true if device was acquired successfully
-	* @throws Error if WebGPU is unavailable or device request fails
-	*/
-	async acquireDevice(options = {}) {
-		const detection = detectWebGPU();
-		if (!detection.available) throw new Error(`WebGPU unavailable: ${detection.reason ?? "unknown reason"}`);
-		let adapter = null;
-		const adapterOpts = options.powerPreference !== void 0 ? { powerPreference: options.powerPreference } : {};
-		if (typeof navigator !== "undefined" && "gpu" in navigator) adapter = await navigator.gpu.requestAdapter(adapterOpts);
-		if (adapter === null && typeof globalThis !== "undefined" && "GPU" in globalThis) {
-			const gpuDescriptor = Object.getOwnPropertyDescriptor(globalThis, "gpu");
-			if (gpuDescriptor !== void 0 && hasRequestAdapter(gpuDescriptor.value)) adapter = await gpuDescriptor.value.requestAdapter(adapterOpts);
-		}
-		if (adapter === null) throw new Error("No GPU adapter found");
-		this.device = await adapter.requestDevice();
-		this.device.lost.then((info) => {
-			console.error(`GPU device lost: ${info.message}`);
-			this.device = null;
-			this.clearCache();
-		});
-		return true;
-	}
-	/**
-	* Compile a WGSL shader, using cache if available.
-	*
-	* @param code - WGSL shader code
-	* @param key - Optional cache key (defaults to code hash)
-	* @returns Compiled shader module
-	*/
-	compileShader(code, key) {
-		const cacheKey = key ?? this.hashCode(code);
-		const cached = this.shaderCache.get(cacheKey);
-		if (cached?.code === code) return cached.module;
-		const module = this.getDevice().createShaderModule({ code });
-		this.shaderCache.set(cacheKey, {
-			module,
-			code
-		});
-		return module;
-	}
-	/**
-	* Create a GPU buffer, optionally reusing from pool.
-	*
-	* @param size - Buffer size in bytes
-	* @param usage - Buffer usage flags
-	* @returns GPU buffer
-	*/
-	createBuffer(size, usage) {
-		for (let i = 0; i < this.bufferPool.length; i++) {
-			const buffer = this.bufferPool[i];
-			if (buffer !== void 0 && !this.destroyedBuffers.has(buffer) && buffer.size >= size && (buffer.usage & usage) === usage) {
-				this.bufferPool.splice(i, 1);
-				return buffer;
-			}
-		}
-		return this.getDevice().createBuffer({
-			size,
-			usage
-		});
-	}
-	/**
-	* Return a buffer to the pool for reuse.
-	*
-	* @param buffer - Buffer to recycle
-	*/
-	recycleBuffer(buffer) {
-		if (!this.destroyedBuffers.has(buffer)) this.bufferPool.push(buffer);
-	}
-	/**
-	* Mark a buffer as destroyed (call before GPUBuffer.destroy()).
-	*
-	* @param buffer - Buffer to mark as destroyed
-	*/
-	markDestroyed(buffer) {
-		this.destroyedBuffers.add(buffer);
-	}
-	/**
-	* Create a compute pipeline from shader code.
-	*
-	* @param code - WGSL compute shader code
-	* @param entryPoint - Entry point function name
-	* @returns Compute pipeline
-	*/
-	createComputePipeline(code, entryPoint = "main") {
-		const device = this.getDevice();
-		const module = this.compileShader(code);
-		return device.createComputePipeline({
-			layout: "auto",
-			compute: {
-				module,
-				entryPoint
-			}
-		});
-	}
-	/**
-	* Create a compute pipeline asynchronously (preferred for performance).
-	*
-	* @param code - WGSL compute shader code
-	* @param entryPoint - Entry point function name
-	* @returns Promise resolving to compute pipeline
-	*/
-	async createComputePipelineAsync(code, entryPoint = "main") {
-		const device = this.getDevice();
-		const module = this.compileShader(code);
-		return device.createComputePipelineAsync({
-			layout: "auto",
-			compute: {
-				module,
-				entryPoint
-			}
-		});
-	}
-	/**
-	* Clear all cached resources.
-	*/
-	clearCache() {
-		this.shaderCache.clear();
-		for (const buffer of this.bufferPool) buffer.destroy();
-		this.bufferPool.length = 0;
-	}
-	/**
-	* Destroy the context and release all resources.
-	*/
-	destroy() {
-		this.clearCache();
-		if (this.device !== null) {
-			this.device.destroy();
-			this.device = null;
-		}
-	}
-	/**
-	* Simple string hash for cache keys.
-	*/
-	hashCode(str) {
-		let hash = 0;
-		for (let i = 0; i < str.length; i++) {
-			const char = str.charCodeAt(i);
-			hash = (hash << 5) - hash + char | 0;
-		}
-		return hash.toString(16);
-	}
-};
-var defaultContext = null;
-/**
-* Get or create the default GPU context.
-*
-* This is a lazy singleton - the device is not acquired until
-* acquireDevice() is called.
-*
-* @param options - Context creation options
-* @returns GPU context instance
-*/
-function getGPUContext(options) {
-	if (defaultContext === null || (options?.forceNew ?? false)) defaultContext = new GPUContext();
-	return defaultContext;
-}
-/**
-* Create a new isolated GPU context.
-*
-* Use this when you need separate resource pools or device management.
-*
-* @returns New GPU context instance
-*/
-function createGPUContext() {
-	return new GPUContext();
-}
-//#endregion
-export { GPUContext, GPUNotAvailableError, assertWebGPUAvailable, createGPUContext, createResultBuffer, csrToGPUBuffers, detectWebGPU, getGPUContext, graphToCSR, isWebGPUAvailable, readBufferToCPU };
-
-//# sourceMappingURL=index.js.map
+import { a as gpuSpmv, c as initGPUFromDevice, d as isWebGPUAvailable, f as csrToTypedBuffers, i as gpuPageRank, l as assertWebGPUAvailable, m as GPUNotAvailableError, n as gpuDegreeHistogram, o as withBackend, p as graphToCSR, r as gpuJaccardBatch, s as initGPU, t as gpuBfsLevels, u as detectWebGPU } from "../gpu-CHiCN0wa.js";
+export { GPUNotAvailableError, assertWebGPUAvailable, csrToTypedBuffers, detectWebGPU, gpuBfsLevels, gpuDegreeHistogram, gpuJaccardBatch, gpuPageRank, gpuSpmv, graphToCSR, initGPU, initGPUFromDevice, isWebGPUAvailable, withBackend };

package/dist/gpu/kernels/bfs/kernel.d.ts

@@ -0,0 +1,59 @@
+import { d, StorageFlag, TgpuBuffer } from 'typegpu';
+import { TypedBufferGroup } from '../../csr';
+import { GraphwiseGPURoot } from '../../root';
+/**
+ * Bind group layout for BFS kernel.
+ */
+declare const BFSLayout: import('typegpu').TgpuBindGroupLayout<{
+    rowOffsets: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+    };
+    colIndices: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+    };
+    frontier: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+    };
+    frontierSize: {
+        uniform: d.U32;
+    };
+    visited: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+        access: "mutable";
+    };
+    levels: {
+        storage: (elementCount: number) => d.WgslArray<d.I32>;
+        access: "mutable";
+    };
+    nextFrontier: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+        access: "mutable";
+    };
+    nextFrontierSize: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+        access: "mutable";
+    };
+    currentLevel: {
+        uniform: d.U32;
+    };
+    nodeCount: {
+        uniform: d.U32;
+    };
+}>;
+/**
+ * Dispatch one BFS level on GPU.
+ *
+ * @param root - TypeGPU root instance
+ * @param csrBuffers - CSR matrix as typed buffers
+ * @param frontier - Current frontier nodes (u32 array)
+ * @param frontierSize - Number of nodes in current frontier
+ * @param visited - Visited flags (u32 array, mutable)
+ * @param levels - Level assignments (i32 array, mutable)
+ * @param nextFrontier - Output next frontier (u32 array, mutable)
+ * @param nextFrontierSize - Output next frontier size (u32 array, mutable)
+ * @param currentLevel - Current BFS level (0-indexed)
+ * @param nodeCount - Total number of nodes
+ */
+export declare function dispatchBfsLevel(root: GraphwiseGPURoot, csrBuffers: TypedBufferGroup, frontier: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.u32>>> & StorageFlag, frontierSize: number, visited: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.u32>>> & StorageFlag, levels: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.i32>>> & StorageFlag, nextFrontier: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.u32>>> & StorageFlag, nextFrontierSize: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.u32>>> & StorageFlag, currentLevel: number, nodeCount: number): void;
+export { BFSLayout };
+//# sourceMappingURL=kernel.d.ts.map

package/dist/gpu/kernels/bfs/kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/bfs/kernel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAa,EAAE,CAAC,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;GAEG;AACH,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWb,CAAC;AA6CH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,gBAAgB,EACtB,UAAU,EAAE,gBAAgB,EAC5B,QAAQ,EAAE,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAC/D,WAAW,EACZ,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,WAAW,EAC7E,MAAM,EAAE,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,WAAW,EAC5E,YAAY,EAAE,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GACnE,WAAW,EACZ,gBAAgB,EAAE,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GACvE,WAAW,EACZ,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,GACf,IAAI,CAyBN;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/gpu/kernels/bfs/logic.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Pure CPU implementation of level-synchronous BFS.
+ *
+ * Processes one BFS level per iteration:
+ *   - For each node in the current frontier:
+ *     - For each neighbour:
+ *       - If not yet visited, mark visited, add to next frontier, set level
+ *
+ * This is the CPU reference implementation extracted from the WGSL kernel.
+ *
+ * @module gpu/kernels/bfs/logic
+ */
+/**
+ * Result of a BFS traversal.
+ */
+export interface BfsResult {
+    /** Level (distance from source) for each node. -1 if unreachable. */
+    readonly levels: Int32Array;
+    /** Number of BFS levels (maximum distance + 1). */
+    readonly depth: number;
+    /** Number of nodes reached. */
+    readonly nodesReached: number;
+}
+/**
+ * Process one BFS level: expand frontier and return next frontier.
+ * This mirrors one dispatch of the GPU kernel.
+ *
+ * @param rowOffsets - CSR row offsets
+ * @param colIndices - CSR column indices
+ * @param frontier - Current frontier node indices
+ * @param visited - Visited flags (mutated in place)
+ * @param levels - Level assignments (mutated in place)
+ * @param currentLevel - Current BFS level
+ * @returns Next frontier node indices
+ */
+export declare function bfsLevel(rowOffsets: Uint32Array, colIndices: Uint32Array, frontier: readonly number[], visited: Uint8Array, levels: Int32Array, currentLevel: number): number[];
+/**
+ * Full BFS from a source node.
+ *
+ * @param rowOffsets - CSR row offsets
+ * @param colIndices - CSR column indices
+ * @param nodeCount - Number of nodes
+ * @param source - Source node index
+ * @returns BFS result with levels and statistics
+ */
+export declare function bfs(rowOffsets: Uint32Array, colIndices: Uint32Array, nodeCount: number, source: number): BfsResult;
+//# sourceMappingURL=logic.d.ts.map

package/dist/gpu/kernels/bfs/logic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logic.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/bfs/logic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;GAEG;AACH,MAAM,WAAW,SAAS;IACzB,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,mDAAmD;IACnD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,+BAA+B;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CACvB,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,WAAW,EACvB,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,MAAM,GAClB,MAAM,EAAE,CAoBV;AAED;;;;;;;;GAQG;AACH,wBAAgB,GAAG,CAClB,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,WAAW,EACvB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACZ,SAAS,CAwCX"}

package/dist/gpu/kernels/bfs/logic.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=logic.unit.test.d.ts.map

package/dist/gpu/kernels/bfs/logic.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logic.unit.test.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/bfs/logic.unit.test.ts"],"names":[],"mappings":""}

package/dist/gpu/kernels/degree-histogram/kernel.d.ts

@@ -0,0 +1,32 @@
+import { d, StorageFlag, TgpuBuffer } from 'typegpu';
+import { TypedBufferGroup } from '../../csr';
+import { GraphwiseGPURoot } from '../../root';
+/**
+ * Bind group layout for degree kernel.
+ */
+declare const DegreeLayout: import('typegpu').TgpuBindGroupLayout<{
+    rowOffsets: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+    };
+    degrees: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+        access: "mutable";
+    };
+    nodeCount: {
+        uniform: d.U32;
+    };
+}>;
+/**
+ * Dispatch degree computation on GPU.
+ *
+ * Note: This computes per-node degrees. Histogram aggregation should be
+ * done on CPU or with a separate reduction kernel.
+ *
+ * @param root - TypeGPU root instance
+ * @param csrBuffers - CSR matrix as typed buffers
+ * @param degrees - Output degree array (u32, mutable)
+ * @param nodeCount - Number of nodes
+ */
+export declare function dispatchDegreeHistogram(root: GraphwiseGPURoot, csrBuffers: TypedBufferGroup, degrees: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.u32>>> & StorageFlag, nodeCount: number): void;
+export { DegreeLayout };
+//# sourceMappingURL=kernel.d.ts.map

package/dist/gpu/kernels/degree-histogram/kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/degree-histogram/kernel.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAa,EAAE,CAAC,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;GAEG;AACH,QAAA,MAAM,YAAY;;;;;;;;;;;EAIhB,CAAC;AAuBH;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACtC,IAAI,EAAE,gBAAgB,EACtB,UAAU,EAAE,gBAAgB,EAC5B,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,WAAW,EAC7E,SAAS,EAAE,MAAM,GACf,IAAI,CAYN;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/gpu/kernels/degree-histogram/logic.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Pure CPU implementation of degree histogram computation.
+ *
+ * Computes degree statistics from CSR format:
+ *   - Degree per node from rowOffsets
+ *   - Histogram of degree frequencies
+ *   - Max, total, and mean degree
+ *
+ * This is the CPU reference implementation extracted from the WGSL kernel.
+ *
+ * @module gpu/kernels/degree-histogram/logic
+ */
+/**
+ * Degree statistics for a graph.
+ */
+export interface DegreeStats {
+    /** Degree for each node (length: nodeCount) */
+    readonly degrees: Uint32Array;
+    /** Histogram of degree frequencies (length: maxDegree + 1) */
+    readonly histogram: Uint32Array;
+    /** Maximum degree in the graph */
+    readonly maxDegree: number;
+    /** Sum of all degrees */
+    readonly totalDegree: number;
+    /** Mean degree (totalDegree / nodeCount) */
+    readonly meanDegree: number;
+}
+/**
+ * Compute the degree of a single node from CSR row offsets.
+ *
+ * @param rowOffsets - CSR row offset array (length: nodeCount + 1)
+ * @param node - Node index
+ * @returns Degree (number of neighbours) for this node
+ */
+export declare function computeDegree(rowOffsets: Uint32Array, node: number): number;
+/**
+ * Build degree histogram and statistics from CSR row offsets.
+ *
+ * @param rowOffsets - CSR row offset array (length: nodeCount + 1)
+ * @param nodeCount - Number of nodes
+ * @param histogramSize - Size of histogram array (default: auto-computed as maxDegree + 1)
+ * @returns Degree statistics including histogram
+ */
+export declare function buildDegreeStats(rowOffsets: Uint32Array, nodeCount: number, histogramSize?: number): DegreeStats;
+//# sourceMappingURL=logic.d.ts.map

package/dist/gpu/kernels/degree-histogram/logic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logic.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/degree-histogram/logic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,8DAA8D;IAC9D,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;IAChC,kCAAkC;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,yBAAyB;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,4CAA4C;IAC5C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAI3E;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC/B,UAAU,EAAE,WAAW,EACvB,SAAS,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,MAAM,GACpB,WAAW,CAmCb"}

package/dist/gpu/kernels/degree-histogram/logic.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=logic.unit.test.d.ts.map

package/dist/gpu/kernels/degree-histogram/logic.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logic.unit.test.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/degree-histogram/logic.unit.test.ts"],"names":[],"mappings":""}

package/dist/gpu/kernels/jaccard/kernel.d.ts

@@ -0,0 +1,40 @@
+import { d, StorageFlag, TgpuBuffer } from 'typegpu';
+import { TypedBufferGroup } from '../../csr';
+import { GraphwiseGPURoot } from '../../root';
+/**
+ * Bind group layout for Jaccard kernel.
+ */
+declare const JaccardLayout: import('typegpu').TgpuBindGroupLayout<{
+    rowOffsets: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+    };
+    colIndices: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+    };
+    pairsU: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+    };
+    pairsV: {
+        storage: (elementCount: number) => d.WgslArray<d.U32>;
+    };
+    results: {
+        storage: (elementCount: number) => d.WgslArray<d.F32>;
+        access: "mutable";
+    };
+    pairCount: {
+        uniform: d.U32;
+    };
+}>;
+/**
+ * Dispatch batch Jaccard on GPU.
+ *
+ * @param root - TypeGPU root instance
+ * @param csrBuffers - CSR matrix as typed buffers
+ * @param pairsU - First node of each pair (u32 array)
+ * @param pairsV - Second node of each pair (u32 array)
+ * @param results - Output Jaccard coefficients (f32 array, mutable)
+ * @param pairCount - Number of pairs to compute
+ */
+export declare function dispatchJaccard(root: GraphwiseGPURoot, csrBuffers: TypedBufferGroup, pairsU: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.u32>>> & StorageFlag, pairsV: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.u32>>> & StorageFlag, results: TgpuBuffer<ReturnType<typeof d.arrayOf<typeof d.f32>>> & StorageFlag, pairCount: number): void;
+export { JaccardLayout };
+//# sourceMappingURL=kernel.d.ts.map

package/dist/gpu/kernels/jaccard/kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/jaccard/kernel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAa,EAAE,CAAC,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;GAEG;AACH,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;EAOjB,CAAC;AA8EH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC9B,IAAI,EAAE,gBAAgB,EACtB,UAAU,EAAE,gBAAgB,EAC5B,MAAM,EAAE,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,WAAW,EAC5E,MAAM,EAAE,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,WAAW,EAC5E,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,WAAW,EAC7E,SAAS,EAAE,MAAM,GACf,IAAI,CAeN;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}