graphwise 1.9.0 → 1.10.0

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

@@ -0,0 +1,87 @@
+/**
+ * Pure CPU implementation of batch neighbourhood intersection.
+ *
+ * Computes intersection size and neighbourhood sizes for multiple node pairs.
+ * This is the foundation for ALL Jaccard-family MI variants:
+ *   J(A,B) = |A ∩ B| / |A ∪ B| = intersection / (sizeA + sizeB - intersection)
+ *   Cosine(A,B) = |A ∩ B| / sqrt(|A| * |B|)
+ *   Sorensen-Dice(A,B) = 2|A ∩ B| / (|A| + |B|)
+ *   Overlap(A,B) = |A ∩ B| / min(|A|, |B|)
+ *
+ * Uses binary search optimisation: iterate smaller neighbourhood, search in larger.
+ *
+ * @module gpu/kernels/intersection/logic
+ */
+/**
+ * Result of computing intersection for a single pair.
+ */
+export interface IntersectionResult {
+    /** Size of the intersection |N(u) ∩ N(v)| */
+    readonly intersection: number;
+    /** Size of first neighbourhood |N(u)| */
+    readonly sizeU: number;
+    /** Size of second neighbourhood |N(v)| */
+    readonly sizeV: number;
+}
+/**
+ * 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]
+ */
+export declare function binarySearch(colIndices: Uint32Array, start: number, end: number, target: number): boolean;
+/**
+ * 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
+ */
+export declare function intersectionPair(rowOffsets: Uint32Array, colIndices: Uint32Array, u: number, v: number): IntersectionResult;
+/**
+ * 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
+ */
+export declare function intersectionBatch(rowOffsets: Uint32Array, colIndices: Uint32Array, pairs: readonly (readonly [number, number])[]): {
+    intersections: Uint32Array;
+    sizeUs: Uint32Array;
+    sizeVs: Uint32Array;
+};
+/**
+ * Compute Jaccard from intersection stats.
+ * J = intersection / (sizeU + sizeV - intersection)
+ */
+export declare function jaccardFromIntersection(result: IntersectionResult): number;
+/**
+ * Compute Cosine similarity from intersection stats.
+ * Cosine = intersection / sqrt(sizeU * sizeV)
+ */
+export declare function cosineFromIntersection(result: IntersectionResult): number;
+/**
+ * Compute Sorensen-Dice from intersection stats.
+ * SD = 2 * intersection / (sizeU + sizeV)
+ */
+export declare function sorensenDiceFromIntersection(result: IntersectionResult): number;
+/**
+ * Compute Overlap coefficient from intersection stats.
+ * Overlap = intersection / min(sizeU, sizeV)
+ */
+export declare function overlapFromIntersection(result: IntersectionResult): number;
+/**
+ * Compute Hub Promoted from intersection stats.
+ * HP = intersection / min(sizeU, sizeV)
+ * Note: Same formula as Overlap coefficient
+ */
+export declare function hubPromotedFromIntersection(result: IntersectionResult): number;
+//# sourceMappingURL=logic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logic.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/intersection/logic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC,6CAA6C;IAC7C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,yCAAyC;IACzC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,0CAA0C;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC3B,UAAU,EAAE,WAAW,EACvB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,GACZ,OAAO,CAkBT;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC/B,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,WAAW,EACvB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACP,kBAAkB,CAoCpB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,WAAW,EACvB,KAAK,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,GAC3C;IACF,aAAa,EAAE,WAAW,CAAC;IAC3B,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC;CACpB,CAkBA;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAG1E;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAGzE;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAC3C,MAAM,EAAE,kBAAkB,GACxB,MAAM,CAGR;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAG1E;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAC1C,MAAM,EAAE,kBAAkB,GACxB,MAAM,CAER"}

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

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

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

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

package/dist/gpu/kernels/kmeans/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * K-means clustering GPU kernel.
+ *
+ * @module gpu/kernels/kmeans
+ */
+//# sourceMappingURL=index.d.ts.map

package/dist/gpu/kernels/kmeans/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/kmeans/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

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

@@ -0,0 +1,34 @@
+import { GraphwiseGPURoot } from '../../root';
+/**
+ * K-means assignment kernel buffers.
+ *
+ * Buffer types are complex TypeGPU types that are difficult to express in TypeScript.
+ * Using `any` here is intentional to avoid verbose generic constraints.
+ */
+export interface KMeansAssignBuffers {
+    /** Points buffer (3D vectors) */
+    readonly pointsBuffer: any;
+    /** Centroids buffer (3D vectors) */
+    readonly centroidsBuffer: any;
+    /** Assignments output buffer (cluster indices) */
+    readonly assignmentsBuffer: any;
+    /** Distances output buffer (distances to assigned centroid) */
+    readonly distancesBuffer: any;
+}
+/**
+ * Dispatch K-means assignment on GPU.
+ *
+ * @param root - TypeGPU root
+ * @param pointsBuffer - Buffer of 3D points
+ * @param centroidsBuffer - Buffer of centroids
+ * @param assignmentsBuffer - Output buffer for assignments
+ * @param distancesBuffer - Output buffer for distances
+ * @param pointCount - Number of points
+ * @param k - Number of centroids
+ */
+export declare function dispatchKMeansAssign(root: GraphwiseGPURoot, pointsBuffer: any, centroidsBuffer: any, assignmentsBuffer: any, distancesBuffer: any, pointCount: number, k: number): void;
+/**
+ * Create buffers for K-means assignment.
+ */
+export declare function createKMeansAssignBuffers(root: GraphwiseGPURoot, points: readonly (readonly [number, number, number])[], centroids: readonly (readonly [number, number, number])[]): KMeansAssignBuffers;
+//# sourceMappingURL=kernel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/kmeans/kernel.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IACnC,iCAAiC;IAEjC,QAAQ,CAAC,YAAY,EAAE,GAAG,CAAC;IAC3B,oCAAoC;IAEpC,QAAQ,CAAC,eAAe,EAAE,GAAG,CAAC;IAC9B,kDAAkD;IAElD,QAAQ,CAAC,iBAAiB,EAAE,GAAG,CAAC;IAChC,+DAA+D;IAE/D,QAAQ,CAAC,eAAe,EAAE,GAAG,CAAC;CAC9B;AAkED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,gBAAgB,EAGtB,YAAY,EAAE,GAAG,EAEjB,eAAe,EAAE,GAAG,EAEpB,iBAAiB,EAAE,GAAG,EAEtB,eAAe,EAAE,GAAG,EACpB,UAAU,EAAE,MAAM,EAClB,CAAC,EAAE,MAAM,GACP,IAAI,CAuBN;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACxC,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,EACtD,SAAS,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,GACvD,mBAAmB,CAqCrB"}

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

