graphwise 1.0.0 → 1.1.0

package/dist/traversal-QeHaNUWn.cjs

@@ -0,0 +1,172 @@
+//#region src/traversal/bfs.ts
+/**
+* Perform a breadth-first search traversal from a start node.
+*
+* This generator yields node IDs in BFS order. It uses lazy evaluation
+* via a generator, making it memory-efficient for large graphs.
+*
+* @param graph - The graph to traverse
+* @param start - The starting node ID
+* @yields Node IDs in BFS order
+*
+* @example
+* ```typescript
+* for (const nodeId of bfs(graph, "A")) {
+*   console.log(nodeId);
+* }
+* ```
+*/
+function* bfs(graph, start) {
+	if (!graph.hasNode(start)) return;
+	const visited = new Set([start]);
+	const queue = [start];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		if (current === void 0) break;
+		yield current;
+		for (const neighbour of graph.neighbours(current)) if (!visited.has(neighbour)) {
+			visited.add(neighbour);
+			queue.push(neighbour);
+		}
+	}
+}
+/**
+* Perform a breadth-first search traversal with path information.
+*
+* This generator yields detailed information about each visited node,
+* including its depth from the start and parent in the BFS tree.
+* Useful for reconstructing shortest paths.
+*
+* @param graph - The graph to traverse
+* @param start - The starting node ID
+* @yields Objects containing node ID, depth, and parent
+*
+* @example
+* ```typescript
+* for (const entry of bfsWithPath(graph, "A")) {
+*   console.log(`${entry.node} at depth ${entry.depth}`);
+* }
+* ```
+*/
+function* bfsWithPath(graph, start) {
+	if (!graph.hasNode(start)) return;
+	const visited = new Set([start]);
+	const queue = [{
+		node: start,
+		depth: 0,
+		parent: void 0
+	}];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		if (current === void 0) break;
+		yield current;
+		for (const neighbour of graph.neighbours(current.node)) if (!visited.has(neighbour)) {
+			visited.add(neighbour);
+			queue.push({
+				node: neighbour,
+				depth: current.depth + 1,
+				parent: current.node
+			});
+		}
+	}
+}
+//#endregion
+//#region src/traversal/dfs.ts
+/**
+* Perform a depth-first search traversal from a start node.
+*
+* This generator yields node IDs in DFS order (pre-order traversal).
+* It uses lazy evaluation via a generator, making it memory-efficient
+* for large graphs.
+*
+* @param graph - The graph to traverse
+* @param start - The starting node ID
+* @yields Node IDs in DFS order
+*
+* @example
+* ```typescript
+* for (const nodeId of dfs(graph, "A")) {
+*   console.log(nodeId);
+* }
+* ```
+*/
+function* dfs(graph, start) {
+	if (!graph.hasNode(start)) return;
+	const visited = /* @__PURE__ */ new Set();
+	const stack = [start];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (current === void 0) break;
+		if (visited.has(current)) continue;
+		visited.add(current);
+		yield current;
+		const neighbours = [...graph.neighbours(current)].reverse();
+		for (const neighbour of neighbours) if (!visited.has(neighbour)) stack.push(neighbour);
+	}
+}
+/**
+* Perform a depth-first search traversal with path information.
+*
+* This generator yields detailed information about each visited node,
+* including its depth from the start and parent in the DFS tree.
+*
+* @param graph - The graph to traverse
+* @param start - The starting node ID
+* @yields Objects containing node ID, depth, and parent
+*
+* @example
+* ```typescript
+* for (const entry of dfsWithPath(graph, "A")) {
+*   console.log(`${entry.node} at depth ${entry.depth}`);
+* }
+* ```
+*/
+function* dfsWithPath(graph, start) {
+	if (!graph.hasNode(start)) return;
+	const visited = /* @__PURE__ */ new Set();
+	const stack = [{
+		node: start,
+		depth: 0,
+		parent: void 0
+	}];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (current === void 0) break;
+		if (visited.has(current.node)) continue;
+		visited.add(current.node);
+		yield current;
+		const neighbours = [...graph.neighbours(current.node)].reverse();
+		for (const neighbour of neighbours) if (!visited.has(neighbour)) stack.push({
+			node: neighbour,
+			depth: current.depth + 1,
+			parent: current.node
+		});
+	}
+}
+//#endregion
+Object.defineProperty(exports, "bfs", {
+	enumerable: true,
+	get: function() {
+		return bfs;
+	}
+});
+Object.defineProperty(exports, "bfsWithPath", {
+	enumerable: true,
+	get: function() {
+		return bfsWithPath;
+	}
+});
+Object.defineProperty(exports, "dfs", {
+	enumerable: true,
+	get: function() {
+		return dfs;
+	}
+});
+Object.defineProperty(exports, "dfsWithPath", {
+	enumerable: true,
+	get: function() {
+		return dfsWithPath;
+	}
+});
+
+//# sourceMappingURL=traversal-QeHaNUWn.cjs.map

