graphwise 1.2.0 → 1.3.1

package/dist/index/index.js

@@ -2,8 +2,8 @@ import { AdjacencyMapGraph } from "../graph/index.js";
 import { bfs, bfsWithPath, dfs, dfsWithPath } from "../traversal/index.js";
 import { PriorityQueue } from "../structures/index.js";
 import { n as miniBatchKMeans, r as normaliseFeatures, t as _computeMean } from "../kmeans-87ExSUNZ.js";
+import { approximateClusteringCoefficient, batchClusteringCoefficients, countEdgesOfType, countNodesOfType, entropyFromCounts, localClusteringCoefficient, localTypeEntropy, neighbourIntersection, neighbourOverlap, neighbourSet, normalisedEntropy, shannonEntropy } from "../utils/index.js";
 import { grasp, stratified } from "../seeds/index.js";
-import { approximateClusteringCoefficient, batchClusteringCoefficients, entropyFromCounts, localClusteringCoefficient, localTypeEntropy, normalisedEntropy, shannonEntropy } from "../utils/index.js";
 import { GPUContext, GPUNotAvailableError, assertWebGPUAvailable, createGPUContext, createResultBuffer, csrToGPUBuffers, detectWebGPU, getGPUContext, graphToCSR, isWebGPUAvailable, readBufferToCPU } from "../gpu/index.js";
 //#region src/expansion/base.ts
 /**
@@ -298,15 +298,9 @@ function edge(graph, seeds, config) {
 */
 function jaccard(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	const sourceNeighbours = new Set(graph.neighbours(source));
-	const targetNeighbours = new Set(graph.neighbours(target));
-	sourceNeighbours.delete(target);
-	targetNeighbours.delete(source);
-	let intersectionSize = 0;
-	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) intersectionSize++;
-	const unionSize = sourceNeighbours.size + targetNeighbours.size - intersectionSize;
-	if (unionSize === 0) return 0;
-	const score = intersectionSize / unionSize;
+	const { intersection, union } = neighbourOverlap(neighbourSet(graph, source, target), neighbourSet(graph, target, source));
+	if (union === 0) return 0;
+	const score = intersection / union;
 	return Math.max(epsilon, score);
 }
 //#endregion