@@ -0,0 +1,111 @@
+/**
+ * CPU reference implementation for K-means operations.
+ *
+ * K-means has two main operations:
+ * 1. Assignment: assign each point to nearest centroid
+ * 2. Update: compute new centroids from assigned points
+ *
+ * The assignment step is the most parallelizable - each point independently
+ * computes distances to all centroids and finds the minimum.
+ *
+ * @module gpu/kernels/kmeans/logic
+ */
+/**
+ * Point in K-dimensional space.
+ */
+export interface Point {
+    /** Feature coordinates */
+    readonly coords: readonly number[];
+}
+/**
+ * Centroid with accumulated sum and count for incremental update.
+ */
+export interface CentroidAccumulator {
+    /** Sum of coordinates for each dimension */
+    readonly sums: number[];
+    /** Number of points assigned to this centroid */
+    count: number;
+}
+/**
+ * Result of K-means assignment step.
+ */
+export interface KMeansAssignmentResult {
+    /** Assignment index for each point (0 to k-1) */
+    readonly assignments: Uint32Array;
+    /** Distance to assigned centroid for each point */
+    readonly distances: Float32Array;
+}
+/**
+ * Compute squared Euclidean distance between two points.
+ *
+ * @param a - First point coordinates
+ * @param b - Second point coordinates
+ * @returns Squared Euclidean distance
+ */
+export declare function squaredEuclideanDistance(a: readonly number[], b: readonly number[]): number;
+/**
+ * Compute Euclidean distance between two points.
+ *
+ * @param a - First point coordinates
+ * @param b - Second point coordinates
+ * @returns Euclidean distance
+ */
+export declare function euclideanDistance(a: readonly number[], b: readonly number[]): number;
+/**
+ * Assign each point to its nearest centroid.
+ *
+ * For each point, computes distance to all centroids and assigns to the nearest.
+ * This is the main parallelizable operation in K-means.
+ *
+ * @param points - Array of points to assign
+ * @param centroids - Array of centroid coordinates
+ * @returns Assignment result with indices and distances
+ */
+export declare function assignPointsToCentroids(points: readonly (readonly number[])[], centroids: readonly (readonly number[])[]): KMeansAssignmentResult;
+/**
+ * Update centroids based on point assignments.
+ *
+ * Computes new centroids as the mean of all assigned points.
+ *
+ * @param points - Array of points
+ * @param assignments - Assignment index for each point
+ * @param k - Number of clusters
+ * @param dimensions - Number of dimensions per point
+ * @returns New centroid coordinates
+ */
+export declare function updateCentroids(points: readonly (readonly number[])[], assignments: Uint32Array, k: number, dimensions: number): number[][];
+/**
+ * Initialize centroids using K-means++ algorithm.
+ *
+ * Selects initial centroids that are spread out, leading to faster convergence.
+ *
+ * @param points - Array of points
+ * @param k - Number of centroids to select
+ * @param rng - Random number generator (0 to 1)
+ * @returns Initial centroid coordinates
+ */
+export declare function initializeCentroidsKMeansPlusPlus(points: readonly (readonly number[])[], k: number, rng: () => number): number[][];
+/**
+ * Run full K-means clustering.
+ *
+ * @param points - Array of points to cluster
+ * @param k - Number of clusters
+ * @param options - Configuration options
+ * @returns Final assignments and centroids
+ */
+export declare function kmeans(points: readonly (readonly number[])[], k: number, options?: {
+    /** Maximum iterations (default: 100) */
+    readonly maxIterations?: number;
+    /** Convergence threshold for centroid movement (default: 1e-6) */
+    readonly tolerance?: number;
+    /** Random number generator (default: Math.random) */
+    readonly rng?: () => number;
+    /** Initial centroids (optional, uses k-means++ if not provided) */
+    readonly initialCentroids?: readonly (readonly number[])[];
+}): {
+    assignments: Uint32Array;
+    centroids: number[][];
+    iterations: number;
+    converged: boolean;
+};
+//# sourceMappingURL=logic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logic.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kernels/kmeans/logic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;GAEG;AACH,MAAM,WAAW,KAAK;IACrB,0BAA0B;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IACnC,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IACxB,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC,iDAAiD;IACjD,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,mDAAmD;IACnD,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;CACjC;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACvC,CAAC,EAAE,SAAS,MAAM,EAAE,EACpB,CAAC,EAAE,SAAS,MAAM,EAAE,GAClB,MAAM,CAOR;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAChC,CAAC,EAAE,SAAS,MAAM,EAAE,EACpB,CAAC,EAAE,SAAS,MAAM,EAAE,GAClB,MAAM,CAER;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACtC,MAAM,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACtC,SAAS,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,GACvC,sBAAsB,CAiCxB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC9B,MAAM,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACtC,WAAW,EAAE,WAAW,EACxB,CAAC,EAAE,MAAM,EACT,UAAU,EAAE,MAAM,GAChB,MAAM,EAAE,EAAE,CAqCZ;AAED;;;;;;;;;GASG;AACH,wBAAgB,iCAAiC,CAChD,MAAM,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACtC,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,MAAM,MAAM,GACf,MAAM,EAAE,EAAE,CAsEZ;AAED;;;;;;;GAOG;AACH,wBAAgB,MAAM,CACrB,MAAM,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACtC,CAAC,EAAE,MAAM,EACT,OAAO,CAAC,EAAE;IACT,wCAAwC;IACxC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,kEAAkE;IAClE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,qDAAqD;IACrD,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,mEAAmE;IACnE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC;CAC3D,GACC;IACF,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;CACnB,CAmEA"}

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

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for K-means CPU reference implementation.
+ */
+export {};
+//# sourceMappingURL=logic.unit.test.d.ts.map

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

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

package/dist/gpu/operations.d.ts

@@ -1,4 +1,5 @@
 import { NodeData, EdgeData, NodeId, ReadableGraph } from '../graph';
+import { MIVariantName } from '../ranking/mi/types';
 import { ComputeResult, GPUComputeOptions } from './types';
 /**
  * Degree statistics from histogram computation.
@@ -73,4 +74,55 @@ export declare function gpuBfsLevels<N extends NodeData, E extends EdgeData>(gra
 export declare function gpuDegreeHistogram<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, options?: GPUComputeOptions & {
     signal?: AbortSignal;
 }): Promise<ComputeResult<DegreeStats>>;
+/**
+ * Result of batch MI computation.
+ */
+export interface MIBatchResult {
+    /** MI scores for each pair */
+    readonly scores: Float32Array;
+    /** Raw intersection counts for each pair */
+    readonly intersections: Uint32Array;
+    /** Size of first neighbourhood for each pair */
+    readonly sizeUs: Uint32Array;
+    /** Size of second neighbourhood for each pair */
+    readonly sizeVs: Uint32Array;
+}
+/**
+ * Batch MI computation for multiple node pairs on GPU.
+ *
+ * For Jaccard-family variants, uses the intersection kernel for raw counts
+ * then applies the variant-specific formula on CPU.
+ *
+ * @param graph - Input graph
+ * @param pairs - Array of [u, v] node ID pairs
+ * @param variant - MI variant to compute (default: jaccard)
+ * @param options - Compute options
+ * @returns MI scores and raw intersection data for each pair
+ */
+export declare function gpuMIBatch<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, pairs: readonly (readonly [NodeId, NodeId])[], variant?: MIVariantName, options?: GPUComputeOptions & {
+    signal?: AbortSignal;
+}): Promise<ComputeResult<MIBatchResult>>;
+/**
+ * Result of K-means assignment step.
+ */
+export interface KMeansAssignResult {
+    /** Assignment index for each point (0 to k-1) */
+    readonly assignments: Uint32Array;
+    /** Squared distance to assigned centroid for each point */
+    readonly distances: Float32Array;
+}
+/**
+ * Assign points to nearest centroids using GPU.
+ *
+ * For each point, computes distance to all centroids and assigns to nearest.
+ * This is the main parallelizable operation in K-means clustering.
+ *
+ * @param points - Array of 3D points to assign
+ * @param centroids - Array of 3D centroid coordinates
+ * @param options - Compute options
+ * @returns Assignment indices and distances
+ */
+export declare function gpuKMeansAssign(points: readonly (readonly [number, number, number])[], centroids: readonly (readonly [number, number, number])[], options?: GPUComputeOptions & {
+    signal?: AbortSignal;
+}): Promise<ComputeResult<KMeansAssignResult>>;
 //# sourceMappingURL=operations.d.ts.map