package/dist/traversal-QeHaNUWn.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"traversal-QeHaNUWn.cjs","names":[],"sources":["../src/traversal/bfs.ts","../src/traversal/dfs.ts"],"sourcesContent":["/**\n * Breadth-first search traversal algorithms.\n *\n * BFS explores nodes level by level, visiting all neighbours at the current\n * depth before moving to nodes at the next depth level. This guarantees\n * shortest path discovery in unweighted graphs.\n */\n\nimport type { ReadableGraph, NodeId } from \"../graph\";\n\n/**\n * Node visit information during BFS traversal.\n */\nexport interface BfsPathEntry {\n\t/** The visited node identifier */\n\tnode: NodeId;\n\t/** Distance from the start node (0 for start node) */\n\tdepth: number;\n\t/** Parent node in the BFS tree (undefined for start node) */\n\tparent: NodeId | undefined;\n}\n\n/**\n * Perform a breadth-first search traversal from a start node.\n *\n * This generator yields node IDs in BFS order. It uses lazy evaluation\n * via a generator, making it memory-efficient for large graphs.\n *\n * @param graph - The graph to traverse\n * @param start - The starting node ID\n * @yields Node IDs in BFS order\n *\n * @example\n * ```typescript\n * for (const nodeId of bfs(graph, \"A\")) {\n *   console.log(nodeId);\n * }\n * ```\n */\nexport function* bfs(graph: ReadableGraph, start: NodeId): Iterable<NodeId> {\n\tif (!graph.hasNode(start)) {\n\t\treturn;\n\t}\n\n\tconst visited = new Set<NodeId>([start]);\n\tconst queue: NodeId[] = [start];\n\n\twhile (queue.length > 0) {\n\t\tconst current = queue.shift();\n\t\tif (current === undefined) break;\n\t\tyield current;\n\n\t\tfor (const neighbour of graph.neighbours(current)) {\n\t\t\tif (!visited.has(neighbour)) {\n\t\t\t\tvisited.add(neighbour);\n\t\t\t\tqueue.push(neighbour);\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Perform a breadth-first search traversal with path information.\n *\n * This generator yields detailed information about each visited node,\n * including its depth from the start and parent in the BFS tree.\n * Useful for reconstructing shortest paths.\n *\n * @param graph - The graph to traverse\n * @param start - The starting node ID\n * @yields Objects containing node ID, depth, and parent\n *\n * @example\n * ```typescript\n * for (const entry of bfsWithPath(graph, \"A\")) {\n *   console.log(`${entry.node} at depth ${entry.depth}`);\n * }\n * ```\n */\nexport function* bfsWithPath(\n\tgraph: ReadableGraph,\n\tstart: NodeId,\n): Iterable<BfsPathEntry> {\n\tif (!graph.hasNode(start)) {\n\t\treturn;\n\t}\n\n\tconst visited = new Set<NodeId>([start]);\n\tconst queue: { node: NodeId; depth: number; parent: NodeId | undefined }[] = [\n\t\t{ node: start, depth: 0, parent: undefined },\n\t];\n\n\twhile (queue.length > 0) {\n\t\tconst current = queue.shift();\n\t\tif (current === undefined) break;\n\t\tyield current;\n\n\t\tfor (const neighbour of graph.neighbours(current.node)) {\n\t\t\tif (!visited.has(neighbour)) {\n\t\t\t\tvisited.add(neighbour);\n\t\t\t\tqueue.push({\n\t\t\t\t\tnode: neighbour,\n\t\t\t\t\tdepth: current.depth + 1,\n\t\t\t\t\tparent: current.node,\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t}\n}\n","/**\n * Depth-first search traversal algorithms.\n *\n * DFS explores as far as possible along each branch before backtracking.\n * This makes it useful for cycle detection, topological sorting, and\n * finding connected components.\n */\n\nimport type { ReadableGraph, NodeId } from \"../graph\";\n\n/**\n * Node visit information during DFS traversal.\n */\nexport interface DfsPathEntry {\n\t/** The visited node identifier */\n\tnode: NodeId;\n\t/** Distance from the start node (0 for start node) */\n\tdepth: number;\n\t/** Parent node in the DFS tree (undefined for start node) */\n\tparent: NodeId | undefined;\n}\n\n/**\n * Perform a depth-first search traversal from a start node.\n *\n * This generator yields node IDs in DFS order (pre-order traversal).\n * It uses lazy evaluation via a generator, making it memory-efficient\n * for large graphs.\n *\n * @param graph - The graph to traverse\n * @param start - The starting node ID\n * @yields Node IDs in DFS order\n *\n * @example\n * ```typescript\n * for (const nodeId of dfs(graph, \"A\")) {\n *   console.log(nodeId);\n * }\n * ```\n */\nexport function* dfs(graph: ReadableGraph, start: NodeId): Iterable<NodeId> {\n\tif (!graph.hasNode(start)) {\n\t\treturn;\n\t}\n\n\tconst visited = new Set<NodeId>();\n\tconst stack: NodeId[] = [start];\n\n\twhile (stack.length > 0) {\n\t\tconst current = stack.pop();\n\t\tif (current === undefined) break;\n\n\t\tif (visited.has(current)) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tvisited.add(current);\n\t\tyield current;\n\n\t\t// Add neighbours in reverse order to maintain left-to-right traversal\n\t\t// when popping from the stack\n\t\tconst neighbours = [...graph.neighbours(current)].reverse();\n\t\tfor (const neighbour of neighbours) {\n\t\t\tif (!visited.has(neighbour)) {\n\t\t\t\tstack.push(neighbour);\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Perform a depth-first search traversal with path information.\n *\n * This generator yields detailed information about each visited node,\n * including its depth from the start and parent in the DFS tree.\n *\n * @param graph - The graph to traverse\n * @param start - The starting node ID\n * @yields Objects containing node ID, depth, and parent\n *\n * @example\n * ```typescript\n * for (const entry of dfsWithPath(graph, \"A\")) {\n *   console.log(`${entry.node} at depth ${entry.depth}`);\n * }\n * ```\n */\nexport function* dfsWithPath(\n\tgraph: ReadableGraph,\n\tstart: NodeId,\n): Iterable<DfsPathEntry> {\n\tif (!graph.hasNode(start)) {\n\t\treturn;\n\t}\n\n\tconst visited = new Set<NodeId>();\n\tconst stack: { node: NodeId; depth: number; parent: NodeId | undefined }[] = [\n\t\t{ node: start, depth: 0, parent: undefined },\n\t];\n\n\twhile (stack.length > 0) {\n\t\tconst current = stack.pop();\n\t\tif (current === undefined) break;\n\n\t\tif (visited.has(current.node)) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tvisited.add(current.node);\n\t\tyield current;\n\n\t\t// Add neighbours in reverse order to maintain left-to-right traversal\n\t\t// when popping from the stack\n\t\tconst neighbours = [...graph.neighbours(current.node)].reverse();\n\t\tfor (const neighbour of neighbours) {\n\t\t\tif (!visited.has(neighbour)) {\n\t\t\t\tstack.push({\n\t\t\t\t\tnode: neighbour,\n\t\t\t\t\tdepth: current.depth + 1,\n\t\t\t\t\tparent: current.node,\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAuCA,UAAiB,IAAI,OAAsB,OAAiC;AAC3E,KAAI,CAAC,MAAM,QAAQ,MAAM,CACxB;CAGD,MAAM,UAAU,IAAI,IAAY,CAAC,MAAM,CAAC;CACxC,MAAM,QAAkB,CAAC,MAAM;AAE/B,QAAO,MAAM,SAAS,GAAG;EACxB,MAAM,UAAU,MAAM,OAAO;AAC7B,MAAI,YAAY,KAAA,EAAW;AAC3B,QAAM;AAEN,OAAK,MAAM,aAAa,MAAM,WAAW,QAAQ,CAChD,KAAI,CAAC,QAAQ,IAAI,UAAU,EAAE;AAC5B,WAAQ,IAAI,UAAU;AACtB,SAAM,KAAK,UAAU;;;;;;;;;;;;;;;;;;;;;;AAwBzB,UAAiB,YAChB,OACA,OACyB;AACzB,KAAI,CAAC,MAAM,QAAQ,MAAM,CACxB;CAGD,MAAM,UAAU,IAAI,IAAY,CAAC,MAAM,CAAC;CACxC,MAAM,QAAuE,CAC5E;EAAE,MAAM;EAAO,OAAO;EAAG,QAAQ,KAAA;EAAW,CAC5C;AAED,QAAO,MAAM,SAAS,GAAG;EACxB,MAAM,UAAU,MAAM,OAAO;AAC7B,MAAI,YAAY,KAAA,EAAW;AAC3B,QAAM;AAEN,OAAK,MAAM,aAAa,MAAM,WAAW,QAAQ,KAAK,CACrD,KAAI,CAAC,QAAQ,IAAI,UAAU,EAAE;AAC5B,WAAQ,IAAI,UAAU;AACtB,SAAM,KAAK;IACV,MAAM;IACN,OAAO,QAAQ,QAAQ;IACvB,QAAQ,QAAQ;IAChB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AChEN,UAAiB,IAAI,OAAsB,OAAiC;AAC3E,KAAI,CAAC,MAAM,QAAQ,MAAM,CACxB;CAGD,MAAM,0BAAU,IAAI,KAAa;CACjC,MAAM,QAAkB,CAAC,MAAM;AAE/B,QAAO,MAAM,SAAS,GAAG;EACxB,MAAM,UAAU,MAAM,KAAK;AAC3B,MAAI,YAAY,KAAA,EAAW;AAE3B,MAAI,QAAQ,IAAI,QAAQ,CACvB;AAGD,UAAQ,IAAI,QAAQ;AACpB,QAAM;EAIN,MAAM,aAAa,CAAC,GAAG,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS;AAC3D,OAAK,MAAM,aAAa,WACvB,KAAI,CAAC,QAAQ,IAAI,UAAU,CAC1B,OAAM,KAAK,UAAU;;;;;;;;;;;;;;;;;;;;AAuBzB,UAAiB,YAChB,OACA,OACyB;AACzB,KAAI,CAAC,MAAM,QAAQ,MAAM,CACxB;CAGD,MAAM,0BAAU,IAAI,KAAa;CACjC,MAAM,QAAuE,CAC5E;EAAE,MAAM;EAAO,OAAO;EAAG,QAAQ,KAAA;EAAW,CAC5C;AAED,QAAO,MAAM,SAAS,GAAG;EACxB,MAAM,UAAU,MAAM,KAAK;AAC3B,MAAI,YAAY,KAAA,EAAW;AAE3B,MAAI,QAAQ,IAAI,QAAQ,KAAK,CAC5B;AAGD,UAAQ,IAAI,QAAQ,KAAK;AACzB,QAAM;EAIN,MAAM,aAAa,CAAC,GAAG,MAAM,WAAW,QAAQ,KAAK,CAAC,CAAC,SAAS;AAChE,OAAK,MAAM,aAAa,WACvB,KAAI,CAAC,QAAQ,IAAI,UAAU,CAC1B,OAAM,KAAK;GACV,MAAM;GACN,OAAO,QAAQ,QAAQ;GACvB,QAAQ,QAAQ;GAChB,CAAC"}

