@c4a/graph-analytics 0.4.12-beta.14

package/index.js

@@ -0,0 +1,811 @@
+// src/leiden/network.ts
+var fill = (len, val = 0) => {
+  const arr = new Array(len);
+  for (let i = 0;i < len; i++)
+    arr[i] = val;
+  return arr;
+};
+var pairKey = (a, b) => a < b ? a * 1048576 + b : b * 1048576 + a;
+var buildNetwork = (adjacency) => {
+  const nodeIds = [];
+  const indexById = new Map;
+  const ensureNode = (id) => {
+    let idx = indexById.get(id);
+    if (idx !== undefined)
+      return idx;
+    idx = nodeIds.length;
+    nodeIds.push(id);
+    indexById.set(id, idx);
+    return idx;
+  };
+  for (const [source, edges] of adjacency.entries()) {
+    ensureNode(source);
+    for (const edge of edges)
+      ensureNode(edge.target);
+  }
+  const nNodes = nodeIds.length;
+  if (nNodes === 0) {
+    return {
+      network: {
+        nNodes: 0,
+        nEdges: 0,
+        nodeWeights: [],
+        firstNeighborIndices: [0],
+        neighbors: [],
+        edgeWeights: [],
+        totalEdgeWeightSelfLinks: 0
+      },
+      nodeIds
+    };
+  }
+  const edgeMap = new Map;
+  for (const [source, edges] of adjacency.entries()) {
+    const si = indexById.get(source);
+    for (const edge of edges) {
+      const ti = indexById.get(edge.target);
+      const key = pairKey(si, ti);
+      edgeMap.set(key, Math.max(edgeMap.get(key) ?? 0, edge.weight));
+    }
+  }
+  const adjLists = Array.from({ length: nNodes }, () => []);
+  let totalEdgeWeightSelfLinks = 0;
+  for (const [key, weight] of edgeMap.entries()) {
+    const a = Math.floor(key / 1048576);
+    const b = key % 1048576;
+    if (a === b) {
+      adjLists[a].push({ target: a, weight });
+      totalEdgeWeightSelfLinks += weight;
+    } else {
+      adjLists[a].push({ target: b, weight });
+      adjLists[b].push({ target: a, weight });
+    }
+  }
+  for (let i = 0;i < nNodes; i++) {
+    adjLists[i].sort((x, y) => x.target - y.target);
+  }
+  let nEdges = 0;
+  for (let i = 0;i < nNodes; i++)
+    nEdges += adjLists[i].length;
+  const firstNeighborIndices = fill(nNodes + 1);
+  const neighbors = fill(nEdges);
+  const edgeWeightsArr = fill(nEdges);
+  const nodeWeights = fill(nNodes);
+  let offset = 0;
+  for (let i = 0;i < nNodes; i++) {
+    firstNeighborIndices[i] = offset;
+    for (const e of adjLists[i]) {
+      neighbors[offset] = e.target;
+      edgeWeightsArr[offset] = e.weight;
+      offset++;
+    }
+    nodeWeights[i] = 1;
+  }
+  firstNeighborIndices[nNodes] = offset;
+  return {
+    network: {
+      nNodes,
+      nEdges,
+      nodeWeights,
+      firstNeighborIndices,
+      neighbors,
+      edgeWeights: edgeWeightsArr,
+      totalEdgeWeightSelfLinks
+    },
+    nodeIds
+  };
+};
+var getNodesPerCluster = (clusters, nClusters) => {
+  const result = Array.from({ length: nClusters }, () => []);
+  for (let i = 0;i < clusters.length; i++) {
+    result[clusters[i]].push(i);
+  }
+  return result;
+};
+var createSubnetworks = (network, clusters, nClusters) => {
+  const nodesPerCluster = getNodesPerCluster(clusters, nClusters);
+  const subnetworks = new Array(nClusters);
+  const subnetworkNodeMap = fill(network.nNodes, -1);
+  const tempNeighbors = fill(network.nEdges);
+  const tempEdgeWeights = fill(network.nEdges);
+  for (let c = 0;c < nClusters; c++) {
+    const nodes = nodesPerCluster[c];
+    const nSubNodes = nodes.length;
+    if (nSubNodes === 1) {
+      subnetworks[c] = {
+        nNodes: 1,
+        nEdges: 0,
+        nodeWeights: [network.nodeWeights[nodes[0]]],
+        firstNeighborIndices: [0, 0],
+        neighbors: [],
+        edgeWeights: [],
+        totalEdgeWeightSelfLinks: 0
+      };
+      continue;
+    }
+    for (let i = 0;i < nSubNodes; i++) {
+      subnetworkNodeMap[nodes[i]] = i;
+    }
+    const subNodeWeights = fill(nSubNodes);
+    const subFirstNeighbor = fill(nSubNodes + 1);
+    let subNEdges = 0;
+    for (let i = 0;i < nSubNodes; i++) {
+      const j = nodes[i];
+      subNodeWeights[i] = network.nodeWeights[j];
+      const start = network.firstNeighborIndices[j];
+      const end = network.firstNeighborIndices[j + 1];
+      for (let k = start;k < end; k++) {
+        const neighbor = network.neighbors[k];
+        if (clusters[neighbor] === c) {
+          tempNeighbors[subNEdges] = subnetworkNodeMap[neighbor];
+          tempEdgeWeights[subNEdges] = network.edgeWeights[k];
+          subNEdges++;
+        }
+      }
+      subFirstNeighbor[i + 1] = subNEdges;
+    }
+    subnetworks[c] = {
+      nNodes: nSubNodes,
+      nEdges: subNEdges,
+      nodeWeights: subNodeWeights,
+      firstNeighborIndices: subFirstNeighbor,
+      neighbors: tempNeighbors.slice(0, subNEdges),
+      edgeWeights: tempEdgeWeights.slice(0, subNEdges),
+      totalEdgeWeightSelfLinks: 0
+    };
+    for (let i = 0;i < nSubNodes; i++) {
+      subnetworkNodeMap[nodes[i]] = -1;
+    }
+  }
+  return { subnetworks, nodesPerCluster };
+};
+var createReducedNetwork = (network, clusters, nClusters) => {
+  const nodesPerCluster = getNodesPerCluster(clusters, nClusters);
+  let reducedNEdges = 0;
+  const reducedNodeWeights = fill(nClusters);
+  const reducedFirstNeighbor = fill(nClusters + 1);
+  let totalEdgeWeightSelfLinks = network.totalEdgeWeightSelfLinks;
+  const tempNeighbors = fill(network.nEdges);
+  const tempEdgeWeights = fill(network.nEdges);
+  const scatterWeights = fill(nClusters);
+  const scatterNeighbors = fill(nClusters);
+  for (let i = 0;i < nClusters; i++) {
+    const nodes = nodesPerCluster[i];
+    let j = 0;
+    for (let k = 0;k < nodes.length; k++) {
+      const node = nodes[k];
+      reducedNodeWeights[i] += network.nodeWeights[node];
+      const start = network.firstNeighborIndices[node];
+      const end = network.firstNeighborIndices[node + 1];
+      for (let m = start;m < end; m++) {
+        const neighborCluster = clusters[network.neighbors[m]];
+        if (neighborCluster !== i) {
+          if (scatterWeights[neighborCluster] === 0) {
+            scatterNeighbors[j] = neighborCluster;
+            j++;
+          }
+          scatterWeights[neighborCluster] += network.edgeWeights[m];
+        } else {
+          totalEdgeWeightSelfLinks += network.edgeWeights[m];
+        }
+      }
+    }
+    for (let k = 0;k < j; k++) {
+      const nc = scatterNeighbors[k];
+      tempNeighbors[reducedNEdges + k] = nc;
+      tempEdgeWeights[reducedNEdges + k] = scatterWeights[nc];
+      scatterWeights[nc] = 0;
+    }
+    reducedNEdges += j;
+    reducedFirstNeighbor[i + 1] = reducedNEdges;
+  }
+  return {
+    nNodes: nClusters,
+    nEdges: reducedNEdges,
+    nodeWeights: reducedNodeWeights,
+    firstNeighborIndices: reducedFirstNeighbor,
+    neighbors: tempNeighbors.slice(0, reducedNEdges),
+    edgeWeights: tempEdgeWeights.slice(0, reducedNEdges),
+    totalEdgeWeightSelfLinks
+  };
+};
+var getTotalNodeWeight = (network) => {
+  let sum = 0;
+  for (let i = 0;i < network.nNodes; i++)
+    sum += network.nodeWeights[i];
+  return sum;
+};
+
+// src/leiden/random.ts
+var createRandom = (seed) => {
+  let state = (seed ?? 2654435769) >>> 0;
+  if (state === 0)
+    state = 1;
+  const nextDouble = () => {
+    state ^= state << 13;
+    state ^= state >>> 17;
+    state ^= state << 5;
+    return (state >>> 0) / 4294967295;
+  };
+  return {
+    nextDouble,
+    nextInt: (bound) => Math.floor(nextDouble() * bound)
+  };
+};
+var generateRandomPermutation = (n, random) => {
+  const perm = new Array(n);
+  for (let i = 0;i < n; i++) {
+    perm[i] = i;
+  }
+  for (let i = 0;i < n; i++) {
+    const j = random.nextInt(n);
+    const tmp = perm[i];
+    perm[i] = perm[j];
+    perm[j] = tmp;
+  }
+  return perm;
+};
+
+// src/leiden/fastLocalMoving.ts
+var fill2 = (len, val = 0) => {
+  const arr = new Array(len);
+  for (let i = 0;i < len; i++)
+    arr[i] = val;
+  return arr;
+};
+var removeEmptyClusters = (clustering) => {
+  const map = new Map;
+  for (let i = 0;i < clustering.clusters.length; i++) {
+    const c = clustering.clusters[i];
+    if (!map.has(c))
+      map.set(c, map.size);
+    clustering.clusters[i] = map.get(c);
+  }
+  clustering.nClusters = map.size;
+};
+var fastLocalMoving = (network, clustering, resolution, random) => {
+  if (network.nNodes === 1)
+    return false;
+  let update = false;
+  const n = network.nNodes;
+  const clusterWeights = fill2(n);
+  const nNodesPerCluster = fill2(n);
+  for (let i2 = 0;i2 < n; i2++) {
+    clusterWeights[clustering.clusters[i2]] += network.nodeWeights[i2];
+    nNodesPerCluster[clustering.clusters[i2]]++;
+  }
+  let nUnusedClusters = 0;
+  const unusedClusters = fill2(n);
+  for (let i2 = n - 1;i2 >= 0; i2--) {
+    if (nNodesPerCluster[i2] === 0) {
+      unusedClusters[nUnusedClusters] = i2;
+      nUnusedClusters++;
+    }
+  }
+  const nodeOrder = generateRandomPermutation(n, random);
+  const edgeWeightPerCluster = fill2(n);
+  const neighboringClusters = fill2(n);
+  const stableNodes = fill2(n);
+  let nUnstableNodes = n;
+  let i = 0;
+  do {
+    const j = nodeOrder[i];
+    const currentCluster = clustering.clusters[j];
+    clusterWeights[currentCluster] -= network.nodeWeights[j];
+    nNodesPerCluster[currentCluster]--;
+    if (nNodesPerCluster[currentCluster] === 0) {
+      unusedClusters[nUnusedClusters] = currentCluster;
+      nUnusedClusters++;
+    }
+    neighboringClusters[0] = unusedClusters[nUnusedClusters - 1];
+    let nNeighboringClusters = 1;
+    const jStart = network.firstNeighborIndices[j];
+    const jEnd = network.firstNeighborIndices[j + 1];
+    for (let k = jStart;k < jEnd; k++) {
+      const l = clustering.clusters[network.neighbors[k]];
+      if (edgeWeightPerCluster[l] === 0) {
+        neighboringClusters[nNeighboringClusters] = l;
+        nNeighboringClusters++;
+      }
+      edgeWeightPerCluster[l] += network.edgeWeights[k];
+    }
+    let bestCluster = currentCluster;
+    let maxIncrement = edgeWeightPerCluster[currentCluster] - network.nodeWeights[j] * clusterWeights[currentCluster] * resolution;
+    for (let k = 0;k < nNeighboringClusters; k++) {
+      const l = neighboringClusters[k];
+      const increment = edgeWeightPerCluster[l] - network.nodeWeights[j] * clusterWeights[l] * resolution;
+      if (increment > maxIncrement) {
+        bestCluster = l;
+        maxIncrement = increment;
+      }
+      edgeWeightPerCluster[l] = 0;
+    }
+    clusterWeights[bestCluster] += network.nodeWeights[j];
+    nNodesPerCluster[bestCluster]++;
+    if (bestCluster === unusedClusters[nUnusedClusters - 1]) {
+      nUnusedClusters--;
+    }
+    stableNodes[j] = 1;
+    nUnstableNodes--;
+    if (bestCluster !== currentCluster) {
+      clustering.clusters[j] = bestCluster;
+      if (bestCluster >= clustering.nClusters) {
+        clustering.nClusters = bestCluster + 1;
+      }
+      for (let k = jStart;k < jEnd; k++) {
+        const neighbor = network.neighbors[k];
+        if (stableNodes[neighbor] === 1 && clustering.clusters[neighbor] !== bestCluster) {
+          stableNodes[neighbor] = 0;
+          nUnstableNodes++;
+          const queueIdx = i + nUnstableNodes < n ? i + nUnstableNodes : i + nUnstableNodes - n;
+          nodeOrder[queueIdx] = neighbor;
+        }
+      }
+      update = true;
+    }
+    i = i < n - 1 ? i + 1 : 0;
+  } while (nUnstableNodes > 0);
+  if (update) {
+    removeEmptyClusters(clustering);
+  }
+  return update;
+};
+
+// src/leiden/fastMath.ts
+var fastExp = (exponent) => {
+  if (exponent < -256)
+    return 0;
+  exponent = 1 + exponent / 256;
+  exponent *= exponent;
+  exponent *= exponent;
+  exponent *= exponent;
+  exponent *= exponent;
+  exponent *= exponent;
+  exponent *= exponent;
+  exponent *= exponent;
+  exponent *= exponent;
+  return exponent;
+};
+
+// src/leiden/localMerging.ts
+var fill3 = (len, val = 0) => {
+  const arr = new Array(len);
+  for (let i = 0;i < len; i++)
+    arr[i] = val;
+  return arr;
+};
+var removeEmptyClusters2 = (clustering) => {
+  const map = new Map;
+  for (let i = 0;i < clustering.clusters.length; i++) {
+    const c = clustering.clusters[i];
+    if (!map.has(c))
+      map.set(c, map.size);
+    clustering.clusters[i] = map.get(c);
+  }
+  clustering.nClusters = map.size;
+};
+var localMerging = (network, resolution, randomness, random) => {
+  const n = network.nNodes;
+  const clusters = fill3(n);
+  for (let i = 0;i < n; i++)
+    clusters[i] = i;
+  const clustering = { clusters, nClusters: n };
+  if (n === 1)
+    return clustering;
+  let updated = false;
+  const totalNodeWeight = getTotalNodeWeight(network);
+  const clusterWeights = fill3(n);
+  for (let i = 0;i < n; i++)
+    clusterWeights[i] = network.nodeWeights[i];
+  const nonSingletonClusters = fill3(n);
+  const externalEdgeWeightPerCluster = fill3(n);
+  for (let i = 0;i < n; i++) {
+    let sum = 0;
+    const start = network.firstNeighborIndices[i];
+    const end = network.firstNeighborIndices[i + 1];
+    for (let k = start;k < end; k++)
+      sum += network.edgeWeights[k];
+    externalEdgeWeightPerCluster[i] = sum;
+  }
+  const nodeOrder = generateRandomPermutation(n, random);
+  const edgeWeightPerCluster = fill3(n);
+  const neighboringClusters = fill3(n);
+  const cumTransformed = fill3(n);
+  for (let idx = 0;idx < n; idx++) {
+    const j = nodeOrder[idx];
+    if (nonSingletonClusters[j] === 1)
+      continue;
+    if (externalEdgeWeightPerCluster[j] < clusterWeights[j] * (totalNodeWeight - clusterWeights[j]) * resolution) {
+      continue;
+    }
+    clusterWeights[j] = 0;
+    externalEdgeWeightPerCluster[j] = 0;
+    neighboringClusters[0] = j;
+    let nNeighboringClusters = 1;
+    const jStart = network.firstNeighborIndices[j];
+    const jEnd = network.firstNeighborIndices[j + 1];
+    for (let k = jStart;k < jEnd; k++) {
+      const l = clustering.clusters[network.neighbors[k]];
+      if (edgeWeightPerCluster[l] === 0) {
+        neighboringClusters[nNeighboringClusters] = l;
+        nNeighboringClusters++;
+      }
+      edgeWeightPerCluster[l] += network.edgeWeights[k];
+    }
+    let bestCluster = j;
+    let maxIncrement = 0;
+    let totalTransformed = 0;
+    for (let k = 0;k < nNeighboringClusters; k++) {
+      const l = neighboringClusters[k];
+      if (externalEdgeWeightPerCluster[l] >= clusterWeights[l] * (totalNodeWeight - clusterWeights[l]) * resolution) {
+        const increment = edgeWeightPerCluster[l] - network.nodeWeights[j] * clusterWeights[l] * resolution;
+        if (increment > maxIncrement) {
+          bestCluster = l;
+          maxIncrement = increment;
+        }
+        if (increment >= 0) {
+          totalTransformed += fastExp(increment / randomness);
+        }
+      }
+      cumTransformed[k] = totalTransformed;
+      edgeWeightPerCluster[l] = 0;
+    }
+    let chosenCluster;
+    if (totalTransformed < Number.POSITIVE_INFINITY) {
+      const r = totalTransformed * random.nextDouble();
+      let lo = -1;
+      let hi = nNeighboringClusters + 1;
+      while (lo < hi - 1) {
+        const mid = lo + hi >>> 1;
+        if (cumTransformed[mid] >= r) {
+          hi = mid;
+        } else {
+          lo = mid;
+        }
+      }
+      chosenCluster = neighboringClusters[hi];
+    } else {
+      chosenCluster = bestCluster;
+    }
+    clusterWeights[chosenCluster] += network.nodeWeights[j];
+    for (let k = jStart;k < jEnd; k++) {
+      if (clustering.clusters[network.neighbors[k]] === chosenCluster) {
+        externalEdgeWeightPerCluster[chosenCluster] -= network.edgeWeights[k];
+      } else {
+        externalEdgeWeightPerCluster[chosenCluster] += network.edgeWeights[k];
+      }
+    }
+    if (chosenCluster !== j) {
+      clustering.clusters[j] = chosenCluster;
+      nonSingletonClusters[chosenCluster] = 1;
+      updated = true;
+    }
+  }
+  if (updated) {
+    removeEmptyClusters2(clustering);
+  }
+  return clustering;
+};
+
+// src/leiden/leidenAlgorithm.ts
+var fill4 = (len, val = 0) => {
+  const arr = new Array(len);
+  for (let i = 0;i < len; i++)
+    arr[i] = val;
+  return arr;
+};
+var improveClusteringOneIteration = (network, clustering, config) => {
+  const { resolution, randomness, random } = config;
+  let update = fastLocalMoving(network, clustering, resolution, random);
+  if (clustering.nClusters >= network.nNodes)
+    return update;
+  const { subnetworks, nodesPerCluster } = createSubnetworks(network, clustering.clusters, clustering.nClusters);
+  const refinement = {
+    clusters: fill4(network.nNodes),
+    nClusters: 0
+  };
+  for (let i = 0;i < subnetworks.length; i++) {
+    const subClustering = localMerging(subnetworks[i], resolution, randomness, random);
+    const nodes = nodesPerCluster[i];
+    for (let j = 0;j < subnetworks[i].nNodes; j++) {
+      refinement.clusters[nodes[j]] = refinement.nClusters + subClustering.clusters[j];
+    }
+    refinement.nClusters += subClustering.nClusters;
+  }
+  let reducedNetwork;
+  let reducedClustering;
+  if (refinement.nClusters < network.nNodes) {
+    reducedNetwork = createReducedNetwork(network, refinement.clusters, refinement.nClusters);
+    const reducedClusters = fill4(refinement.nClusters);
+    for (let i = 0;i < network.nNodes; i++) {
+      reducedClusters[refinement.clusters[i]] = clustering.clusters[i];
+    }
+    reducedClustering = {
+      clusters: reducedClusters,
+      nClusters: clustering.nClusters
+    };
+    clustering.clusters = refinement.clusters;
+    clustering.nClusters = refinement.nClusters;
+  } else {
+    reducedNetwork = createReducedNetwork(network, clustering.clusters, clustering.nClusters);
+    const reducedClusters = fill4(reducedNetwork.nNodes);
+    for (let i = 0;i < reducedNetwork.nNodes; i++)
+      reducedClusters[i] = i;
+    reducedClustering = {
+      clusters: reducedClusters,
+      nClusters: reducedNetwork.nNodes
+    };
+  }
+  const update2 = improveClusteringOneIteration(reducedNetwork, reducedClustering, config);
+  update = update || update2;
+  for (let i = 0;i < network.nNodes; i++) {
+    clustering.clusters[i] = reducedClustering.clusters[clustering.clusters[i]];
+  }
+  clustering.nClusters = reducedClustering.nClusters;
+  return update;
+};
+var runLeiden = (network, config) => {
+  const n = network.nNodes;
+  const clusters = fill4(n);
+  for (let i = 0;i < n; i++)
+    clusters[i] = i;
+  const clustering = { clusters, nClusters: n };
+  if (n <= 1)
+    return clustering;
+  if (config.nIterations > 0) {
+    for (let i = 0;i < config.nIterations; i++) {
+      improveClusteringOneIteration(network, clustering, config);
+    }
+  } else {
+    while (improveClusteringOneIteration(network, clustering, config)) {}
+  }
+  return clustering;
+};
+
+// src/leiden/index.ts
+var leiden = (graph, options = {}) => {
+  const { network, nodeIds } = buildNetwork(graph);
+  if (network.nNodes === 0)
+    return [];
+  const clustering = runLeiden(network, {
+    resolution: options.resolution ?? 1,
+    randomness: options.randomness ?? 0.01,
+    nIterations: options.nIterations ?? 0,
+    random: createRandom(options.randomSeed)
+  });
+  const results = [];
+  for (let i = 0;i < network.nNodes; i++) {
+    results.push({
+      entityId: nodeIds[i],
+      communityId: String(clustering.clusters[i]),
+      level: 0
+    });
+  }
+  return results;
+};
+// src/pagerank.ts
+var buildIndex = (graph) => {
+  const nodeIds = [];
+  const indexById = new Map;
+  const ensure = (id) => {
+    const existing = indexById.get(id);
+    if (existing !== undefined) {
+      return existing;
+    }
+    const index = nodeIds.length;
+    nodeIds.push(id);
+    indexById.set(id, index);
+    return index;
+  };
+  for (const [source, edges] of graph.entries()) {
+    ensure(source);
+    for (const edge of edges) {
+      ensure(edge.target);
+    }
+  }
+  return { nodeIds, indexById };
+};
+var normalizeEdges = (graph, indexById) => {
+  const edges = Array.from({ length: indexById.size }, () => []);
+  for (const [source, outgoing] of graph.entries()) {
+    const sourceIndex = indexById.get(source);
+    if (sourceIndex === undefined) {
+      continue;
+    }
+    for (const edge of outgoing) {
+      const targetIndex = indexById.get(edge.target);
+      if (targetIndex === undefined) {
+        continue;
+      }
+      edges[sourceIndex].push({ target: targetIndex, weight: edge.weight });
+    }
+  }
+  return edges;
+};
+var pagerank = (graph, options = {}) => {
+  const damping = options.damping ?? 0.85;
+  const maxIterations = options.maxIterations ?? 100;
+  const epsilon = options.epsilon ?? 0.000001;
+  const { nodeIds, indexById } = buildIndex(graph);
+  const count = nodeIds.length;
+  if (count === 0) {
+    return [];
+  }
+  const edges = normalizeEdges(graph, indexById);
+  const outWeight = new Float64Array(count);
+  for (let i = 0;i < count; i += 1) {
+    let sum = 0;
+    for (const edge of edges[i]) {
+      sum += edge.weight;
+    }
+    outWeight[i] = sum;
+  }
+  let ranks = new Float64Array(count);
+  let next = new Float64Array(count);
+  const initRank = 1 / count;
+  for (let i = 0;i < count; i += 1) {
+    ranks[i] = initRank;
+  }
+  for (let iteration = 0;iteration < maxIterations; iteration += 1) {
+    let danglingMass = 0;
+    for (let i = 0;i < count; i += 1) {
+      if (outWeight[i] === 0) {
+        danglingMass += ranks[i];
+      }
+    }
+    const base = (1 - damping) / count;
+    const danglingShare = damping * danglingMass / count;
+    for (let i = 0;i < count; i += 1) {
+      next[i] = base + danglingShare;
+    }
+    for (let i = 0;i < count; i += 1) {
+      const weight = outWeight[i];
+      if (weight === 0) {
+        continue;
+      }
+      for (const edge of edges[i]) {
+        next[edge.target] = (next[edge.target] ?? 0) + damping * (ranks[i] * edge.weight) / weight;
+      }
+    }
+    let delta = 0;
+    for (let i = 0;i < count; i += 1) {
+      delta += Math.abs(next[i] - ranks[i]);
+    }
+    const temp = ranks;
+    ranks = next;
+    next = temp;
+    if (delta < epsilon) {
+      break;
+    }
+  }
+  const results = [];
+  for (let i = 0;i < count; i += 1) {
+    results.push({ entityId: nodeIds[i], rank: ranks[i] });
+  }
+  return results;
+};
+// src/ppr.ts
+var buildIndex2 = (graph) => {
+  const nodeIds = [];
+  const indexById = new Map;
+  const ensure = (id) => {
+    const existing = indexById.get(id);
+    if (existing !== undefined) {
+      return existing;
+    }
+    const index = nodeIds.length;
+    nodeIds.push(id);
+    indexById.set(id, index);
+    return index;
+  };
+  for (const [source, edges] of graph.entries()) {
+    ensure(source);
+    for (const edge of edges) {
+      ensure(edge.target);
+    }
+  }
+  return { nodeIds, indexById };
+};
+var normalizeEdges2 = (graph, indexById) => {
+  const edges = Array.from({ length: indexById.size }, () => []);
+  for (const [source, outgoing] of graph.entries()) {
+    const sourceIndex = indexById.get(source);
+    if (sourceIndex === undefined) {
+      continue;
+    }
+    for (const edge of outgoing) {
+      const targetIndex = indexById.get(edge.target);
+      if (targetIndex === undefined) {
+        continue;
+      }
+      edges[sourceIndex].push({ target: targetIndex, weight: edge.weight });
+    }
+  }
+  return edges;
+};
+var personalizedPageRank = (graph, seedIds, options = {}) => {
+  const alpha = options.alpha ?? 0.85;
+  const maxIterations = options.maxIterations ?? 100;
+  const epsilon = options.epsilon ?? 0.000001;
+  const { nodeIds, indexById } = buildIndex2(graph);
+  const count = nodeIds.length;
+  if (count === 0) {
+    return [];
+  }
+  const edges = normalizeEdges2(graph, indexById);
+  const outWeight = new Float64Array(count);
+  for (let i = 0;i < count; i += 1) {
+    let sum = 0;
+    for (const edge of edges[i]) {
+      sum += edge.weight;
+    }
+    outWeight[i] = sum;
+  }
+  const teleport = new Float64Array(count);
+  const seedSet = new Set(seedIds);
+  let seedCount = 0;
+  for (let i = 0;i < count; i += 1) {
+    if (seedSet.has(nodeIds[i])) {
+      seedCount += 1;
+    }
+  }
+  if (seedCount === 0) {
+    seedCount = count;
+    for (let i = 0;i < count; i += 1) {
+      teleport[i] = 1 / count;
+    }
+  } else {
+    for (let i = 0;i < count; i += 1) {
+      teleport[i] = seedSet.has(nodeIds[i]) ? 1 / seedCount : 0;
+    }
+  }
+  let ranks = new Float64Array(count);
+  let next = new Float64Array(count);
+  for (let i = 0;i < count; i += 1) {
+    ranks[i] = teleport[i];
+  }
+  for (let iteration = 0;iteration < maxIterations; iteration += 1) {
+    for (let i = 0;i < count; i += 1) {
+      next[i] = (1 - alpha) * teleport[i];
+    }
+    let danglingMass = 0;
+    for (let i = 0;i < count; i += 1) {
+      if (outWeight[i] === 0) {
+        danglingMass += ranks[i];
+      }
+    }
+    for (let i = 0;i < count; i += 1) {
+      if (outWeight[i] === 0) {
+        continue;
+      }
+      for (const edge of edges[i]) {
+        next[edge.target] = (next[edge.target] ?? 0) + alpha * (ranks[i] * edge.weight) / outWeight[i];
+      }
+    }
+    if (danglingMass > 0) {
+      const danglingShare = alpha * danglingMass;
+      for (let i = 0;i < count; i += 1) {
+        next[i] = (next[i] ?? 0) + danglingShare * teleport[i];
+      }
+    }
+    let delta = 0;
+    for (let i = 0;i < count; i += 1) {
+      delta += Math.abs(next[i] - ranks[i]);
+    }
+    const temp = ranks;
+    ranks = next;
+    next = temp;
+    if (delta < epsilon) {
+      break;
+    }
+  }
+  const results = [];
+  for (let i = 0;i < count; i += 1) {
+    results.push({ entityId: nodeIds[i], rank: ranks[i] });
+  }
+  return results;
+};
+export {
+  personalizedPageRank,
+  pagerank,
+  leiden
+};

package/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@c4a/graph-analytics",
+  "version": "0.4.12-beta.14",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts"
+}