package/dist/gpu/operations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../src/gpu/operations.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAUhE;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,kCAAkC;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,kCAAkC;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,qBAAqB;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sEAAsE;IACtE,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAED;;;;;;;;;GASG;AACH,wBAAsB,OAAO,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACnE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,CAAC,EAAE,YAAY,EACf,OAAO,CAAC,EAAE,iBAAiB,GAAG;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,GACpD,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CA8DtC;AAED;;;;;;GAMG;AACH,wBAAsB,WAAW,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACvE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,OAAO,CAAC,EAAE,iBAAiB,GAAG;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB,GACC,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CA+FtC;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC3E,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAClC,OAAO,CAAC,EAAE,iBAAiB,GAAG;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,GACpD,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,CA8FtC;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,YAAY,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACxE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,iBAAiB,GAAG;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,GACpD,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAsDpC;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACvC,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,QAAQ,EAElB,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,OAAO,CAAC,EAAE,iBAAiB,GAAG;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,GACpD,OAAO,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CA+ErC"}
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../src/gpu/operations.ts"],"names":[],"mappings":"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"}

package/dist/index/index.cjs

@@ -1,23 +1,26 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_gpu = require("../gpu-Y6owRVMi.cjs");
 const require_adjacency_map = require("../adjacency-map-JqBnMNkF.cjs");
 require("../graph/index.cjs");
 const require_traversal = require("../traversal/index.cjs");
 const require_priority_queue = require("../priority-queue-BIiD1L0k.cjs");
 require("../structures/index.cjs");
 const require_utils = require("../utils-CDtCcsyF.cjs");
-const require_ops = require("../ops-djAsQQSh.cjs");
-const require_expansion = require("../expansion-DaTroIyv.cjs");
-const require_kmeans = require("../kmeans-B8x9D1kt.cjs");
+const require_ops = require("../ops-paa1Nvlf.cjs");
+const require_expansion = require("../expansion--UuRowv-.cjs");
+const require_logic = require("../logic-Dbyfb_-7.cjs");
+const require_kmeans = require("../kmeans-CZ7tJFYw.cjs");
 const require_utils$1 = require("../utils/index.cjs");
-const require_jaccard = require("../jaccard-Bys9_dGW.cjs");
-const require_ranking = require("../ranking-DVvajgUZ.cjs");
+const require_jaccard = require("../jaccard-Bdw4B0i4.cjs");
+const require_ranking = require("../ranking-pe5UaxKg.cjs");
 const require_ranking_mi = require("../ranking/mi/index.cjs");
+const require_operations = require("../operations-D-RB67WP.cjs");
 const require_seeds = require("../seeds/index.cjs");
 const require_extraction = require("../extraction/index.cjs");
-require("../async/index.cjs");
+const require_gpu = require("../gpu/index.cjs");
+const require_async = require("../async/index.cjs");
 exports.AdjacencyMapGraph = require_adjacency_map.AdjacencyMapGraph;
-exports.GPUNotAvailableError = require_gpu.GPUNotAvailableError;
+exports.CSRReadableGraph = require_gpu.CSRReadableGraph;
+exports.GPUNotAvailableError = require_operations.GPUNotAvailableError;
 exports.PriorityQueue = require_priority_queue.PriorityQueue;
 exports._computeMean = require_kmeans._computeMean;
 exports.adamicAdar = require_ranking_mi.adamicAdar;
@@ -25,7 +28,7 @@ exports.adamicAdarAsync = require_ranking_mi.adamicAdarAsync;
 exports.adaptive = require_ranking_mi.adaptive;
 exports.adaptiveAsync = require_ranking_mi.adaptiveAsync;
 exports.approximateClusteringCoefficient = require_utils$1.approximateClusteringCoefficient;
-exports.assertWebGPUAvailable = require_gpu.assertWebGPUAvailable;
+exports.assertWebGPUAvailable = require_operations.assertWebGPUAvailable;
 exports.base = require_expansion.base;
 exports.baseAsync = require_expansion.baseAsync;
 exports.batchClusteringCoefficients = require_utils$1.batchClusteringCoefficients;
@@ -34,16 +37,19 @@ exports.bfs = require_traversal.bfs;
 exports.bfsWithPath = require_traversal.bfsWithPath;
 exports.collectAsyncIterable = require_utils.collectAsyncIterable;
 exports.communicability = require_ranking.communicability;
+exports.communicabilityAsync = require_ranking.communicabilityAsync;
 exports.computeJaccard = require_utils$1.computeJaccard;
 exports.computeTrussNumbers = require_extraction.computeTrussNumbers;
 exports.cosine = require_ranking_mi.cosine;
 exports.cosineAsync = require_ranking_mi.cosineAsync;
 exports.countEdgesOfType = require_utils$1.countEdgesOfType;
 exports.countNodesOfType = require_utils$1.countNodesOfType;
-exports.csrToTypedBuffers = require_gpu.csrToTypedBuffers;
+exports.createFuseBatchPriority = require_expansion.createFuseBatchPriority;
+exports.createSiftBatchPriority = require_expansion.createSiftBatchPriority;
+exports.csrToTypedBuffers = require_logic.csrToTypedBuffers;
 exports.defaultYieldStrategy = require_utils.defaultYieldStrategy;
 exports.degreeSum = require_ranking.degreeSum;
-exports.detectWebGPU = require_gpu.detectWebGPU;
+exports.detectWebGPU = require_operations.detectWebGPU;
 exports.dfs = require_traversal.dfs;
 exports.dfsPriority = require_expansion.dfsPriority;
 exports.dfsPriorityAsync = require_expansion.dfsPriorityAsync;
@@ -71,13 +77,17 @@ exports.frontierBalanced = require_expansion.frontierBalanced;
 exports.frontierBalancedAsync = require_expansion.frontierBalancedAsync;
 exports.fuse = require_expansion.fuse;
 exports.fuseAsync = require_expansion.fuseAsync;
+exports.fuseBatchPriority = require_expansion.fuseBatchPriority;
+exports.fuseWithBatchPriority = require_expansion.fuseWithBatchPriority;
 exports.getMotifName = require_extraction.getMotifName;
-exports.gpuBfsLevels = require_gpu.gpuBfsLevels;
-exports.gpuDegreeHistogram = require_gpu.gpuDegreeHistogram;
-exports.gpuJaccardBatch = require_gpu.gpuJaccardBatch;
-exports.gpuPageRank = require_gpu.gpuPageRank;
-exports.gpuSpmv = require_gpu.gpuSpmv;
-exports.graphToCSR = require_gpu.graphToCSR;
+exports.gpuBfsLevels = require_operations.gpuBfsLevels;
+exports.gpuDegreeHistogram = require_operations.gpuDegreeHistogram;
+exports.gpuJaccardBatch = require_operations.gpuJaccardBatch;
+exports.gpuKMeansAssign = require_operations.gpuKMeansAssign;
+exports.gpuMIBatch = require_operations.gpuMIBatch;
+exports.gpuPageRank = require_operations.gpuPageRank;
+exports.gpuSpmv = require_operations.gpuSpmv;
+exports.graphToCSR = require_logic.graphToCSR;
 exports.grasp = require_seeds.grasp;
 exports.hae = require_expansion.hae;
 exports.haeAsync = require_expansion.haeAsync;