package/dist/utils/clustering-coefficient.d.ts

@@ -0,0 +1,38 @@
+import { ReadableGraph, NodeId } from '../graph';
+/**
+ * Compute the local clustering coefficient for a single node.
+ *
+ * The clustering coefficient is defined as:
+ *   CC(v) = (triangles through v) / (possible triangles)
+ *   CC(v) = 2 * |{(u,w) : u,w in N(v), (u,w) in E}| / (deg(v) * (deg(v) - 1))
+ *
+ * For nodes with degree < 2, the clustering coefficient is 0.
+ *
+ * @param graph - The graph to compute on
+ * @param nodeId - The node to compute clustering coefficient for
+ * @returns The clustering coefficient in [0, 1], or 0 if undefined
+ */
+export declare function localClusteringCoefficient(graph: ReadableGraph, nodeId: NodeId): number;
+/**
+ * Compute approximate local clustering coefficient using sampling.
+ *
+ * For nodes with many neighbours, this samples neighbour pairs rather than
+ * checking all pairs. Useful for large graphs where exact computation is expensive.
+ *
+ * @param graph - The graph to compute on
+ * @param nodeId - The node to compute clustering coefficient for
+ * @param sampleSize - Maximum number of neighbour pairs to check (default: 100)
+ * @returns The approximate clustering coefficient in [0, 1]
+ */
+export declare function approximateClusteringCoefficient(graph: ReadableGraph, nodeId: NodeId, sampleSize?: number): number;
+/**
+ * Compute clustering coefficients for multiple nodes efficiently.
+ *
+ * Reuses neighbour sets to avoid repeated iteration.
+ *
+ * @param graph - The graph to compute on
+ * @param nodeIds - The nodes to compute clustering coefficients for
+ * @returns Map from nodeId to clustering coefficient
+ */
+export declare function batchClusteringCoefficients(graph: ReadableGraph, nodeIds: readonly NodeId[]): Map<NodeId, number>;
+//# sourceMappingURL=clustering-coefficient.d.ts.map

