graphwise 1.8.0 → 1.9.0

package/dist/ranking/mi/index.js

@@ -0,0 +1,555 @@
+import { t as collectAsyncIterable } from "../../utils-BodeE2Mo.js";
+import { computeJaccard, countEdgesOfType, countNodesOfType, localClusteringCoefficient, neighbourIntersection, neighbourOverlap, neighbourSet } from "../../utils/index.js";
+import { n as jaccardAsync, t as jaccard } from "../../jaccard-3rCdilwm.js";
+//#region src/ranking/mi/adamic-adar.ts
+/**
+* Compute Adamic-Adar index between neighbourhoods of two nodes.
+*
+* @param graph - Source graph
+* @param source - Source node ID
+* @param target - Target node ID
+* @param config - Optional configuration
+* @returns Adamic-Adar index (normalised to [0, 1] if configured)
+*/
+function adamicAdar(graph, source, target, config) {
+	const { epsilon = 1e-10, normalise = true } = config ?? {};
+	const commonNeighbours = neighbourIntersection(neighbourSet(graph, source, target), neighbourSet(graph, target, source));
+	let score = 0;
+	for (const neighbour of commonNeighbours) {
+		const degree = graph.degree(neighbour);
+		score += 1 / Math.log(degree + 1);
+	}
+	if (normalise && commonNeighbours.size > 0) {
+		const maxScore = commonNeighbours.size / Math.log(2);
+		score = score / maxScore;
+	}
+	return Math.max(epsilon, score);
+}
+/**
+* Async variant of Adamic-Adar index for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then fetches degree for each common
+* neighbour to compute the inverse-log-degree weighted sum.
+*/
+async function adamicAdarAsync(graph, source, target, config) {
+	const { epsilon = 1e-10, normalise = true } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	const commonNeighbours = [];
+	for (const n of srcSet) if (tgtSet.has(n)) commonNeighbours.push(n);
+	if (commonNeighbours.length === 0) return epsilon;
+	const degrees = await Promise.all(commonNeighbours.map((n) => graph.degree(n)));
+	let score = 0;
+	for (const degree of degrees) score += 1 / Math.log(degree + 1);
+	if (normalise) {
+		const maxScore = commonNeighbours.length / Math.log(2);
+		score = score / maxScore;
+	}
+	return Math.max(epsilon, score);
+}
+//#endregion
+//#region src/ranking/mi/cosine.ts
+/**
+* Compute cosine similarity between neighbourhoods of two nodes.
+*
+* @param graph - Source graph
+* @param source - Source node ID
+* @param target - Target node ID
+* @param config - Optional configuration
+* @returns Cosine similarity in [0, 1]
+*/
+function cosine(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const sourceNeighbours = neighbourSet(graph, source, target);
+	const targetNeighbours = neighbourSet(graph, target, source);
+	const { intersection } = neighbourOverlap(sourceNeighbours, targetNeighbours);
+	const denominator = Math.sqrt(sourceNeighbours.size) * Math.sqrt(targetNeighbours.size);
+	if (denominator === 0) return 0;
+	const score = intersection / denominator;
+	return Math.max(epsilon, score);
+}
+/**
+* Async variant of cosine similarity for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then applies the same formula.
+*/
+async function cosineAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const denominator = Math.sqrt(srcSet.size) * Math.sqrt(tgtSet.size);
+	if (denominator === 0) return 0;
+	const score = intersection / denominator;
+	return Math.max(epsilon, score);
+}
+//#endregion
+//#region src/ranking/mi/sorensen.ts
+/**
+* Compute Sorensen-Dice similarity between neighbourhoods of two nodes.
+*
+* @param graph - Source graph
+* @param source - Source node ID
+* @param target - Target node ID
+* @param config - Optional configuration
+* @returns Sorensen-Dice coefficient in [0, 1]
+*/
+function sorensen(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const sourceNeighbours = neighbourSet(graph, source, target);
+	const targetNeighbours = neighbourSet(graph, target, source);
+	const { intersection } = neighbourOverlap(sourceNeighbours, targetNeighbours);
+	const denominator = sourceNeighbours.size + targetNeighbours.size;
+	if (denominator === 0) return 0;
+	const score = 2 * intersection / denominator;
+	return Math.max(epsilon, score);
+}
+/**
+* Async variant of Sorensen-Dice coefficient for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then applies the same formula.
+*/
+async function sorensenAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const denominator = srcSet.size + tgtSet.size;
+	if (denominator === 0) return 0;
+	const score = 2 * intersection / denominator;
+	return Math.max(epsilon, score);
+}
+//#endregion
+//#region src/ranking/mi/resource-allocation.ts
+/**
+* Compute Resource Allocation index between neighbourhoods of two nodes.
+*
+* @param graph - Source graph
+* @param source - Source node ID
+* @param target - Target node ID
+* @param config - Optional configuration
+* @returns Resource Allocation index (normalised to [0, 1] if configured)
+*/
+function resourceAllocation(graph, source, target, config) {
+	const { epsilon = 1e-10, normalise = true } = config ?? {};
+	const commonNeighbours = neighbourIntersection(neighbourSet(graph, source, target), neighbourSet(graph, target, source));
+	let score = 0;
+	for (const neighbour of commonNeighbours) {
+		const degree = graph.degree(neighbour);
+		if (degree > 0) score += 1 / degree;
+	}
+	if (normalise && commonNeighbours.size > 0) {
+		const maxScore = commonNeighbours.size;
+		score = score / maxScore;
+	}
+	return Math.max(epsilon, score);
+}
+/**
+* Async variant of Resource Allocation index for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then fetches degree for each common
+* neighbour to compute the inverse-degree weighted sum.
+*/
+async function resourceAllocationAsync(graph, source, target, config) {
+	const { epsilon = 1e-10, normalise = true } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	const commonNeighbours = [];
+	for (const n of srcSet) if (tgtSet.has(n)) commonNeighbours.push(n);
+	if (commonNeighbours.length === 0) return epsilon;
+	const degrees = await Promise.all(commonNeighbours.map((n) => graph.degree(n)));
+	let score = 0;
+	for (const degree of degrees) if (degree > 0) score += 1 / degree;
+	if (normalise) {
+		const maxScore = commonNeighbours.length;
+		score = score / maxScore;
+	}
+	return Math.max(epsilon, score);
+}
+//#endregion
+//#region src/ranking/mi/overlap-coefficient.ts
+/**
+* Compute Overlap Coefficient between neighbourhoods of two nodes.
+*
+* @param graph - Source graph
+* @param source - Source node ID
+* @param target - Target node ID
+* @param config - Optional configuration
+* @returns Overlap Coefficient in [0, 1]
+*/
+function overlapCoefficient(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const sourceNeighbours = neighbourSet(graph, source, target);
+	const targetNeighbours = neighbourSet(graph, target, source);
+	const { intersection } = neighbourOverlap(sourceNeighbours, targetNeighbours);
+	const denominator = Math.min(sourceNeighbours.size, targetNeighbours.size);
+	if (denominator === 0) return 0;
+	const score = intersection / denominator;
+	return Math.max(epsilon, score);
+}
+/**
+* Async variant of Overlap Coefficient for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then applies the same formula.
+*/
+async function overlapCoefficientAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const denominator = Math.min(srcSet.size, tgtSet.size);
+	if (denominator === 0) return 0;
+	const score = intersection / denominator;
+	return Math.max(epsilon, score);
+}
+//#endregion
+//#region src/ranking/mi/hub-promoted.ts
+/**
+* Compute Hub Promoted index between neighbourhoods of two nodes.
+*
+* @param graph - Source graph
+* @param source - Source node ID
+* @param target - Target node ID
+* @param config - Optional configuration
+* @returns Hub Promoted index in [0, 1]
+*/
+function hubPromoted(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const { intersection } = neighbourOverlap(neighbourSet(graph, source, target), neighbourSet(graph, target, source));
+	const sourceDegree = graph.degree(source);
+	const targetDegree = graph.degree(target);
+	const denominator = Math.min(sourceDegree, targetDegree);
+	if (denominator === 0) return 0;
+	const score = intersection / denominator;
+	return Math.max(epsilon, score);
+}
+/**
+* Async variant of Hub Promoted index for use with async graph data sources.
+*
+* Fetches both neighbourhoods and degrees concurrently, then applies the same formula.
+*/
+async function hubPromotedAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr, sourceDegree, targetDegree] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		graph.degree(source),
+		graph.degree(target)
+	]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const denominator = Math.min(sourceDegree, targetDegree);
+	if (denominator === 0) return 0;
+	const score = intersection / denominator;
+	return Math.max(epsilon, score);
+}
+//#endregion
+//#region src/ranking/mi/scale.ts
+/**
+* Compute SCALE MI between two nodes.
+*/
+function scale(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const { jaccard: jaccardScore } = computeJaccard(graph, source, target);
+	const n = graph.nodeCount;
+	const m = graph.edgeCount;
+	const possibleEdges = n * (n - 1);
+	const density = possibleEdges > 0 ? (graph.directed ? m : 2 * m) / possibleEdges : 0;
+	if (density === 0) return epsilon;
+	const score = jaccardScore / density;
+	return Math.max(epsilon, score);
+}
+/**
+* Async variant of SCALE MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods, node count, and edge count concurrently.
+*/
+async function scaleAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr, n, m] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		graph.nodeCount,
+		graph.edgeCount
+	]);
+	const srcSet = new Set(sourceArr.filter((node) => node !== target));
+	const tgtSet = new Set(targetArr.filter((node) => node !== source));
+	let intersection = 0;
+	for (const node of srcSet) if (tgtSet.has(node)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	const possibleEdges = n * (n - 1);
+	const density = possibleEdges > 0 ? (graph.directed ? m : 2 * m) / possibleEdges : 0;
+	if (density === 0) return epsilon;
+	const score = jaccardScore / density;
+	return Math.max(epsilon, score);
+}
+//#endregion
+//#region src/ranking/mi/skew.ts
+/**
+* Compute SKEW MI between two nodes.
+*/
+function skew(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const { jaccard: jaccardScore } = computeJaccard(graph, source, target);
+	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 = jaccardScore * sourceIdf * targetIdf;
+	return Math.max(epsilon, score);
+}
+/**
+* Async variant of SKEW MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods, degrees, and node count concurrently.
+*/
+async function skewAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr, N, sourceDegree, targetDegree] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		graph.nodeCount,
+		graph.degree(source),
+		graph.degree(target)
+	]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	const sourceIdf = Math.log(N / (sourceDegree + 1));
+	const targetIdf = Math.log(N / (targetDegree + 1));
+	const score = jaccardScore * sourceIdf * targetIdf;
+	return Math.max(epsilon, score);
+}
+//#endregion
+//#region src/ranking/mi/span.ts
+/**
+* Compute SPAN MI between two nodes.
+*/
+function span(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const { jaccard: jaccardScore } = computeJaccard(graph, source, target);
+	const sourceCc = localClusteringCoefficient(graph, source);
+	const targetCc = localClusteringCoefficient(graph, target);
+	const score = jaccardScore * (1 - Math.max(sourceCc, targetCc));
+	return Math.max(epsilon, score);
+}
+/**
+* Async variant of SPAN MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then computes the clustering
+* coefficient for each endpoint from the collected neighbour arrays.
+*/
+async function spanAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr] = await Promise.all([collectAsyncIterable(graph.neighbours(source)), collectAsyncIterable(graph.neighbours(target))]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	const computeClusteringCoefficient = async (nodeId, neighbourArr) => {
+		const degree = neighbourArr.length;
+		if (degree < 2) return 0;
+		const pairs = [];
+		for (let i = 0; i < neighbourArr.length; i++) for (let j = i + 1; j < neighbourArr.length; j++) {
+			const u = neighbourArr[i];
+			const v = neighbourArr[j];
+			if (u !== void 0 && v !== void 0) pairs.push([u, v]);
+		}
+		const edgeResults = await Promise.all(pairs.flatMap(([u, v]) => [graph.getEdge(u, v), graph.getEdge(v, u)]));
+		let triangleCount = 0;
+		for (let i = 0; i < pairs.length; i++) if (edgeResults[2 * i] !== void 0 || edgeResults[2 * i + 1] !== void 0) triangleCount++;
+		const possibleTriangles = degree * (degree - 1) / 2;
+		return triangleCount / possibleTriangles;
+	};
+	const [sourceCc, targetCc] = await Promise.all([computeClusteringCoefficient(source, sourceArr), computeClusteringCoefficient(target, targetArr)]);
+	const score = jaccardScore * (1 - Math.max(sourceCc, targetCc));
+	return Math.max(epsilon, score);
+}
+//#endregion
+//#region src/ranking/mi/etch.ts
+/**
+* Compute ETCH MI between two nodes.
+*/
+function etch(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const { jaccard: jaccardScore } = computeJaccard(graph, source, target);
+	const edge = graph.getEdge(source, target);
+	if (edge?.type === void 0) return Math.max(epsilon, jaccardScore);
+	const edgeTypeCount = countEdgesOfType(graph, edge.type);
+	if (edgeTypeCount === 0) return Math.max(epsilon, jaccardScore);
+	const score = jaccardScore * Math.log(graph.edgeCount / edgeTypeCount);
+	return Math.max(epsilon, score);
+}
+/**
+* Async variant of ETCH MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods and edge data concurrently, then counts
+* edges of the same type by iterating the async edge stream.
+*/
+async function etchAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr, edge] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		graph.getEdge(source, target)
+	]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	if (edge?.type === void 0) return Math.max(epsilon, jaccardScore);
+	const edgeType = edge.type;
+	let edgeTypeCount = 0;
+	let totalEdges = 0;
+	for await (const e of graph.edges()) {
+		totalEdges++;
+		if (e.type === edgeType) edgeTypeCount++;
+	}
+	if (edgeTypeCount === 0) return Math.max(epsilon, jaccardScore);
+	const score = jaccardScore * Math.log(totalEdges / edgeTypeCount);
+	return Math.max(epsilon, score);
+}
+//#endregion
+//#region src/ranking/mi/notch.ts
+/**
+* Compute NOTCH MI between two nodes.
+*/
+function notch(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const { jaccard: jaccardScore } = computeJaccard(graph, source, target);
+	const sourceNode = graph.getNode(source);
+	const targetNode = graph.getNode(target);
+	if (sourceNode?.type === void 0 || targetNode?.type === void 0) return Math.max(epsilon, jaccardScore);
+	const sourceTypeCount = countNodesOfType(graph, sourceNode.type);
+	const targetTypeCount = countNodesOfType(graph, targetNode.type);
+	if (sourceTypeCount === 0 || targetTypeCount === 0) return Math.max(epsilon, jaccardScore);
+	const sourceRarity = Math.log(graph.nodeCount / sourceTypeCount);
+	const targetRarity = Math.log(graph.nodeCount / targetTypeCount);
+	const score = jaccardScore * sourceRarity * targetRarity;
+	return Math.max(epsilon, score);
+}
+/**
+* Async variant of NOTCH MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods and node data concurrently, then counts
+* nodes of each type by iterating the async node stream.
+*/
+async function notchAsync(graph, source, target, config) {
+	const { epsilon = 1e-10 } = config ?? {};
+	const [sourceArr, targetArr, sourceNode, targetNode] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		graph.getNode(source),
+		graph.getNode(target)
+	]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	if (sourceNode?.type === void 0 || targetNode?.type === void 0) return Math.max(epsilon, jaccardScore);
+	const sourceType = sourceNode.type;
+	const targetType = targetNode.type;
+	let totalNodes = 0;
+	let sourceTypeCount = 0;
+	let targetTypeCount = 0;
+	for await (const nodeId of graph.nodeIds()) {
+		totalNodes++;
+		const node = await graph.getNode(nodeId);
+		if (node?.type === sourceType) sourceTypeCount++;
+		if (node?.type === targetType) targetTypeCount++;
+	}
+	if (sourceTypeCount === 0 || targetTypeCount === 0) return Math.max(epsilon, jaccardScore);
+	const sourceRarity = Math.log(totalNodes / sourceTypeCount);
+	const targetRarity = Math.log(totalNodes / targetTypeCount);
+	const score = jaccardScore * sourceRarity * targetRarity;
+	return Math.max(epsilon, score);
+}
+//#endregion
+//#region src/ranking/mi/adaptive.ts
+/**
+* Compute unified adaptive MI between two connected nodes.
+*
+* Combines structural, degree, and overlap signals with
+* configurable weighting.
+*
+* @param graph - Source graph
+* @param source - Source node ID
+* @param target - Target node ID
+* @param config - Optional configuration with component weights
+* @returns Adaptive MI score in [0, 1]
+*/
+function adaptive(graph, source, target, config) {
+	const { epsilon = 1e-10, structuralWeight = .4, degreeWeight = .3, overlapWeight = .3 } = config ?? {};
+	const { jaccard: jaccardScore, sourceNeighbours, targetNeighbours } = computeJaccard(graph, source, target);
+	const structural = sourceNeighbours.size === 0 && targetNeighbours.size === 0 ? 0 : Math.max(epsilon, jaccardScore);
+	const degreeComponent = adamicAdar(graph, source, target, {
+		epsilon,
+		normalise: true
+	});
+	let overlap;
+	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;
+	return Math.max(epsilon, Math.min(1, score));
+}
+/**
+* Async variant of Adaptive MI for use with async graph data sources.
+*
+* Fetches both neighbourhoods concurrently, then delegates degree-weighted
+* component to the async Adamic-Adar variant.
+*/
+async function adaptiveAsync(graph, source, target, config) {
+	const { epsilon = 1e-10, structuralWeight = .4, degreeWeight = .3, overlapWeight = .3 } = config ?? {};
+	const [sourceArr, targetArr, degreeComponent] = await Promise.all([
+		collectAsyncIterable(graph.neighbours(source)),
+		collectAsyncIterable(graph.neighbours(target)),
+		adamicAdarAsync(graph, source, target, {
+			epsilon,
+			normalise: true
+		})
+	]);
+	const srcSet = new Set(sourceArr.filter((n) => n !== target));
+	const tgtSet = new Set(targetArr.filter((n) => n !== source));
+	let intersection = 0;
+	for (const n of srcSet) if (tgtSet.has(n)) intersection++;
+	const union = srcSet.size + tgtSet.size - intersection;
+	const jaccardScore = union > 0 ? intersection / union : 0;
+	const structural = srcSet.size === 0 && tgtSet.size === 0 ? 0 : Math.max(epsilon, jaccardScore);
+	let overlap;
+	if (srcSet.size > 0 && tgtSet.size > 0) {
+		const minDegree = Math.min(srcSet.size, tgtSet.size);
+		overlap = minDegree > 0 ? intersection / minDegree : epsilon;
+	} else overlap = epsilon;
+	const totalWeight = structuralWeight + degreeWeight + overlapWeight;
+	const score = (structuralWeight * structural + degreeWeight * degreeComponent + overlapWeight * overlap) / totalWeight;
+	return Math.max(epsilon, Math.min(1, score));
+}
+//#endregion
+export { adamicAdar, adamicAdarAsync, adaptive, adaptiveAsync, cosine, cosineAsync, etch, etchAsync, hubPromoted, hubPromotedAsync, jaccard, jaccardAsync, notch, notchAsync, overlapCoefficient, overlapCoefficientAsync, resourceAllocation, resourceAllocationAsync, scale, scaleAsync, skew, skewAsync, sorensen, sorensenAsync, span, spanAsync };
+
+//# sourceMappingURL=index.js.map