@@ -86,14 +96,17 @@ exports.hubPromoted = require_ranking_mi.hubPromoted;
 exports.hubPromotedAsync = require_ranking_mi.hubPromotedAsync;
 exports.initGPU = require_gpu.initGPU;
 exports.initGPUFromDevice = require_gpu.initGPUFromDevice;
-exports.isWebGPUAvailable = require_gpu.isWebGPUAvailable;
+exports.isWebGPUAvailable = require_operations.isWebGPUAvailable;
 exports.jaccard = require_jaccard.jaccard;
 exports.jaccardArithmetic = require_ranking.jaccardArithmetic;
 exports.jaccardAsync = require_jaccard.jaccardAsync;
 exports.kHop = require_expansion.kHop;
 exports.katz = require_ranking.katz;
+exports.katzAsync = require_ranking.katzAsync;
 exports.lace = require_expansion.lace;
 exports.laceAsync = require_expansion.laceAsync;
+exports.laceBatchPriority = require_expansion.laceBatchPriority;
+exports.laceWithBatchPriority = require_expansion.laceWithBatchPriority;
 exports.localClusteringCoefficient = require_utils$1.localClusteringCoefficient;
 exports.localTypeEntropy = require_utils$1.localTypeEntropy;
 exports.maze = require_expansion.maze;
@@ -107,6 +120,8 @@ exports.zScoreNormalise = require_kmeans.normaliseFeatures;
 exports.normalisedEntropy = require_utils$1.normalisedEntropy;
 exports.notch = require_ranking_mi.notch;
 exports.notchAsync = require_ranking_mi.notchAsync;
+exports.opBatchDegree = require_ops.opBatchDegree;
+exports.opBatchNeighbours = require_ops.opBatchNeighbours;
 exports.opDegree = require_ops.opDegree;
 exports.opGetEdge = require_ops.opGetEdge;
 exports.opGetNode = require_ops.opGetNode;
@@ -117,6 +132,7 @@ exports.opYield = require_ops.opYield;
 exports.overlapCoefficient = require_ranking_mi.overlapCoefficient;
 exports.overlapCoefficientAsync = require_ranking_mi.overlapCoefficientAsync;
 exports.pagerank = require_ranking.pagerank;
+exports.pagerankAsync = require_ranking.pagerankAsync;
 exports.parse = require_ranking.parse;
 exports.parseAsync = require_ranking.parseAsync;
 exports.pipe = require_expansion.pipe;
@@ -133,6 +149,7 @@ exports.resolveSyncOp = require_ops.resolveSyncOp;
 exports.resourceAllocation = require_ranking_mi.resourceAllocation;
 exports.resourceAllocationAsync = require_ranking_mi.resourceAllocationAsync;
 exports.runAsync = require_ops.runAsync;
+exports.runBatched = require_async.runBatched;
 exports.runSync = require_ops.runSync;
 exports.sage = require_expansion.sage;
 exports.sageAsync = require_expansion.sageAsync;
@@ -142,6 +159,8 @@ exports.shannonEntropy = require_utils$1.shannonEntropy;
 exports.shortest = require_ranking.shortest;
 exports.sift = require_expansion.sift;
 exports.siftAsync = require_expansion.siftAsync;
+exports.siftBatchPriority = require_expansion.siftBatchPriority;
+exports.siftWithBatchPriority = require_expansion.siftWithBatchPriority;
 exports.skew = require_ranking_mi.skew;
 exports.skewAsync = require_ranking_mi.skewAsync;
 exports.sorensen = require_ranking_mi.sorensen;
@@ -156,4 +175,4 @@ exports.tideAsync = require_expansion.tideAsync;
 exports.warp = require_expansion.warp;
 exports.warpAsync = require_expansion.warpAsync;
 exports.widestPath = require_ranking.widestPath;
-exports.withBackend = require_gpu.withBackend;
+exports.withBackend = require_operations.withBackend;

package/dist/index/index.js

@@ -1,18 +1,20 @@
-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";
 import { t as AdjacencyMapGraph } from "../adjacency-map-BtKzcuJq.js";
 import "../graph/index.js";
 import { bfs, bfsWithPath, dfs, dfsWithPath } from "../traversal/index.js";
 import { t as PriorityQueue } from "../priority-queue-CFDd5cBg.js";
 import "../structures/index.js";
 import { n as defaultYieldStrategy, t as collectAsyncIterable } from "../utils-BodeE2Mo.js";
-import { a as opNeighbours, c as resolveAsyncOp, d as runSync, i as opHasNode, l as resolveSyncOp, n as opGetEdge, o as opProgress, r as opGetNode, s as opYield, t as opDegree, u as runAsync } from "../ops-upIi6JIi.js";
-import { A as pipe, B as base, C as tideAsync, D as reachAsync, E as reach, F as haeAsync, I as dome, L as domeAsync, M as edge, N as edgeAsync, O as sage, P as hae, R as domeHighDegree, S as tide, T as mazeAsync, V as baseAsync, _ as fuseAsync, a as dfsPriorityFn, b as lace, c as frontierBalanced, d as standardBfsAsync, f as flux, g as fuse, h as siftAsync, i as dfsPriorityAsync, j as pipeAsync, k as sageAsync, l as frontierBalancedAsync, m as sift, n as kHop, o as randomPriority, p as fluxAsync, r as dfsPriority, s as randomPriorityAsync, t as randomWalk, u as standardBfs, v as warp, w as maze, x as laceAsync, y as warpAsync, z as domeHighDegreeAsync } from "../expansion-ClDhlMK8.js";
-import { n as miniBatchKMeans, r as normaliseFeatures, t as _computeMean } from "../kmeans-DKkL9rAN.js";
+import { a as opGetNode, c as opProgress, d as resolveSyncOp, f as runAsync, i as opGetEdge, l as opYield, n as opBatchNeighbours, o as opHasNode, p as runSync, r as opDegree, s as opNeighbours, t as opBatchDegree, u as resolveAsyncOp } from "../ops-D5xZr4fV.js";
+import { A as tide, B as edge, C as fuseWithBatchPriority, D as laceAsync, E as lace, F as reachAsync, G as domeAsync, H as hae, I as sage, J as base, K as domeHighDegree, L as sageAsync, M as maze, N as mazeAsync, O as laceBatchPriority, P as reach, R as pipe, S as fuseBatchPriority, T as warpAsync, U as haeAsync, V as edgeAsync, W as dome, Y as baseAsync, _ as siftBatchPriority, a as dfsPriorityFn, b as fuse, c as frontierBalanced, d as standardBfsAsync, f as flux, g as siftAsync, h as sift, i as dfsPriorityAsync, j as tideAsync, k as laceWithBatchPriority, l as frontierBalancedAsync, m as createSiftBatchPriority, n as kHop, o as randomPriority, p as fluxAsync, q as domeHighDegreeAsync, r as dfsPriority, s as randomPriorityAsync, t as randomWalk, u as standardBfs, v as siftWithBatchPriority, w as warp, x as fuseAsync, y as createFuseBatchPriority, z as pipeAsync } from "../expansion-CZLNK6Pr.js";
+import { c as graphToCSR, s as csrToTypedBuffers } from "../logic-DyBzRg1A.js";
+import { n as miniBatchKMeans, r as normaliseFeatures, t as _computeMean } from "../kmeans-DLrlrp6i.js";
 import { approximateClusteringCoefficient, batchClusteringCoefficients, computeJaccard, countEdgesOfType, countNodesOfType, entropyFromCounts, localClusteringCoefficient, localTypeEntropy, neighbourIntersection, neighbourOverlap, neighbourSet, normalisedEntropy, shannonEntropy } from "../utils/index.js";