package/dist/utils/clustering-coefficient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clustering-coefficient.d.ts","sourceRoot":"","sources":["../../src/utils/clustering-coefficient.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEtD;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CACzC,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,MAAM,GACZ,MAAM,CAmCR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gCAAgC,CAC/C,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,MAAM,EACd,UAAU,SAAM,GACd,MAAM,CA2CR;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAC1C,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,SAAS,MAAM,EAAE,GACxB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAQrB"}

package/dist/utils/clustering-coefficient.unit.test.d.ts

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

package/dist/utils/clustering-coefficient.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clustering-coefficient.unit.test.d.ts","sourceRoot":"","sources":["../../src/utils/clustering-coefficient.unit.test.ts"],"names":[],"mappings":""}

package/dist/utils/entropy.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Entropy computation utilities for graph analysis.
+ *
+ * Shannon entropy measures uncertainty or randomness in a distribution.
+ * Used in EDGE and HAE algorithms for heterogeneity-aware expansion.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Compute Shannon entropy of a probability distribution.
+ *
+ * Shannon entropy is defined as:
+ *   H(X) = -Σ p(x) × log₂(p(x))
+ *
+ * A uniform distribution has maximum entropy.
+ * A deterministic distribution (all probability on one value) has zero entropy.
+ *
+ * @param probabilities - Array of probabilities (should sum to 1)
+ * @returns Entropy in bits (log base 2), or 0 if probabilities are invalid
+ */
+export declare function shannonEntropy(probabilities: readonly number[]): number;
+/**
+ * Compute normalised entropy (entropy divided by maximum possible entropy).
+ *
+ * Normalised entropy is in [0, 1], where:
+ * - 0 means the distribution is deterministic (all mass on one value)
+ * - 1 means the distribution is uniform (maximum uncertainty)
+ *
+ * This is useful for comparing entropy across distributions with different
+ * numbers of possible values.
+ *
+ * @param probabilities - Array of probabilities (should sum to 1)
+ * @returns Normalised entropy in [0, 1], or 0 if only one category
+ */
+export declare function normalisedEntropy(probabilities: readonly number[]): number;
+/**
+ * Compute entropy from a frequency count.
+ *
+ * Converts counts to probabilities and then computes entropy.
+ * This is a convenience function when you have raw counts rather than
+ * normalised probabilities.
+ *
+ * @param counts - Array of frequency counts
+ * @returns Entropy in bits
+ */
+export declare function entropyFromCounts(counts: readonly number[]): number;
+/**
+ * Compute local type entropy for a node's neighbours.
+ *
+ * This measures the diversity of types among a node's neighbours.
+ * High entropy = heterogeneous neighbourhood (diverse types).
+ * Low entropy = homogeneous neighbourhood (similar types).
+ *
+ * @param neighbourTypes - Array of type labels for neighbours
+ * @returns Normalised entropy in [0, 1]
+ */
+export declare function localTypeEntropy(neighbourTypes: readonly string[]): number;
+//# sourceMappingURL=entropy.d.ts.map

package/dist/utils/entropy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entropy.d.ts","sourceRoot":"","sources":["../../src/utils/entropy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAcvE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAa1E;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAYnE;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAwB1E"}

package/dist/utils/entropy.unit.test.d.ts

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

package/dist/utils/entropy.unit.test.d.ts.map

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

package/dist/utils/index.cjs

@@ -0,0 +1,13 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_kmeans = require("../kmeans-B0HEOU6k.cjs");
+const require_utils = require("../utils-spZa1ZvS.cjs");
+exports.approximateClusteringCoefficient = require_utils.approximateClusteringCoefficient;
+exports.batchClusteringCoefficients = require_utils.batchClusteringCoefficients;
+exports.entropyFromCounts = require_utils.entropyFromCounts;
+exports.localClusteringCoefficient = require_utils.localClusteringCoefficient;
+exports.localTypeEntropy = require_utils.localTypeEntropy;
+exports.miniBatchKMeans = require_kmeans.miniBatchKMeans;
+exports.normaliseFeatures = require_kmeans.normaliseFeatures;
+exports.normalisedEntropy = require_utils.normalisedEntropy;
+exports.shannonEntropy = require_utils.shannonEntropy;
+exports.zScoreNormalise = require_kmeans.normaliseFeatures;