@@ -686,19 +680,14 @@ function computePathSalience(graph, path, mi, epsilon) {
 */
 function adamicAdar(graph, source, target, config) {
 	const { epsilon = 1e-10, normalise = true } = config ?? {};
-	const sourceNeighbours = new Set(graph.neighbours(source));
-	const targetNeighbours = new Set(graph.neighbours(target));
-	sourceNeighbours.delete(target);
-	targetNeighbours.delete(source);
+	const commonNeighbours = neighbourIntersection(neighbourSet(graph, source, target), neighbourSet(graph, target, source));
 	let score = 0;
-	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) {
+	for (const neighbour of commonNeighbours) {
 		const degree = graph.degree(neighbour);
-		if (degree > 1) score += 1 / Math.log(degree);
+		score += 1 / Math.log(degree + 1);
 	}
-	if (normalise) {
-		const commonCount = sourceNeighbours.size < targetNeighbours.size ? sourceNeighbours.size : targetNeighbours.size;
-		if (commonCount === 0) return 0;
-		const maxScore = commonCount / Math.log(2);
+	if (normalise && commonNeighbours.size > 0) {
+		const maxScore = commonNeighbours.size / Math.log(2);
 		score = score / maxScore;
 	}
 	return Math.max(epsilon, score);
@@ -710,22 +699,15 @@ function adamicAdar(graph, source, target, config) {
 */
 function scale(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	const sourceNeighbours = new Set(graph.neighbours(source));
-	const targetNeighbours = new Set(graph.neighbours(target));
-	sourceNeighbours.delete(target);
-	targetNeighbours.delete(source);
-	const sourceDegree = sourceNeighbours.size;
-	const targetDegree = targetNeighbours.size;
-	let intersectionSize = 0;
-	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) intersectionSize++;
-	const unionSize = sourceDegree + targetDegree - intersectionSize;
-	const jaccard = unionSize > 0 ? intersectionSize / unionSize : 0;
-	const minDegree = Math.min(sourceDegree, targetDegree);
-	const maxDegree = Math.max(sourceDegree, targetDegree);
-	const degreeRatio = maxDegree > 0 ? minDegree / maxDegree : 0;
-	if (jaccard + degreeRatio === 0) return epsilon;
-	const score = 2 * jaccard * degreeRatio / (jaccard + degreeRatio);
-	return Math.max(epsilon, Math.min(1, score));
+	const { intersection, union } = neighbourOverlap(neighbourSet(graph, source, target), neighbourSet(graph, target, source));
+	const jaccard = union > 0 ? intersection / union : 0;
+	const n = graph.nodeCount;
+	const m = graph.edgeCount;
+	const densityNormaliser = graph.directed ? n * (n - 1) : 2 * n * (n - 1);
+	const density = densityNormaliser > 0 ? m / densityNormaliser : 0;
+	if (density === 0) return epsilon;
+	const score = jaccard / density;
+	return Math.max(epsilon, score);
 }
 //#endregion
 //#region src/ranking/mi/skew.ts
@@ -734,23 +716,15 @@ function scale(graph, source, target, config) {
 */
 function skew(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	const sourceNeighbours = new Set(graph.neighbours(source));
-	const targetNeighbours = new Set(graph.neighbours(target));
-	sourceNeighbours.delete(target);
-	targetNeighbours.delete(source);
-	let weightedIntersection = 0;
-	let commonCount = 0;
-	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) {
-		commonCount++;
-		const degree = graph.degree(neighbour);
-		if (degree > 1) weightedIntersection += 1 / Math.log(degree);
-	}
-	if (commonCount === 0) return epsilon;
-	const sourceDegree = sourceNeighbours.size;
-	const targetDegree = targetNeighbours.size;
-	const maxScore = Math.min(sourceDegree, targetDegree) / Math.log(2);
-	const score = weightedIntersection / maxScore;
-	return Math.max(epsilon, Math.min(1, score));
+	const { intersection, union } = neighbourOverlap(neighbourSet(graph, source, target), neighbourSet(graph, target, source));
+	const jaccard = union > 0 ? intersection / union : 0;
+	const N = graph.nodeCount;
+	const sourceDegree = graph.degree(source);
+	const targetDegree = graph.degree(target);
+	const sourceIdf = Math.log(N / (sourceDegree + 1));
+	const targetIdf = Math.log(N / (targetDegree + 1));
+	const score = jaccard * sourceIdf * targetIdf;
+	return Math.max(epsilon, score);
 }
 //#endregion
 //#region src/ranking/mi/span.ts
@@ -759,21 +733,12 @@ function skew(graph, source, target, config) {
 */
 function span(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	const sourceNeighbours = new Set(graph.neighbours(source));
-	const targetNeighbours = new Set(graph.neighbours(target));
-	sourceNeighbours.delete(target);
-	targetNeighbours.delete(source);
-	const sourceDegree = sourceNeighbours.size;
-	const targetDegree = targetNeighbours.size;
-	let intersectionSize = 0;
-	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) intersectionSize++;
-	const unionSize = sourceDegree + targetDegree - intersectionSize;
-	const jaccard = unionSize > 0 ? intersectionSize / unionSize : 0;
-	const maxDegree = Math.max(sourceDegree, targetDegree);
-	const degreeDiff = Math.abs(sourceDegree - targetDegree);
-	const degreeSimilarity = maxDegree > 0 ? 1 - degreeDiff / maxDegree : 1;
-	const score = Math.sqrt(jaccard * degreeSimilarity);
-	return Math.max(epsilon, Math.min(1, score));
+	const { intersection, union } = neighbourOverlap(neighbourSet(graph, source, target), neighbourSet(graph, target, source));
+	const jaccard = union > 0 ? intersection / union : 0;
+	const sourceCc = localClusteringCoefficient(graph, source);
+	const targetCc = localClusteringCoefficient(graph, target);
+	const score = jaccard * (1 - Math.max(sourceCc, targetCc));
+	return Math.max(epsilon, score);
 }
 //#endregion
 //#region src/ranking/mi/etch.ts
@@ -782,30 +747,14 @@ function span(graph, source, target, config) {
 */
 function etch(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	const sourceNeighbours = new Set(graph.neighbours(source));
-	const targetNeighbours = new Set(graph.neighbours(target));
-	sourceNeighbours.delete(target);
-	targetNeighbours.delete(source);
-	const commonNeighbours = [];
-	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) commonNeighbours.push(neighbour);
-	if (commonNeighbours.length < 2) return epsilon;
-	let jointEdges = 0;
-	for (let i = 0; i < commonNeighbours.length; i++) for (let j = i + 1; j < commonNeighbours.length; j++) {
-		const ni = commonNeighbours[i];
-		const nj = commonNeighbours[j];
-		if (ni !== void 0 && nj !== void 0 && graph.getEdge(ni, nj) !== void 0) jointEdges++;
-	}
-	const maxJointEdges = commonNeighbours.length * (commonNeighbours.length - 1) / 2;
-	const jointDensity = maxJointEdges > 0 ? jointEdges / maxJointEdges : 0;
-	let commonEdges = 0;
-	for (const cn of commonNeighbours) {
-		if (graph.getEdge(source, cn) !== void 0) commonEdges++;
-		if (graph.getEdge(target, cn) !== void 0) commonEdges++;
-	}
-	const maxCommonEdges = commonNeighbours.length * 2;
-	const commonDensity = maxCommonEdges > 0 ? commonEdges / maxCommonEdges : 0;
-	const score = jointDensity * .7 + commonDensity * .3;
-	return Math.max(epsilon, Math.min(1, score));
+	const { intersection, union } = neighbourOverlap(neighbourSet(graph, source, target), neighbourSet(graph, target, source));
+	const jaccard = union > 0 ? intersection / union : 0;
+	const edge = graph.getEdge(source, target);
+	if (edge?.type === void 0) return Math.max(epsilon, jaccard);
+	const edgeTypeCount = countEdgesOfType(graph, edge.type);
+	if (edgeTypeCount === 0) return Math.max(epsilon, jaccard);
+	const score = jaccard * Math.log(graph.edgeCount / edgeTypeCount);
+	return Math.max(epsilon, score);
 }
 //#endregion
 //#region src/ranking/mi/notch.ts
@@ -814,20 +763,18 @@ function etch(graph, source, target, config) {
 */
 function notch(graph, source, target, config) {
 	const { epsilon = 1e-10 } = config ?? {};
-	const sourceNeighbours = new Set(graph.neighbours(source));
-	const targetNeighbours = new Set(graph.neighbours(target));
-	sourceNeighbours.delete(target);
-	targetNeighbours.delete(source);
-	const sourceDegree = sourceNeighbours.size;
-	const targetDegree = targetNeighbours.size;
-	let intersectionSize = 0;
-	for (const neighbour of sourceNeighbours) if (targetNeighbours.has(neighbour)) intersectionSize++;
-	const minDegree = Math.min(sourceDegree, targetDegree);
-	const overlap = minDegree > 0 ? intersectionSize / minDegree : 0;
-	const maxDegree = Math.max(sourceDegree, targetDegree);
-	const correlation = maxDegree > 0 ? 1 - Math.abs(sourceDegree - targetDegree) / maxDegree : 1;
-	const score = overlap * .6 + correlation * .4;
-	return Math.max(epsilon, Math.min(1, score));
+	const { intersection, union } = neighbourOverlap(neighbourSet(graph, source, target), neighbourSet(graph, target, source));
+	const jaccard = union > 0 ? intersection / union : 0;
+	const sourceNode = graph.getNode(source);
+	const targetNode = graph.getNode(target);
+	if (sourceNode?.type === void 0 || targetNode?.type === void 0) return Math.max(epsilon, jaccard);
+	const sourceTypeCount = countNodesOfType(graph, sourceNode.type);
+	const targetTypeCount = countNodesOfType(graph, targetNode.type);
+	if (sourceTypeCount === 0 || targetTypeCount === 0) return Math.max(epsilon, jaccard);
+	const sourceRarity = Math.log(graph.nodeCount / sourceTypeCount);
+	const targetRarity = Math.log(graph.nodeCount / targetTypeCount);
+	const score = jaccard * sourceRarity * targetRarity;
+	return Math.max(epsilon, score);
 }
 //#endregion
 //#region src/ranking/mi/adaptive.ts
@@ -835,7 +782,7 @@ function notch(graph, source, target, config) {
 * Compute unified adaptive MI between two connected nodes.
 *
 * Combines structural, degree, and overlap signals with
-* adaptive weighting based on graph density.
+* configurable weighting.
 *
 * @param graph - Source graph
 * @param source - Source node ID
@@ -850,17 +797,13 @@ function adaptive(graph, source, target, config) {
 		epsilon,
 		normalise: true
 	});
-	const sourceNeighbours = new Set(graph.neighbours(source));
-	const targetNeighbours = new Set(graph.neighbours(target));
-	sourceNeighbours.delete(target);
-	targetNeighbours.delete(source);
-	const sourceDegree = sourceNeighbours.size;
-	const targetDegree = targetNeighbours.size;
+	const sourceNeighbours = neighbourSet(graph, source, target);
+	const targetNeighbours = neighbourSet(graph, target, source);
 	let overlap;
-	if (sourceDegree > 0 && targetDegree > 0) {
-		let commonCount = 0;
-		for (const n of sourceNeighbours) if (targetNeighbours.has(n)) commonCount++;
-		overlap = commonCount / Math.min(sourceDegree, targetDegree);
+	if (sourceNeighbours.size > 0 && targetNeighbours.size > 0) {
+		const { intersection } = neighbourOverlap(sourceNeighbours, targetNeighbours);
+		const minDegree = Math.min(sourceNeighbours.size, targetNeighbours.size);
+		overlap = minDegree > 0 ? intersection / minDegree : epsilon;
 	} else overlap = epsilon;
 	const totalWeight = structuralWeight + degreeWeight + overlapWeight;
 	const score = (structuralWeight * structural + degreeWeight * degreeComponent + overlapWeight * overlap) / totalWeight;
@@ -2221,6 +2164,6 @@ function filterSubgraph(graph, options) {
 	return result;
 }
 //#endregion
-export { AdjacencyMapGraph, GPUContext, GPUNotAvailableError, PriorityQueue, _computeMean, adamicAdar, adaptive, approximateClusteringCoefficient, assertWebGPUAvailable, base, batchClusteringCoefficients, betweenness, bfs, bfsWithPath, communicability, computeTrussNumbers, createGPUContext, createResultBuffer, csrToGPUBuffers, degreeSum, detectWebGPU, dfs, dfsWithPath, dome, domeHighDegree, edge, entropyFromCounts, enumerateMotifs, enumerateMotifsWithInstances, etch, extractEgoNetwork, extractInducedSubgraph, extractKCore, extractKTruss, filterSubgraph, frontierBalanced, getGPUContext, getMotifName, graphToCSR, grasp, hae, isWebGPUAvailable, jaccard, jaccardArithmetic, katz, localClusteringCoefficient, localTypeEntropy, maze, miniBatchKMeans, normaliseFeatures, normaliseFeatures as zScoreNormalise, normalisedEntropy, notch, pagerank, parse, pipe, randomPriority, randomRanking, reach, readBufferToCPU, resistanceDistance, sage, scale, shannonEntropy, shortest, skew, span, standardBfs, stratified, widestPath };
+export { AdjacencyMapGraph, GPUContext, GPUNotAvailableError, PriorityQueue, _computeMean, adamicAdar, adaptive, approximateClusteringCoefficient, assertWebGPUAvailable, base, batchClusteringCoefficients, betweenness, bfs, bfsWithPath, communicability, computeTrussNumbers, countEdgesOfType, countNodesOfType, createGPUContext, createResultBuffer, csrToGPUBuffers, degreeSum, detectWebGPU, dfs, dfsWithPath, dome, domeHighDegree, edge, entropyFromCounts, enumerateMotifs, enumerateMotifsWithInstances, etch, extractEgoNetwork, extractInducedSubgraph, extractKCore, extractKTruss, filterSubgraph, frontierBalanced, getGPUContext, getMotifName, graphToCSR, grasp, hae, isWebGPUAvailable, jaccard, jaccardArithmetic, katz, localClusteringCoefficient, localTypeEntropy, maze, miniBatchKMeans, neighbourIntersection, neighbourOverlap, neighbourSet, normaliseFeatures, normaliseFeatures as zScoreNormalise, normalisedEntropy, notch, pagerank, parse, pipe, randomPriority, randomRanking, reach, readBufferToCPU, resistanceDistance, sage, scale, shannonEntropy, shortest, skew, span, standardBfs, stratified, widestPath };
 
 //# sourceMappingURL=index.js.map