-import { n as jaccardAsync, t as jaccard } from "../jaccard-3rCdilwm.js";
-import { a as katz, c as jaccardArithmetic, d as shortest, f as parse, i as communicability, l as widestPath, n as randomRanking, o as betweenness, p as parseAsync, r as resistanceDistance, s as pagerank, t as hittingTime, u as degreeSum } from "../ranking-3ez5m67U.js";
+import { n as jaccardAsync, t as jaccard } from "../jaccard-BwC_NuQu.js";
+import { a as communicabilityAsync, c as betweenness, d as jaccardArithmetic, f as widestPath, g as parseAsync, h as parse, i as communicability, l as pagerank, m as shortest, n as randomRanking, o as katz, p as degreeSum, r as resistanceDistance, s as katzAsync, t as hittingTime, u as pagerankAsync } from "../ranking-DOKDBcIR.js";
 import { adamicAdar, adamicAdarAsync, adaptive, adaptiveAsync, cosine, cosineAsync, etch, etchAsync, hubPromoted, hubPromotedAsync, notch, notchAsync, overlapCoefficient, overlapCoefficientAsync, resourceAllocation, resourceAllocationAsync, scale, scaleAsync, skew, skewAsync, sorensen, sorensenAsync, span, spanAsync } from "../ranking/mi/index.js";
+import { a as gpuMIBatch, c as withBackend, d as detectWebGPU, f as isWebGPUAvailable, i as gpuKMeansAssign, l as GPUNotAvailableError, n as gpuDegreeHistogram, o as gpuPageRank, r as gpuJaccardBatch, s as gpuSpmv, t as gpuBfsLevels, u as assertWebGPUAvailable } from "../operations-D9otVlIH.js";
 import { grasp, stratified } from "../seeds/index.js";
 import { computeTrussNumbers, enumerateMotifs, enumerateMotifsWithInstances, extractEgoNetwork, extractInducedSubgraph, extractKCore, extractKTruss, filterSubgraph, getMotifName } from "../extraction/index.js";
-import "../async/index.js";
-export { AdjacencyMapGraph, GPUNotAvailableError, PriorityQueue, _computeMean, adamicAdar, adamicAdarAsync, adaptive, adaptiveAsync, approximateClusteringCoefficient, assertWebGPUAvailable, base, baseAsync, batchClusteringCoefficients, betweenness, bfs, bfsWithPath, collectAsyncIterable, communicability, computeJaccard, computeTrussNumbers, cosine, cosineAsync, countEdgesOfType, countNodesOfType, csrToTypedBuffers, defaultYieldStrategy, degreeSum, detectWebGPU, dfs, dfsPriority, dfsPriorityAsync, dfsPriorityFn, dfsWithPath, dome, domeAsync, domeHighDegree, domeHighDegreeAsync, edge, edgeAsync, entropyFromCounts, enumerateMotifs, enumerateMotifsWithInstances, etch, etchAsync, extractEgoNetwork, extractInducedSubgraph, extractKCore, extractKTruss, filterSubgraph, flux, fluxAsync, frontierBalanced, frontierBalancedAsync, fuse, fuseAsync, getMotifName, gpuBfsLevels, gpuDegreeHistogram, gpuJaccardBatch, gpuPageRank, gpuSpmv, graphToCSR, grasp, hae, haeAsync, hittingTime, hubPromoted, hubPromotedAsync, initGPU, initGPUFromDevice, isWebGPUAvailable, jaccard, jaccardArithmetic, jaccardAsync, kHop, katz, lace, laceAsync, localClusteringCoefficient, localTypeEntropy, maze, mazeAsync, miniBatchKMeans, neighbourIntersection, neighbourOverlap, neighbourSet, normaliseFeatures, normaliseFeatures as zScoreNormalise, normalisedEntropy, notch, notchAsync, opDegree, opGetEdge, opGetNode, opHasNode, opNeighbours, opProgress, opYield, overlapCoefficient, overlapCoefficientAsync, pagerank, parse, parseAsync, pipe, pipeAsync, randomPriority, randomPriorityAsync, randomRanking, randomWalk, reach, reachAsync, resistanceDistance, resolveAsyncOp, resolveSyncOp, resourceAllocation, resourceAllocationAsync, runAsync, runSync, sage, sageAsync, scale, scaleAsync, shannonEntropy, shortest, sift, siftAsync, skew, skewAsync, sorensen, sorensenAsync, span, spanAsync, standardBfs, standardBfsAsync, stratified, tide, tideAsync, warp, warpAsync, widestPath, withBackend };
+import { CSRReadableGraph, initGPU, initGPUFromDevice } from "../gpu/index.js";
+import { runBatched } from "../async/index.js";
+export { AdjacencyMapGraph, CSRReadableGraph, GPUNotAvailableError, PriorityQueue, _computeMean, adamicAdar, adamicAdarAsync, adaptive, adaptiveAsync, approximateClusteringCoefficient, assertWebGPUAvailable, base, baseAsync, batchClusteringCoefficients, betweenness, bfs, bfsWithPath, collectAsyncIterable, communicability, communicabilityAsync, computeJaccard, computeTrussNumbers, cosine, cosineAsync, countEdgesOfType, countNodesOfType, createFuseBatchPriority, createSiftBatchPriority, csrToTypedBuffers, defaultYieldStrategy, degreeSum, detectWebGPU, dfs, dfsPriority, dfsPriorityAsync, dfsPriorityFn, dfsWithPath, dome, domeAsync, domeHighDegree, domeHighDegreeAsync, edge, edgeAsync, entropyFromCounts, enumerateMotifs, enumerateMotifsWithInstances, etch, etchAsync, extractEgoNetwork, extractInducedSubgraph, extractKCore, extractKTruss, filterSubgraph, flux, fluxAsync, frontierBalanced, frontierBalancedAsync, fuse, fuseAsync, fuseBatchPriority, fuseWithBatchPriority, getMotifName, gpuBfsLevels, gpuDegreeHistogram, gpuJaccardBatch, gpuKMeansAssign, gpuMIBatch, gpuPageRank, gpuSpmv, graphToCSR, grasp, hae, haeAsync, hittingTime, hubPromoted, hubPromotedAsync, initGPU, initGPUFromDevice, isWebGPUAvailable, jaccard, jaccardArithmetic, jaccardAsync, kHop, katz, katzAsync, lace, laceAsync, laceBatchPriority, laceWithBatchPriority, localClusteringCoefficient, localTypeEntropy, maze, mazeAsync, miniBatchKMeans, neighbourIntersection, neighbourOverlap, neighbourSet, normaliseFeatures, normaliseFeatures as zScoreNormalise, normalisedEntropy, notch, notchAsync, opBatchDegree, opBatchNeighbours, opDegree, opGetEdge, opGetNode, opHasNode, opNeighbours, opProgress, opYield, overlapCoefficient, overlapCoefficientAsync, pagerank, pagerankAsync, parse, parseAsync, pipe, pipeAsync, randomPriority, randomPriorityAsync, randomRanking, randomWalk, reach, reachAsync, resistanceDistance, resolveAsyncOp, resolveSyncOp, resourceAllocation, resourceAllocationAsync, runAsync, runBatched, runSync, sage, sageAsync, scale, scaleAsync, shannonEntropy, shortest, sift, siftAsync, siftBatchPriority, siftWithBatchPriority, skew, skewAsync, sorensen, sorensenAsync, span, spanAsync, standardBfs, standardBfsAsync, stratified, tide, tideAsync, warp, warpAsync, widestPath, withBackend };