package/dist/utils/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Utility functions module.
+ *
+ * @packageDocumentation
+ */
+export { localClusteringCoefficient, approximateClusteringCoefficient, batchClusteringCoefficients, } from './clustering-coefficient';
+export { miniBatchKMeans, normaliseFeatures, zScoreNormalise, type FeatureVector3D, type LabelledFeature, type KMeansResult, type KMeansOptions, } from './kmeans';
+export { shannonEntropy, normalisedEntropy, entropyFromCounts, localTypeEntropy, } from './entropy';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACN,0BAA0B,EAC1B,gCAAgC,EAChC,2BAA2B,GAC3B,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACN,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,aAAa,GAClB,MAAM,UAAU,CAAC;AAElB,OAAO,EACN,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,GAChB,MAAM,WAAW,CAAC"}

package/dist/utils/index.js

@@ -0,0 +1,3 @@
+import { n as normaliseFeatures, t as miniBatchKMeans } from "../kmeans-DgbsOznU.js";
+import { a as approximateClusteringCoefficient, i as shannonEntropy, n as localTypeEntropy, o as batchClusteringCoefficients, r as normalisedEntropy, s as localClusteringCoefficient, t as entropyFromCounts } from "../utils-Q_akvlMn.js";
+export { approximateClusteringCoefficient, batchClusteringCoefficients, entropyFromCounts, localClusteringCoefficient, localTypeEntropy, miniBatchKMeans, normaliseFeatures, normaliseFeatures as zScoreNormalise, normalisedEntropy, shannonEntropy };

package/dist/utils/kmeans.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Minimal K-means clustering implementation for GRASP seed selection.
+ *
+ * This is a lightweight implementation specifically designed for 3D feature vectors
+ * used in structural seed selection. For general-purpose clustering, consider
+ * using a dedicated library.
+ *
+ * @packageDocumentation
+ */
+/**
+ * A 3D feature vector representing node structural properties.
+ */
+export interface FeatureVector3D {
+    /** First dimension (e.g., log-degree) */
+    readonly f1: number;
+    /** Second dimension (e.g., clustering coefficient) */
+    readonly f2: number;
+    /** Third dimension (e.g., approximate PageRank) */
+    readonly f3: number;
+}
+/**
+ * A labelled feature vector with associated node ID.
+ */
+export interface LabelledFeature extends FeatureVector3D {
+    /** Node identifier */
+    readonly nodeId: string;
+}
+/**
+ * Result of K-means clustering.
+ */
+export interface KMeansResult {
+    /** Cluster centroids */
+    readonly centroids: readonly FeatureVector3D[];
+    /** Cluster assignments: nodeId -> cluster index */
+    readonly assignments: ReadonlyMap<string, number>;
+    /** Number of clusters */
+    readonly k: number;
+}
+/**
+ * Options for K-means clustering.
+ */
+export interface KMeansOptions {
+    /** Number of clusters */
+    readonly k: number;
+    /** Maximum iterations (default: 100) */
+    readonly maxIterations?: number;
+    /** Convergence threshold (default: 1e-6) */
+    readonly tolerance?: number;
+    /** Random seed for reproducibility */
+    readonly seed?: number;
+}
+/**
+ * Compute the mean of a set of feature vectors.
+ * @internal - Used for testing
+ */
+export declare function _computeMean(vectors: readonly FeatureVector3D[]): FeatureVector3D;
+/**
+ * Z-score normalise features (zero mean, unit variance).
+ */
+export { normaliseFeatures as zScoreNormalise };
+export declare function normaliseFeatures(features: readonly LabelledFeature[]): LabelledFeature[];
+/**
+ * Mini-batch K-means clustering for 3D feature vectors.
+ *
+ * Uses Mini-batch K-means for efficiency with large datasets.
+ * This is specifically designed for the GRASP seed selection algorithm.
+ *
+ * @param features - Array of labelled feature vectors
+ * @param options - Clustering options
+ * @returns Clustering result with centroids and assignments
+ */
+export declare function miniBatchKMeans(features: readonly LabelledFeature[], options: KMeansOptions): KMeansResult;
+//# sourceMappingURL=kmeans.d.ts.map

package/dist/utils/kmeans.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kmeans.d.ts","sourceRoot":"","sources":["../../src/utils/kmeans.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC/B,yCAAyC;IACzC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,eAAgB,SAAQ,eAAe;IACvD,sBAAsB;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC5B,wBAAwB;IACxB,QAAQ,CAAC,SAAS,EAAE,SAAS,eAAe,EAAE,CAAC;IAC/C,mDAAmD;IACnD,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD,yBAAyB;IACzB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,yBAAyB;IACzB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,4CAA4C;IAC5C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,sCAAsC;IACtC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACvB;AA4BD;;;GAGG;AACH,wBAAgB,YAAY,CAC3B,OAAO,EAAE,SAAS,eAAe,EAAE,GACjC,eAAe,CAcjB;AAED;;GAEG;AACH,OAAO,EAAE,iBAAiB,IAAI,eAAe,EAAE,CAAC;AAEhD,wBAAgB,iBAAiB,CAChC,QAAQ,EAAE,SAAS,eAAe,EAAE,GAClC,eAAe,EAAE,CAyCnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC9B,QAAQ,EAAE,SAAS,eAAe,EAAE,EACpC,OAAO,EAAE,aAAa,GACpB,YAAY,CAiId"}

package/dist/utils/kmeans.unit.test.d.ts

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

package/dist/utils/kmeans.unit.test.d.ts.map

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

package/dist/utils-Q_akvlMn.js

@@ -0,0 +1,164 @@
+//#region src/utils/clustering-coefficient.ts
+/**
+* Compute the local clustering coefficient for a single node.
+*
+* The clustering coefficient is defined as:
+*   CC(v) = (triangles through v) / (possible triangles)
+*   CC(v) = 2 * |{(u,w) : u,w in N(v), (u,w) in E}| / (deg(v) * (deg(v) - 1))
+*
+* For nodes with degree < 2, the clustering coefficient is 0.
+*
+* @param graph - The graph to compute on
+* @param nodeId - The node to compute clustering coefficient for
+* @returns The clustering coefficient in [0, 1], or 0 if undefined
+*/
+function localClusteringCoefficient(graph, nodeId) {
+	const neighbours = [...graph.neighbours(nodeId, "both")];
+	const degree = neighbours.length;
+	if (degree < 2) return 0;
+	let triangleCount = 0;
+	for (let i = 0; i < neighbours.length; i++) {
+		const u = neighbours[i];
+		if (u === void 0) continue;
+		for (let j = i + 1; j < neighbours.length; j++) {
+			const w = neighbours[j];
+			if (w === void 0) continue;
+			if (graph.getEdge(u, w) !== void 0 || graph.getEdge(w, u) !== void 0) triangleCount++;
+		}
+	}
+	const possibleTriangles = degree * (degree - 1) / 2;
+	return triangleCount / possibleTriangles;
+}
+/**
+* Compute approximate local clustering coefficient using sampling.
+*
+* For nodes with many neighbours, this samples neighbour pairs rather than
+* checking all pairs. Useful for large graphs where exact computation is expensive.
+*
+* @param graph - The graph to compute on
+* @param nodeId - The node to compute clustering coefficient for
+* @param sampleSize - Maximum number of neighbour pairs to check (default: 100)
+* @returns The approximate clustering coefficient in [0, 1]
+*/
+function approximateClusteringCoefficient(graph, nodeId, sampleSize = 100) {
+	const neighbours = [...graph.neighbours(nodeId, "both")];
+	const degree = neighbours.length;
+	if (degree < 2) return 0;
+	const possibleTriangles = degree * (degree - 1) / 2;
+	if (possibleTriangles <= sampleSize) return localClusteringCoefficient(graph, nodeId);
+	let triangleCount = 0;
+	let sampled = 0;
+	for (let i = 0; i < neighbours.length && sampled < sampleSize; i++) {
+		const u = neighbours[i];
+		if (u === void 0) continue;
+		for (let j = i + 1; j < neighbours.length && sampled < sampleSize; j++) {
+			const w = neighbours[j];
+			if (w === void 0) continue;
+			sampled++;
+			if (graph.getEdge(u, w) !== void 0 || graph.getEdge(w, u) !== void 0) triangleCount++;
+		}
+	}
+	return triangleCount / sampled * (possibleTriangles / possibleTriangles);
+}
+/**
+* Compute clustering coefficients for multiple nodes efficiently.
+*
+* Reuses neighbour sets to avoid repeated iteration.
+*
+* @param graph - The graph to compute on
+* @param nodeIds - The nodes to compute clustering coefficients for
+* @returns Map from nodeId to clustering coefficient
+*/
+function batchClusteringCoefficients(graph, nodeIds) {
+	const results = /* @__PURE__ */ new Map();
+	for (const nodeId of nodeIds) results.set(nodeId, localClusteringCoefficient(graph, nodeId));
+	return results;
+}
+//#endregion
+//#region src/utils/entropy.ts
+/**
+* Entropy computation utilities for graph analysis.
+*
+* Shannon entropy measures uncertainty or randomness in a distribution.
+* Used in EDGE and HAE algorithms for heterogeneity-aware expansion.
+*
+* @packageDocumentation
+*/
+/**
+* Compute Shannon entropy of a probability distribution.
+*
+* Shannon entropy is defined as:
+*   H(X) = -Σ p(x) × log₂(p(x))
+*
+* A uniform distribution has maximum entropy.
+* A deterministic distribution (all probability on one value) has zero entropy.
+*
+* @param probabilities - Array of probabilities (should sum to 1)
+* @returns Entropy in bits (log base 2), or 0 if probabilities are invalid
+*/
+function shannonEntropy(probabilities) {
+	if (probabilities.length === 0) return 0;
+	let entropy = 0;
+	for (const p of probabilities) if (p > 0) entropy -= p * Math.log2(p);
+	return entropy;
+}
+/**
+* Compute normalised entropy (entropy divided by maximum possible entropy).
+*
+* Normalised entropy is in [0, 1], where:
+* - 0 means the distribution is deterministic (all mass on one value)
+* - 1 means the distribution is uniform (maximum uncertainty)
+*
+* This is useful for comparing entropy across distributions with different
+* numbers of possible values.
+*
+* @param probabilities - Array of probabilities (should sum to 1)
+* @returns Normalised entropy in [0, 1], or 0 if only one category
+*/
+function normalisedEntropy(probabilities) {
+	if (probabilities.length <= 1) return 0;
+	const H = shannonEntropy(probabilities);
+	const Hmax = Math.log2(probabilities.length);
+	if (Hmax === 0) return 0;
+	return H / Hmax;
+}
+/**
+* Compute entropy from a frequency count.
+*
+* Converts counts to probabilities and then computes entropy.
+* This is a convenience function when you have raw counts rather than
+* normalised probabilities.
+*
+* @param counts - Array of frequency counts
+* @returns Entropy in bits
+*/
+function entropyFromCounts(counts) {
+	if (counts.length === 0) return 0;
+	const total = counts.reduce((sum, c) => sum + c, 0);
+	if (total === 0) return 0;
+	return shannonEntropy(counts.map((c) => c / total));
+}
+/**
+* Compute local type entropy for a node's neighbours.
+*
+* This measures the diversity of types among a node's neighbours.
+* High entropy = heterogeneous neighbourhood (diverse types).
+* Low entropy = homogeneous neighbourhood (similar types).
+*
+* @param neighbourTypes - Array of type labels for neighbours
+* @returns Normalised entropy in [0, 1]
+*/
+function localTypeEntropy(neighbourTypes) {
+	if (neighbourTypes.length <= 1) return 0;
+	const typeCounts = /* @__PURE__ */ new Map();
+	for (const t of neighbourTypes) typeCounts.set(t, (typeCounts.get(t) ?? 0) + 1);
+	if (typeCounts.size === 1) return 0;
+	const probabilities = [];
+	const total = neighbourTypes.length;
+	for (const count of typeCounts.values()) probabilities.push(count / total);
+	return normalisedEntropy(probabilities);
+}
+//#endregion
+export { approximateClusteringCoefficient as a, shannonEntropy as i, localTypeEntropy as n, batchClusteringCoefficients as o, normalisedEntropy as r, localClusteringCoefficient as s, entropyFromCounts as t };
+
+//# sourceMappingURL=utils-Q_akvlMn.js.map