package/dist/{jaccard-Bys9_dGW.cjs → jaccard-Bdw4B0i4.cjs}

@@ -47,4 +47,4 @@ Object.defineProperty(exports, "jaccardAsync", {
 	}
 });
 
-//# sourceMappingURL=jaccard-Bys9_dGW.cjs.map
+//# sourceMappingURL=jaccard-Bdw4B0i4.cjs.map

package/dist/{jaccard-Bys9_dGW.cjs.map → jaccard-Bdw4B0i4.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"jaccard-Bys9_dGW.cjs","names":[],"sources":["../src/ranking/mi/jaccard.ts"],"sourcesContent":["/**\n * Jaccard similarity coefficient for edge salience.\n *\n * Measures overlap between neighbourhoods of connected nodes:\n * MI(u,v) = |N(u) ∩ N(v)| / |N(u) ∪ N(v)|\n *\n * Range: [0, 1]\n * - 0: No shared neighbours (low salience)\n * - 1: Identical neighbourhoods (high salience)\n */\n\nimport type { NodeId, NodeData, EdgeData, ReadableGraph } from \"../../graph\";\nimport type { AsyncReadableGraph } from \"../../graph/async-interfaces\";\nimport { computeJaccard } from \"../../utils\";\nimport { collectAsyncIterable } from \"../../async/utils\";\nimport type { MIConfig } from \"./types\";\n\n/**\n * Compute Jaccard similarity between neighbourhoods of two nodes.\n *\n * @param graph - Source graph\n * @param source - Source node ID\n * @param target - Target node ID\n * @param config - Optional configuration\n * @returns Jaccard coefficient in [0, 1]\n */\nexport function jaccard<N extends NodeData, E extends EdgeData>(\n\tgraph: ReadableGraph<N, E>,\n\tsource: NodeId,\n\ttarget: NodeId,\n\tconfig?: MIConfig,\n): number {\n\tconst { epsilon = 1e-10 } = config ?? {};\n\n\tconst {\n\t\tjaccard: jaccardScore,\n\t\tsourceNeighbours,\n\t\ttargetNeighbours,\n\t} = computeJaccard(graph, source, target);\n\n\t// Return 0 only when the union is empty (no neighbours on either side)\n\tif (sourceNeighbours.size === 0 && targetNeighbours.size === 0) {\n\t\treturn 0;\n\t}\n\n\t// Apply epsilon floor for numerical stability\n\treturn Math.max(epsilon, jaccardScore);\n}\n\n/**\n * Async variant of Jaccard similarity for use with async graph data sources.\n *\n * Fetches both neighbourhoods concurrently, then applies the same formula.\n */\nexport async function jaccardAsync<N extends NodeData, E extends EdgeData>(\n\tgraph: AsyncReadableGraph<N, E>,\n\tsource: NodeId,\n\ttarget: NodeId,\n\tconfig?: MIConfig,\n): Promise<number> {\n\tconst { epsilon = 1e-10 } = config ?? {};\n\n\t// Fetch both neighbourhoods in parallel\n\tconst [sourceNeighboursArr, targetNeighboursArr] = await Promise.all([\n\t\tcollectAsyncIterable(graph.neighbours(source)),\n\t\tcollectAsyncIterable(graph.neighbours(target)),\n\t]);\n\n\tconst srcSet = new Set(sourceNeighboursArr.filter((n) => n !== target));\n\tconst tgtSet = new Set(targetNeighboursArr.filter((n) => n !== source));\n\n\t// Return 0 only when the union is empty (no neighbours on either side)\n\tif (srcSet.size === 0 && tgtSet.size === 0) {\n\t\treturn 0;\n\t}\n\n\t// Compute intersection and union sizes\n\tlet intersection = 0;\n\tfor (const n of srcSet) {\n\t\tif (tgtSet.has(n)) intersection++;\n\t}\n\tconst union = srcSet.size + tgtSet.size - intersection;\n\n\tconst jaccardScore = union > 0 ? intersection / union : 0;\n\n\treturn Math.max(epsilon, jaccardScore);\n}\n"],"mappings":";;;;;;;;;;;;AA0BA,SAAgB,QACf,OACA,QACA,QACA,QACS;CACT,MAAM,EAAE,UAAU,UAAU,UAAU,EAAE;CAExC,MAAM,EACL,SAAS,cACT,kBACA,qBACG,gBAAA,eAAe,OAAO,QAAQ,OAAO;AAGzC,KAAI,iBAAiB,SAAS,KAAK,iBAAiB,SAAS,EAC5D,QAAO;AAIR,QAAO,KAAK,IAAI,SAAS,aAAa;;;;;;;AAQvC,eAAsB,aACrB,OACA,QACA,QACA,QACkB;CAClB,MAAM,EAAE,UAAU,UAAU,UAAU,EAAE;CAGxC,MAAM,CAAC,qBAAqB,uBAAuB,MAAM,QAAQ,IAAI,CACpE,cAAA,qBAAqB,MAAM,WAAW,OAAO,CAAC,EAC9C,cAAA,qBAAqB,MAAM,WAAW,OAAO,CAAC,CAC9C,CAAC;CAEF,MAAM,SAAS,IAAI,IAAI,oBAAoB,QAAQ,MAAM,MAAM,OAAO,CAAC;CACvE,MAAM,SAAS,IAAI,IAAI,oBAAoB,QAAQ,MAAM,MAAM,OAAO,CAAC;AAGvE,KAAI,OAAO,SAAS,KAAK,OAAO,SAAS,EACxC,QAAO;CAIR,IAAI,eAAe;AACnB,MAAK,MAAM,KAAK,OACf,KAAI,OAAO,IAAI,EAAE,CAAE;CAEpB,MAAM,QAAQ,OAAO,OAAO,OAAO,OAAO;CAE1C,MAAM,eAAe,QAAQ,IAAI,eAAe,QAAQ;AAExD,QAAO,KAAK,IAAI,SAAS,aAAa"}
+{"version":3,"file":"jaccard-Bdw4B0i4.cjs","names":[],"sources":["../src/ranking/mi/jaccard.ts"],"sourcesContent":["/**\n * Jaccard similarity coefficient for edge salience.\n *\n * Measures overlap between neighbourhoods of connected nodes:\n * MI(u,v) = |N(u) ∩ N(v)| / |N(u) ∪ N(v)|\n *\n * Range: [0, 1]\n * - 0: No shared neighbours (low salience)\n * - 1: Identical neighbourhoods (high salience)\n */\n\nimport type { NodeId, NodeData, EdgeData, ReadableGraph } from \"../../graph\";\nimport type { AsyncReadableGraph } from \"../../graph/async-interfaces\";\nimport { computeJaccard } from \"../../utils\";\nimport { collectAsyncIterable } from \"../../async/utils\";\nimport type { MIConfig } from \"./types\";\n\n/**\n * Compute Jaccard similarity between neighbourhoods of two nodes.\n *\n * @param graph - Source graph\n * @param source - Source node ID\n * @param target - Target node ID\n * @param config - Optional configuration\n * @returns Jaccard coefficient in [0, 1]\n */\nexport function jaccard<N extends NodeData, E extends EdgeData>(\n\tgraph: ReadableGraph<N, E>,\n\tsource: NodeId,\n\ttarget: NodeId,\n\tconfig?: MIConfig,\n): number {\n\tconst { epsilon = 1e-10 } = config ?? {};\n\n\tconst {\n\t\tjaccard: jaccardScore,\n\t\tsourceNeighbours,\n\t\ttargetNeighbours,\n\t} = computeJaccard(graph, source, target);\n\n\t// Return 0 only when the union is empty (no neighbours on either side)\n\tif (sourceNeighbours.size === 0 && targetNeighbours.size === 0) {\n\t\treturn 0;\n\t}\n\n\t// Apply epsilon floor for numerical stability\n\treturn Math.max(epsilon, jaccardScore);\n}\n\n/**\n * Async variant of Jaccard similarity for use with async graph data sources.\n *\n * Fetches both neighbourhoods concurrently, then applies the same formula.\n */\nexport async function jaccardAsync<N extends NodeData, E extends EdgeData>(\n\tgraph: AsyncReadableGraph<N, E>,\n\tsource: NodeId,\n\ttarget: NodeId,\n\tconfig?: MIConfig,\n): Promise<number> {\n\tconst { epsilon = 1e-10 } = config ?? {};\n\n\t// Fetch both neighbourhoods in parallel\n\tconst [sourceNeighboursArr, targetNeighboursArr] = await Promise.all([\n\t\tcollectAsyncIterable(graph.neighbours(source)),\n\t\tcollectAsyncIterable(graph.neighbours(target)),\n\t]);\n\n\tconst srcSet = new Set(sourceNeighboursArr.filter((n) => n !== target));\n\tconst tgtSet = new Set(targetNeighboursArr.filter((n) => n !== source));\n\n\t// Return 0 only when the union is empty (no neighbours on either side)\n\tif (srcSet.size === 0 && tgtSet.size === 0) {\n\t\treturn 0;\n\t}\n\n\t// Compute intersection and union sizes\n\tlet intersection = 0;\n\tfor (const n of srcSet) {\n\t\tif (tgtSet.has(n)) intersection++;\n\t}\n\tconst union = srcSet.size + tgtSet.size - intersection;\n\n\tconst jaccardScore = union > 0 ? intersection / union : 0;\n\n\treturn Math.max(epsilon, jaccardScore);\n}\n"],"mappings":";;;;;;;;;;;;AA0BA,SAAgB,QACf,OACA,QACA,QACA,QACS;CACT,MAAM,EAAE,UAAU,UAAU,UAAU,EAAE;CAExC,MAAM,EACL,SAAS,cACT,kBACA,qBACG,gBAAA,eAAe,OAAO,QAAQ,OAAO;AAGzC,KAAI,iBAAiB,SAAS,KAAK,iBAAiB,SAAS,EAC5D,QAAO;AAIR,QAAO,KAAK,IAAI,SAAS,aAAa;;;;;;;AAQvC,eAAsB,aACrB,OACA,QACA,QACA,QACkB;CAClB,MAAM,EAAE,UAAU,UAAU,UAAU,EAAE;CAGxC,MAAM,CAAC,qBAAqB,uBAAuB,MAAM,QAAQ,IAAI,CACpE,cAAA,qBAAqB,MAAM,WAAW,OAAO,CAAC,EAC9C,cAAA,qBAAqB,MAAM,WAAW,OAAO,CAAC,CAC9C,CAAC;CAEF,MAAM,SAAS,IAAI,IAAI,oBAAoB,QAAQ,MAAM,MAAM,OAAO,CAAC;CACvE,MAAM,SAAS,IAAI,IAAI,oBAAoB,QAAQ,MAAM,MAAM,OAAO,CAAC;AAGvE,KAAI,OAAO,SAAS,KAAK,OAAO,SAAS,EACxC,QAAO;CAIR,IAAI,eAAe;AACnB,MAAK,MAAM,KAAK,OACf,KAAI,OAAO,IAAI,EAAE,CAAE;CAEpB,MAAM,QAAQ,OAAO,OAAO,OAAO,OAAO;CAE1C,MAAM,eAAe,QAAQ,IAAI,eAAe,QAAQ;AAExD,QAAO,KAAK,IAAI,SAAS,aAAa"}