package/dist/utils-Q_akvlMn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-Q_akvlMn.js","names":[],"sources":["../src/utils/clustering-coefficient.ts","../src/utils/entropy.ts"],"sourcesContent":["/**\n * Clustering coefficient computation for graph nodes.\n *\n * The local clustering coefficient measures how close a node's neighbours\n * are to being a complete graph (clique). It is used in SPAN MI variant\n * and GRASP seed selection.\n *\n * @packageDocumentation\n */\n\nimport type { ReadableGraph, NodeId } from \"../graph\";\n\n/**\n * Compute the local clustering coefficient for a single node.\n *\n * The clustering coefficient is defined as:\n *   CC(v) = (triangles through v) / (possible triangles)\n *   CC(v) = 2 * |{(u,w) : u,w in N(v), (u,w) in E}| / (deg(v) * (deg(v) - 1))\n *\n * For nodes with degree < 2, the clustering coefficient is 0.\n *\n * @param graph - The graph to compute on\n * @param nodeId - The node to compute clustering coefficient for\n * @returns The clustering coefficient in [0, 1], or 0 if undefined\n */\nexport function localClusteringCoefficient(\n\tgraph: ReadableGraph,\n\tnodeId: NodeId,\n): number {\n\tconst neighbours = [...graph.neighbours(nodeId, \"both\")];\n\tconst degree = neighbours.length;\n\n\t// Nodes with degree < 2 have no possible triangles\n\tif (degree < 2) {\n\t\treturn 0;\n\t}\n\n\t// Count actual triangles: pairs of neighbours that are connected\n\tlet triangleCount = 0;\n\n\tfor (let i = 0; i < neighbours.length; i++) {\n\t\tconst u = neighbours[i];\n\t\tif (u === undefined) continue;\n\n\t\tfor (let j = i + 1; j < neighbours.length; j++) {\n\t\t\tconst w = neighbours[j];\n\t\t\tif (w === undefined) continue;\n\n\t\t\t// Check if u and w are connected\n\t\t\tif (\n\t\t\t\tgraph.getEdge(u, w) !== undefined ||\n\t\t\t\tgraph.getEdge(w, u) !== undefined\n\t\t\t) {\n\t\t\t\ttriangleCount++;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Possible triangles: deg * (deg - 1) / 2 pairs\n\t// We multiply by 2 because each triangle is counted once\n\tconst possibleTriangles = (degree * (degree - 1)) / 2;\n\n\treturn triangleCount / possibleTriangles;\n}\n\n/**\n * Compute approximate local clustering coefficient using sampling.\n *\n * For nodes with many neighbours, this samples neighbour pairs rather than\n * checking all pairs. Useful for large graphs where exact computation is expensive.\n *\n * @param graph - The graph to compute on\n * @param nodeId - The node to compute clustering coefficient for\n * @param sampleSize - Maximum number of neighbour pairs to check (default: 100)\n * @returns The approximate clustering coefficient in [0, 1]\n */\nexport function approximateClusteringCoefficient(\n\tgraph: ReadableGraph,\n\tnodeId: NodeId,\n\tsampleSize = 100,\n): number {\n\tconst neighbours = [...graph.neighbours(nodeId, \"both\")];\n\tconst degree = neighbours.length;\n\n\tif (degree < 2) {\n\t\treturn 0;\n\t}\n\n\tconst possibleTriangles = (degree * (degree - 1)) / 2;\n\n\t// If all pairs can be checked within sample limit, use exact computation\n\tif (possibleTriangles <= sampleSize) {\n\t\treturn localClusteringCoefficient(graph, nodeId);\n\t}\n\n\t// Sample pairs uniformly\n\tlet triangleCount = 0;\n\tlet sampled = 0;\n\n\t// Use reservoir sampling style approach for pair selection\n\tfor (let i = 0; i < neighbours.length && sampled < sampleSize; i++) {\n\t\tconst u = neighbours[i];\n\t\tif (u === undefined) continue;\n\n\t\tfor (let j = i + 1; j < neighbours.length && sampled < sampleSize; j++) {\n\t\t\tconst w = neighbours[j];\n\t\t\tif (w === undefined) continue;\n\n\t\t\t// Decide whether to include this pair based on remaining budget\n\t\t\tsampled++;\n\n\t\t\t// Check if u and w are connected\n\t\t\tif (\n\t\t\t\tgraph.getEdge(u, w) !== undefined ||\n\t\t\t\tgraph.getEdge(w, u) !== undefined\n\t\t\t) {\n\t\t\t\ttriangleCount++;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Extrapolate from sample\n\treturn (triangleCount / sampled) * (possibleTriangles / possibleTriangles);\n}\n\n/**\n * Compute clustering coefficients for multiple nodes efficiently.\n *\n * Reuses neighbour sets to avoid repeated iteration.\n *\n * @param graph - The graph to compute on\n * @param nodeIds - The nodes to compute clustering coefficients for\n * @returns Map from nodeId to clustering coefficient\n */\nexport function batchClusteringCoefficients(\n\tgraph: ReadableGraph,\n\tnodeIds: readonly NodeId[],\n): Map<NodeId, number> {\n\tconst results = new Map<NodeId, number>();\n\n\tfor (const nodeId of nodeIds) {\n\t\tresults.set(nodeId, localClusteringCoefficient(graph, nodeId));\n\t}\n\n\treturn results;\n}\n","/**\n * Entropy computation utilities for graph analysis.\n *\n * Shannon entropy measures uncertainty or randomness in a distribution.\n * Used in EDGE and HAE algorithms for heterogeneity-aware expansion.\n *\n * @packageDocumentation\n */\n\n/**\n * Compute Shannon entropy of a probability distribution.\n *\n * Shannon entropy is defined as:\n *   H(X) = -Σ p(x) × log₂(p(x))\n *\n * A uniform distribution has maximum entropy.\n * A deterministic distribution (all probability on one value) has zero entropy.\n *\n * @param probabilities - Array of probabilities (should sum to 1)\n * @returns Entropy in bits (log base 2), or 0 if probabilities are invalid\n */\nexport function shannonEntropy(probabilities: readonly number[]): number {\n\tif (probabilities.length === 0) {\n\t\treturn 0;\n\t}\n\n\tlet entropy = 0;\n\tfor (const p of probabilities) {\n\t\t// Skip zero probabilities (log(0) is undefined, but 0 * log(0) = 0)\n\t\tif (p > 0) {\n\t\t\tentropy -= p * Math.log2(p);\n\t\t}\n\t}\n\n\treturn entropy;\n}\n\n/**\n * Compute normalised entropy (entropy divided by maximum possible entropy).\n *\n * Normalised entropy is in [0, 1], where:\n * - 0 means the distribution is deterministic (all mass on one value)\n * - 1 means the distribution is uniform (maximum uncertainty)\n *\n * This is useful for comparing entropy across distributions with different\n * numbers of possible values.\n *\n * @param probabilities - Array of probabilities (should sum to 1)\n * @returns Normalised entropy in [0, 1], or 0 if only one category\n */\nexport function normalisedEntropy(probabilities: readonly number[]): number {\n\tif (probabilities.length <= 1) {\n\t\treturn 0;\n\t}\n\n\tconst H = shannonEntropy(probabilities);\n\tconst Hmax = Math.log2(probabilities.length);\n\n\tif (Hmax === 0) {\n\t\treturn 0;\n\t}\n\n\treturn H / Hmax;\n}\n\n/**\n * Compute entropy from a frequency count.\n *\n * Converts counts to probabilities and then computes entropy.\n * This is a convenience function when you have raw counts rather than\n * normalised probabilities.\n *\n * @param counts - Array of frequency counts\n * @returns Entropy in bits\n */\nexport function entropyFromCounts(counts: readonly number[]): number {\n\tif (counts.length === 0) {\n\t\treturn 0;\n\t}\n\n\tconst total = counts.reduce((sum, c) => sum + c, 0);\n\tif (total === 0) {\n\t\treturn 0;\n\t}\n\n\tconst probabilities = counts.map((c) => c / total);\n\treturn shannonEntropy(probabilities);\n}\n\n/**\n * Compute local type entropy for a node's neighbours.\n *\n * This measures the diversity of types among a node's neighbours.\n * High entropy = heterogeneous neighbourhood (diverse types).\n * Low entropy = homogeneous neighbourhood (similar types).\n *\n * @param neighbourTypes - Array of type labels for neighbours\n * @returns Normalised entropy in [0, 1]\n */\nexport function localTypeEntropy(neighbourTypes: readonly string[]): number {\n\tif (neighbourTypes.length <= 1) {\n\t\treturn 0;\n\t}\n\n\t// Count occurrences of each type\n\tconst typeCounts = new Map<string, number>();\n\tfor (const t of neighbourTypes) {\n\t\ttypeCounts.set(t, (typeCounts.get(t) ?? 0) + 1);\n\t}\n\n\t// If all neighbours are the same type, entropy is 0\n\tif (typeCounts.size === 1) {\n\t\treturn 0;\n\t}\n\n\t// Convert to probability array\n\tconst probabilities: number[] = [];\n\tconst total = neighbourTypes.length;\n\tfor (const count of typeCounts.values()) {\n\t\tprobabilities.push(count / total);\n\t}\n\n\treturn normalisedEntropy(probabilities);\n}\n"],"mappings":"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"}