package/dist/{jaccard-3rCdilwm.js → jaccard-BwC_NuQu.js}

@@ -36,4 +36,4 @@ async function jaccardAsync(graph, source, target, config) {
 //#endregion
 export { jaccardAsync as n, jaccard as t };
 
-//# sourceMappingURL=jaccard-3rCdilwm.js.map
+//# sourceMappingURL=jaccard-BwC_NuQu.js.map

package/dist/{jaccard-3rCdilwm.js.map → jaccard-BwC_NuQu.js.map}

@@ -1 +1 @@
-{"version":3,"file":"jaccard-3rCdilwm.js","names":[],"sources":["../src/ranking/mi/jaccard.ts"],"sourcesContent":["/**\n * Jaccard similarity coefficient for edge salience.\n *\n * Measures overlap between neighbourhoods of connected nodes:\n * MI(u,v) = |N(u) ∩ N(v)| / |N(u) ∪ N(v)|\n *\n * Range: [0, 1]\n * - 0: No shared neighbours (low salience)\n * - 1: Identical neighbourhoods (high salience)\n */\n\nimport type { NodeId, NodeData, EdgeData, ReadableGraph } from \"../../graph\";\nimport type { AsyncReadableGraph } from \"../../graph/async-interfaces\";\nimport { computeJaccard } from \"../../utils\";\nimport { collectAsyncIterable } from \"../../async/utils\";\nimport type { MIConfig } from \"./types\";\n\n/**\n * Compute Jaccard similarity between neighbourhoods of two nodes.\n *\n * @param graph - Source graph\n * @param source - Source node ID\n * @param target - Target node ID\n * @param config - Optional configuration\n * @returns Jaccard coefficient in [0, 1]\n */\nexport function jaccard<N extends NodeData, E extends EdgeData>(\n\tgraph: ReadableGraph<N, E>,\n\tsource: NodeId,\n\ttarget: NodeId,\n\tconfig?: MIConfig,\n): number {\n\tconst { epsilon = 1e-10 } = config ?? {};\n\n\tconst {\n\t\tjaccard: jaccardScore,\n\t\tsourceNeighbours,\n\t\ttargetNeighbours,\n\t} = computeJaccard(graph, source, target);\n\n\t// Return 0 only when the union is empty (no neighbours on either side)\n\tif (sourceNeighbours.size === 0 && targetNeighbours.size === 0) {\n\t\treturn 0;\n\t}\n\n\t// Apply epsilon floor for numerical stability\n\treturn Math.max(epsilon, jaccardScore);\n}\n\n/**\n * Async variant of Jaccard similarity for use with async graph data sources.\n *\n * Fetches both neighbourhoods concurrently, then applies the same formula.\n */\nexport async function jaccardAsync<N extends NodeData, E extends EdgeData>(\n\tgraph: AsyncReadableGraph<N, E>,\n\tsource: NodeId,\n\ttarget: NodeId,\n\tconfig?: MIConfig,\n): Promise<number> {\n\tconst { epsilon = 1e-10 } = config ?? {};\n\n\t// Fetch both neighbourhoods in parallel\n\tconst [sourceNeighboursArr, targetNeighboursArr] = await Promise.all([\n\t\tcollectAsyncIterable(graph.neighbours(source)),\n\t\tcollectAsyncIterable(graph.neighbours(target)),\n\t]);\n\n\tconst srcSet = new Set(sourceNeighboursArr.filter((n) => n !== target));\n\tconst tgtSet = new Set(targetNeighboursArr.filter((n) => n !== source));\n\n\t// Return 0 only when the union is empty (no neighbours on either side)\n\tif (srcSet.size === 0 && tgtSet.size === 0) {\n\t\treturn 0;\n\t}\n\n\t// Compute intersection and union sizes\n\tlet intersection = 0;\n\tfor (const n of srcSet) {\n\t\tif (tgtSet.has(n)) intersection++;\n\t}\n\tconst union = srcSet.size + tgtSet.size - intersection;\n\n\tconst jaccardScore = union > 0 ? intersection / union : 0;\n\n\treturn Math.max(epsilon, jaccardScore);\n}\n"],"mappings":";;;;;;;;;;;;AA0BA,SAAgB,QACf,OACA,QACA,QACA,QACS;CACT,MAAM,EAAE,UAAU,UAAU,UAAU,EAAE;CAExC,MAAM,EACL,SAAS,cACT,kBACA,qBACG,eAAe,OAAO,QAAQ,OAAO;AAGzC,KAAI,iBAAiB,SAAS,KAAK,iBAAiB,SAAS,EAC5D,QAAO;AAIR,QAAO,KAAK,IAAI,SAAS,aAAa;;;;;;;AAQvC,eAAsB,aACrB,OACA,QACA,QACA,QACkB;CAClB,MAAM,EAAE,UAAU,UAAU,UAAU,EAAE;CAGxC,MAAM,CAAC,qBAAqB,uBAAuB,MAAM,QAAQ,IAAI,CACpE,qBAAqB,MAAM,WAAW,OAAO,CAAC,EAC9C,qBAAqB,MAAM,WAAW,OAAO,CAAC,CAC9C,CAAC;CAEF,MAAM,SAAS,IAAI,IAAI,oBAAoB,QAAQ,MAAM,MAAM,OAAO,CAAC;CACvE,MAAM,SAAS,IAAI,IAAI,oBAAoB,QAAQ,MAAM,MAAM,OAAO,CAAC;AAGvE,KAAI,OAAO,SAAS,KAAK,OAAO,SAAS,EACxC,QAAO;CAIR,IAAI,eAAe;AACnB,MAAK,MAAM,KAAK,OACf,KAAI,OAAO,IAAI,EAAE,CAAE;CAEpB,MAAM,QAAQ,OAAO,OAAO,OAAO,OAAO;CAE1C,MAAM,eAAe,QAAQ,IAAI,eAAe,QAAQ;AAExD,QAAO,KAAK,IAAI,SAAS,aAAa"}
+{"version":3,"file":"jaccard-BwC_NuQu.js","names":[],"sources":["../src/ranking/mi/jaccard.ts"],"sourcesContent":["/**\n * Jaccard similarity coefficient for edge salience.\n *\n * Measures overlap between neighbourhoods of connected nodes:\n * MI(u,v) = |N(u) ∩ N(v)| / |N(u) ∪ N(v)|\n *\n * Range: [0, 1]\n * - 0: No shared neighbours (low salience)\n * - 1: Identical neighbourhoods (high salience)\n */\n\nimport type { NodeId, NodeData, EdgeData, ReadableGraph } from \"../../graph\";\nimport type { AsyncReadableGraph } from \"../../graph/async-interfaces\";\nimport { computeJaccard } from \"../../utils\";\nimport { collectAsyncIterable } from \"../../async/utils\";\nimport type { MIConfig } from \"./types\";\n\n/**\n * Compute Jaccard similarity between neighbourhoods of two nodes.\n *\n * @param graph - Source graph\n * @param source - Source node ID\n * @param target - Target node ID\n * @param config - Optional configuration\n * @returns Jaccard coefficient in [0, 1]\n */\nexport function jaccard<N extends NodeData, E extends EdgeData>(\n\tgraph: ReadableGraph<N, E>,\n\tsource: NodeId,\n\ttarget: NodeId,\n\tconfig?: MIConfig,\n): number {\n\tconst { epsilon = 1e-10 } = config ?? {};\n\n\tconst {\n\t\tjaccard: jaccardScore,\n\t\tsourceNeighbours,\n\t\ttargetNeighbours,\n\t} = computeJaccard(graph, source, target);\n\n\t// Return 0 only when the union is empty (no neighbours on either side)\n\tif (sourceNeighbours.size === 0 && targetNeighbours.size === 0) {\n\t\treturn 0;\n\t}\n\n\t// Apply epsilon floor for numerical stability\n\treturn Math.max(epsilon, jaccardScore);\n}\n\n/**\n * Async variant of Jaccard similarity for use with async graph data sources.\n *\n * Fetches both neighbourhoods concurrently, then applies the same formula.\n */\nexport async function jaccardAsync<N extends NodeData, E extends EdgeData>(\n\tgraph: AsyncReadableGraph<N, E>,\n\tsource: NodeId,\n\ttarget: NodeId,\n\tconfig?: MIConfig,\n): Promise<number> {\n\tconst { epsilon = 1e-10 } = config ?? {};\n\n\t// Fetch both neighbourhoods in parallel\n\tconst [sourceNeighboursArr, targetNeighboursArr] = await Promise.all([\n\t\tcollectAsyncIterable(graph.neighbours(source)),\n\t\tcollectAsyncIterable(graph.neighbours(target)),\n\t]);\n\n\tconst srcSet = new Set(sourceNeighboursArr.filter((n) => n !== target));\n\tconst tgtSet = new Set(targetNeighboursArr.filter((n) => n !== source));\n\n\t// Return 0 only when the union is empty (no neighbours on either side)\n\tif (srcSet.size === 0 && tgtSet.size === 0) {\n\t\treturn 0;\n\t}\n\n\t// Compute intersection and union sizes\n\tlet intersection = 0;\n\tfor (const n of srcSet) {\n\t\tif (tgtSet.has(n)) intersection++;\n\t}\n\tconst union = srcSet.size + tgtSet.size - intersection;\n\n\tconst jaccardScore = union > 0 ? intersection / union : 0;\n\n\treturn Math.max(epsilon, jaccardScore);\n}\n"],"mappings":";;;;;;;;;;;;AA0BA,SAAgB,QACf,OACA,QACA,QACA,QACS;CACT,MAAM,EAAE,UAAU,UAAU,UAAU,EAAE;CAExC,MAAM,EACL,SAAS,cACT,kBACA,qBACG,eAAe,OAAO,QAAQ,OAAO;AAGzC,KAAI,iBAAiB,SAAS,KAAK,iBAAiB,SAAS,EAC5D,QAAO;AAIR,QAAO,KAAK,IAAI,SAAS,aAAa;;;;;;;AAQvC,eAAsB,aACrB,OACA,QACA,QACA,QACkB;CAClB,MAAM,EAAE,UAAU,UAAU,UAAU,EAAE;CAGxC,MAAM,CAAC,qBAAqB,uBAAuB,MAAM,QAAQ,IAAI,CACpE,qBAAqB,MAAM,WAAW,OAAO,CAAC,EAC9C,qBAAqB,MAAM,WAAW,OAAO,CAAC,CAC9C,CAAC;CAEF,MAAM,SAAS,IAAI,IAAI,oBAAoB,QAAQ,MAAM,MAAM,OAAO,CAAC;CACvE,MAAM,SAAS,IAAI,IAAI,oBAAoB,QAAQ,MAAM,MAAM,OAAO,CAAC;AAGvE,KAAI,OAAO,SAAS,KAAK,OAAO,SAAS,EACxC,QAAO;CAIR,IAAI,eAAe;AACnB,MAAK,MAAM,KAAK,OACf,KAAI,OAAO,IAAI,EAAE,CAAE;CAEpB,MAAM,QAAQ,OAAO,OAAO,OAAO,OAAO;CAE1C,MAAM,eAAe,QAAQ,IAAI,eAAe,QAAQ;AAExD,QAAO,KAAK,IAAI,SAAS,aAAa"}