@graphty/algorithms 1.8.1 → 2.0.0

package/dist/algorithms.js

@@ -335,6 +335,23 @@ class Graph {
     return count;
   }
 }
+class ConvergenceError extends Error {
+  /**
+   * Builds the error and its message.
+   * @param algorithm - The function that gave up, e.g. `"eigenvectorCentrality"`
+   * @param iterations - The passes it ran, which is its `maxIterations`
+   * @param tolerance - The tolerance it did not meet
+   */
+  constructor(algorithm, iterations, tolerance) {
+    super(
+      `${algorithm} did not converge in ${String(iterations)} iterations (tolerance ${String(tolerance)}); raise maxIterations or tolerance`
+    );
+    this.algorithm = algorithm;
+    this.iterations = iterations;
+    this.tolerance = tolerance;
+    this.name = "ConvergenceError";
+  }
+}
 var lib = {};
 var SparseTypedFastBitSet = {};
 var utils = {};
@@ -3649,6 +3666,17 @@ function createTransposeGraph(graph) {
   }
   return transpose;
 }
+function relaxableArcs(graph) {
+  const arcs = [];
+  for (const edge of graph.edges()) {
+    const weight = edge.weight ?? 1;
+    arcs.push({ from: edge.source, to: edge.target, weight });
+    if (!graph.isDirected) {
+      arcs.push({ from: edge.target, to: edge.source, weight });
+    }
+  }
+  return arcs;
+}
 function bellmanFord(graph, source, options = {}) {
   if (!graph.hasNode(source)) {
     throw new Error(`Source node ${String(source)} not found in graph`);
@@ -3656,16 +3684,17 @@ function bellmanFord(graph, source, options = {}) {
   const distances = /* @__PURE__ */ new Map();
   const predecessors = /* @__PURE__ */ new Map();
   const nodes = Array.from(graph.nodes()).map((node) => node.id);
+  const arcs = relaxableArcs(graph);
   for (const nodeId of nodes) {
     distances.set(nodeId, nodeId === source ? 0 : Infinity);
     predecessors.set(nodeId, null);
   }
   for (let i = 0; i < nodes.length - 1; i++) {
     let updated = false;
-    for (const edge of Array.from(graph.edges())) {
-      const u = edge.source;
-      const v = edge.target;
-      const weight = edge.weight ?? 1;
+    for (const arc of arcs) {
+      const u = arc.from;
+      const v = arc.to;
+      const { weight } = arc;
       const distanceU = distances.get(u);
       const distanceV = distances.get(v);
       if (distanceU !== void 0 && distanceV !== void 0 && distanceU !== Infinity) {
@@ -3686,10 +3715,10 @@ function bellmanFord(graph, source, options = {}) {
   }
   const negativeCycleNodes = [];
   let hasNegativeCycle2 = false;
-  for (const edge of graph.edges()) {
-    const u = edge.source;
-    const v = edge.target;
-    const weight = edge.weight ?? 1;
+  for (const arc of arcs) {
+    const u = arc.from;
+    const v = arc.to;
+    const { weight } = arc;
     const distanceU = distances.get(u);
     const distanceV = distances.get(v);
     if (distanceU !== void 0 && distanceV !== void 0 && distanceU !== Infinity) {
@@ -5225,88 +5254,100 @@ class PriorityDeltaPageRank {
 }
 function eigenvectorCentrality(graph, options = {}) {
   const { maxIterations = 100, tolerance = 1e-6, normalized = true, startVector } = options;
+  const nodeIds = Array.from(graph.nodes(), (node) => node.id);
+  const keys = nodeIds.map((id) => id.toString());
+  const n = keys.length;
   const centrality = {};
-  const nodes = Array.from(graph.nodes());
-  const nodeIds = nodes.map((node) => node.id);
-  if (nodeIds.length === 0) {
+  if (n === 0) {
     return centrality;
   }
-  let currentVector = /* @__PURE__ */ new Map();
-  let previousVector = /* @__PURE__ */ new Map();
-  if (startVector) {
-    for (const nodeId of nodeIds) {
-      const key = nodeId.toString();
-      currentVector.set(key, startVector.get(key) ?? 1 / Math.sqrt(nodeIds.length));
-    }
-  } else {
-    const initialValue = 1 / Math.sqrt(nodeIds.length);
-    for (const nodeId of nodeIds) {
-      currentVector.set(nodeId.toString(), initialValue);
+  const index2 = new Map(keys.map((key, i) => [key, i]));
+  const adjacency = nodeIds.map((id) => Array.from(graph.neighbors(id), (m) => index2.get(m.toString()) ?? 0));
+  if (isNilpotent(adjacency)) {
+    for (const key of keys) {
+      centrality[key] = 0;
     }
+    return centrality;
   }
-  for (let iteration = 0; iteration < maxIterations; iteration++) {
-    previousVector = new Map(currentVector);
-    currentVector = /* @__PURE__ */ new Map();
-    for (const nodeId of nodeIds) {
-      let sum = 0;
-      const neighbors = Array.from(graph.neighbors(nodeId));
-      for (const neighbor of neighbors) {
-        const neighborKey = neighbor.toString();
-        const prevValue = previousVector.get(neighborKey);
-        sum += prevValue ?? 0;
-      }
-      currentVector.set(nodeId.toString(), sum);
-    }
-    let norm = 0;
-    for (const value of Array.from(currentVector.values())) {
-      norm += value * value;
-    }
-    norm = Math.sqrt(norm);
-    if (norm === 0) {
-      for (const nodeId of nodeIds) {
-        centrality[nodeId.toString()] = 0;
+  let x = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    x[i] = adjacency[i]?.length ? startVector?.get(keys[i] ?? "") ?? 1 : 0;
+  }
+  scaleToUnitLength(x);
+  let next = new Float64Array(n);
+  let converged = false;
+  for (let iteration = 0; iteration < maxIterations && !converged; iteration++) {
+    for (let i = 0; i < n; i++) {
+      let sum = x[i] ?? 0;
+      for (const j of adjacency[i] ?? []) {
+        sum += x[j] ?? 0;
       }
-      return centrality;
-    }
-    for (const [nodeId, value] of Array.from(currentVector)) {
-      currentVector.set(nodeId, value / norm);
-    }
-    let maxDiff = 0;
-    for (const [nodeId, value] of Array.from(currentVector)) {
-      const prevValue = previousVector.get(nodeId) ?? 0;
-      const diff = Math.abs(value - prevValue);
-      maxDiff = Math.max(maxDiff, diff);
+      next[i] = sum;
     }
-    if (maxDiff < tolerance) {
-      break;
+    scaleToUnitLength(next);
+    let change = 0;
+    for (let i = 0; i < n; i++) {
+      change += Math.abs((next[i] ?? 0) - (x[i] ?? 0));
     }
+    [x, next] = [next, x];
+    converged = change < n * tolerance;
   }
-  for (const [nodeId, value] of Array.from(currentVector)) {
-    centrality[nodeId] = value;
+  if (!converged) {
+    throw new ConvergenceError("eigenvectorCentrality", maxIterations, tolerance);
+  }
+  for (let i = 0; i < n; i++) {
+    centrality[keys[i] ?? ""] = x[i] ?? 0;
   }
   if (normalized) {
     let maxValue = 0;
     let minValue = Number.POSITIVE_INFINITY;
-    for (const value of Object.values(centrality)) {
+    for (const value of x) {
       maxValue = Math.max(maxValue, value);
       minValue = Math.min(minValue, value);
     }
     const range = maxValue - minValue;
-    if (range > 0) {
-      for (const nodeId of Object.keys(centrality)) {
-        const centralityValue = centrality[nodeId];
-        if (centralityValue !== void 0) {
-          centrality[nodeId] = (centralityValue - minValue) / range;
-        }
-      }
-    } else {
-      for (const nodeId of Object.keys(centrality)) {
-        centrality[nodeId] = maxValue > 0 ? 1 : 0;
-      }
+    const flat = maxValue > 0 ? 1 : 0;
+    for (const key of keys) {
+      centrality[key] = range > 0 ? ((centrality[key] ?? 0) - minValue) / range : flat;
     }
   }
   return centrality;
 }
+function isNilpotent(adjacency) {
+  const inDegree = new Int32Array(adjacency.length);
+  for (const targets of adjacency) {
+    for (const j of targets) {
+      inDegree[j] = (inDegree[j] ?? 0) + 1;
+    }
+  }
+  const queue = [];
+  inDegree.forEach((degree, i) => {
+    if (degree === 0) {
+      queue.push(i);
+    }
+  });
+  for (let head = 0; head < queue.length; head++) {
+    for (const j of adjacency[queue[head] ?? 0] ?? []) {
+      inDegree[j] = (inDegree[j] ?? 0) - 1;
+      if (inDegree[j] === 0) {
+        queue.push(j);
+      }
+    }
+  }
+  return queue.length === adjacency.length;
+}
+function scaleToUnitLength(v) {
+  let norm = 0;
+  for (const value of v) {
+    norm += value * value;
+  }
+  norm = Math.sqrt(norm);
+  if (norm > 0) {
+    for (let i = 0; i < v.length; i++) {
+      v[i] = (v[i] ?? 0) / norm;
+    }
+  }
+}
 function nodeEigenvectorCentrality(graph, nodeId, options = {}) {
   if (!graph.hasNode(nodeId)) {
     throw new Error(`Node ${String(nodeId)} not found in graph`);
@@ -6559,25 +6600,29 @@ function calculateModularity$3(graph, communityMap) {
   if (totalEdgeWeight === 0) {
     return 0;
   }
-  let modularity = 0;
-  const degrees = /* @__PURE__ */ new Map();
+  const degreeSum = /* @__PURE__ */ new Map();
   for (const node of graph.nodes()) {
-    degrees.set(node.id, getNodeDegree$1(graph, node.id));
+    const community = communityMap.get(node.id);
+    if (community === void 0) {
+      continue;
+    }
+    degreeSum.set(community, (degreeSum.get(community) ?? 0) + getNodeDegree$1(graph, node.id));
   }
+  const internalWeight = /* @__PURE__ */ new Map();
   for (const edge of graph.edges()) {
     const communityI = communityMap.get(edge.source);
     const communityJ = communityMap.get(edge.target);
-    if (communityI === communityJ) {
-      const edgeWeight = edge.weight ?? 1;
-      const degreeI = degrees.get(edge.source);
-      const degreeJ = degrees.get(edge.target);
-      if (degreeI === void 0 || degreeJ === void 0) {
-        continue;
-      }
-      modularity += edgeWeight - degreeI * degreeJ / (2 * totalEdgeWeight);
+    if (communityI === void 0 || communityI !== communityJ) {
+      continue;
     }
+    internalWeight.set(communityI, (internalWeight.get(communityI) ?? 0) + (edge.weight ?? 1));
+  }
+  let modularity = 0;
+  for (const [community, degrees] of degreeSum) {
+    const share = degrees / (2 * totalEdgeWeight);
+    modularity += (internalWeight.get(community) ?? 0) / totalEdgeWeight - share * share;
   }
-  return modularity / (2 * totalEdgeWeight);
+  return modularity;
 }
 function getTotalEdgeWeight$1(graph) {
   let totalWeight = 0;
@@ -6921,6 +6966,7 @@ function labelPropagationSemiSupervised(graph, seedLabels, options = {}) {
   const graphMap = graphToMap(graph);
   return labelPropagationSemiSupervisedImpl(graphMap, seedLabels, options);
 }
+const LOCAL_MOVE_PASSES = 50;
 function leidenImpl(inputGraph, options = {}) {
   const { resolution = 1, randomSeed = 42, maxIterations = 100, threshold = 1e-7 } = options;
   if (inputGraph.size === 0) {
@@ -6930,103 +6976,70 @@ function leidenImpl(inputGraph, options = {}) {
       iterations: 0
     };
   }
-  let currentGraph = inputGraph;
   const random = SeededRandom.createGenerator(randomSeed);
-  let totalWeight = 0;
-  const degrees = /* @__PURE__ */ new Map();
-  for (const [node, neighbors] of currentGraph) {
-    let degree = 0;
-    for (const weight of neighbors.values()) {
-      degree += weight;
-      totalWeight += weight;
-    }
-    degrees.set(node, degree);
-  }
-  totalWeight /= 2;
-  const communities = /* @__PURE__ */ new Map();
-  const nodes = Array.from(currentGraph.keys());
-  nodes.forEach((node, i) => communities.set(node, i));
-  let modularity = calculateModularity$2(currentGraph, communities, degrees, totalWeight, resolution);
-  let bestModularity = modularity;
-  let bestCommunities = new Map(communities);
+  const base = weighLevel(inputGraph);
+  const placement = /* @__PURE__ */ new Map();
+  for (const node of inputGraph.keys()) {
+    placement.set(node, node);
+  }
+  let bestCommunities = singletonCommunities(inputGraph);
+  let bestModularity = calculateModularity$2(inputGraph, bestCommunities, base.degrees, base.totalWeight, resolution);
+  let levelGraph = inputGraph;
   let iterations = 0;
+  let polishing = false;
   while (iterations < maxIterations) {
     iterations++;
-    let improved = false;
-    const nodeOrder = [...nodes];
-    shuffle(nodeOrder, random);
-    for (const node of nodeOrder) {
-      const currentCommunity = communities.get(node);
-      if (currentCommunity === void 0) {
-        continue;
-      }
-      const neighborCommunities = getNeighborCommunities$1(node, currentGraph, communities);
-      let bestCommunity = currentCommunity;
-      let bestGain = 0;
-      for (const [community] of neighborCommunities) {
-        if (community === currentCommunity) {
-          continue;
-        }
-        const gain = calculateModularityGain(
-          node,
-          community,
-          currentGraph,
-          communities,
-          degrees,
-          totalWeight,
-          resolution
-        );
-        if (gain > bestGain) {
-          bestGain = gain;
-          bestCommunity = community;
-        }
-      }
-      if (bestCommunity !== currentCommunity) {
-        communities.set(node, bestCommunity);
-        modularity += bestGain;
-        improved = true;
+    const weights = weighLevel(levelGraph);
+    const communities = polishing ? new Map(bestCommunities) : singletonCommunities(levelGraph);
+    const moved = moveNodesLocally(levelGraph, weights, communities, random, resolution, LOCAL_MOVE_PASSES);
+    for (const [node, piece] of refinePartition(levelGraph, communities)) {
+      communities.set(node, piece);
+    }
+    const candidate = /* @__PURE__ */ new Map();
+    for (const [original, levelNode] of placement) {
+      const community = communities.get(levelNode);
+      if (community !== void 0) {
+        candidate.set(original, community);
       }
     }
-    createAggregateNetwork(currentGraph, communities);
-    const subsetPartition = refinePartition(currentGraph, communities);
-    for (const [node, newCommunity] of subsetPartition) {
-      communities.set(node, newCommunity);
-    }
-    modularity = calculateModularity$2(currentGraph, communities, degrees, totalWeight, resolution);
-    if (modularity > bestModularity + threshold) {
+    const modularity = calculateModularity$2(inputGraph, candidate, base.degrees, base.totalWeight, resolution);
+    const improved = modularity > bestModularity + threshold;
+    if (modularity > bestModularity) {
       bestModularity = modularity;
-      bestCommunities = new Map(communities);
-      improved = true;
-    }
-    if (!improved) {
-      break;
+      bestCommunities = candidate;
     }
-    const aggregated = aggregateCommunities(currentGraph, communities);
-    if (aggregated.graph.size === currentGraph.size) {
-      break;
+    const distinct = new Set(communities.values()).size;
+    const settled = polishing ? !improved : !improved || !moved || distinct === levelGraph.size;
+    if (settled) {
+      if (polishing) {
+        break;
+      }
+      polishing = true;
+      levelGraph = inputGraph;
+      for (const node of inputGraph.keys()) {
+        placement.set(node, node);
+      }
+      continue;
     }
-    const { graph: aggregatedGraph } = aggregated;
-    currentGraph = aggregatedGraph;
-    communities.clear();
-    let communityId = 0;
-    for (const node of currentGraph.keys()) {
-      communities.set(node, communityId++);
+    polishing = false;
+    const aggregated = aggregateLevel(levelGraph, communities);
+    for (const [original, levelNode] of placement) {
+      const superNode = aggregated.mapping.get(levelNode);
+      if (superNode !== void 0) {
+        placement.set(original, superNode);
+      }
     }
+    levelGraph = aggregated.graph;
   }
+  const renumbered = /* @__PURE__ */ new Map();
   const finalCommunities = /* @__PURE__ */ new Map();
   for (const [node, community] of bestCommunities) {
-    finalCommunities.set(node, community);
-  }
-  const communityRenumber = /* @__PURE__ */ new Map();
-  let newId = 0;
-  for (const community of new Set(finalCommunities.values())) {
-    communityRenumber.set(community, newId++);
-  }
-  for (const [node, community] of finalCommunities) {
-    const newCommunityId = communityRenumber.get(community);
-    if (newCommunityId !== void 0) {
-      finalCommunities.set(node, newCommunityId);
+    let id = renumbered.get(community);
+    if (id === void 0) {
+      id = renumbered.size;
+      renumbered.set(community, id);
     }
+    finalCommunities.set(node, id);
   }
   return {
     communities: finalCommunities,
@@ -7078,75 +7091,6 @@ function getNeighborCommunities$1(node, graph, communities) {
   }
   return neighborCommunities;
 }
-function calculateModularityGain(node, targetCommunity, graph, communities, degrees, totalWeight, resolution) {
-  const currentCommunity = communities.get(node);
-  const nodeDegree = degrees.get(node);
-  if (currentCommunity === void 0 || nodeDegree === void 0) {
-    return 0;
-  }
-  let weightToTarget = 0;
-  let weightToCurrent = 0;
-  const neighbors = graph.get(node);
-  if (neighbors) {
-    for (const [neighbor, weight] of neighbors) {
-      const neighborCommunity = communities.get(neighbor);
-      if (neighborCommunity === void 0) {
-        continue;
-      }
-      if (neighborCommunity === targetCommunity) {
-        weightToTarget += weight;
-      } else if (neighborCommunity === currentCommunity && neighbor !== node) {
-        weightToCurrent += weight;
-      }
-    }
-  }
-  let targetDegree = 0;
-  let currentDegree = 0;
-  for (const [n, c] of communities) {
-    if (c === targetCommunity && n !== node) {
-      const deg = degrees.get(n);
-      if (deg !== void 0) {
-        targetDegree += deg;
-      }
-    } else if (c === currentCommunity && n !== node) {
-      const deg = degrees.get(n);
-      if (deg !== void 0) {
-        currentDegree += deg;
-      }
-    }
-  }
-  const m2 = 2 * totalWeight;
-  const gain = (weightToTarget - weightToCurrent) / totalWeight - resolution * nodeDegree * (targetDegree - currentDegree) / (m2 * m2);
-  return gain;
-}
-function createAggregateNetwork(graph, communities) {
-  const aggregateGraph = /* @__PURE__ */ new Map();
-  const nodeMapping = /* @__PURE__ */ new Map();
-  for (const [node, community] of communities) {
-    nodeMapping.set(node, community);
-    if (!aggregateGraph.has(community)) {
-      aggregateGraph.set(community, /* @__PURE__ */ new Map());
-    }
-  }
-  for (const [node, neighbors] of graph) {
-    const sourceCommunity = communities.get(node);
-    if (sourceCommunity === void 0) {
-      continue;
-    }
-    for (const [neighbor, weight] of neighbors) {
-      const targetCommunity = communities.get(neighbor);
-      if (targetCommunity === void 0) {
-        continue;
-      }
-      const sourceNeighbors = aggregateGraph.get(sourceCommunity);
-      if (sourceNeighbors) {
-        const current = sourceNeighbors.get(targetCommunity) ?? 0;
-        sourceNeighbors.set(targetCommunity, current + weight);
-      }
-    }
-  }
-  return { aggregateGraph, nodeMapping };
-}
 function refinePartition(originalGraph, communities) {
   const refined = /* @__PURE__ */ new Map();
   const communityNodes = /* @__PURE__ */ new Map();
@@ -7221,46 +7165,118 @@ function findConnectedComponents(graph) {
   }
   return components;
 }
-function aggregateCommunities(graph, communities) {
+function weighLevel(graph) {
+  const degrees = /* @__PURE__ */ new Map();
+  let summed = 0;
+  for (const [node, neighbors] of graph) {
+    let degree = 0;
+    for (const weight of neighbors.values()) {
+      degree += weight;
+    }
+    degrees.set(node, degree);
+    summed += degree;
+  }
+  return { degrees, totalWeight: summed / 2 };
+}
+function singletonCommunities(graph) {
+  const communities = /* @__PURE__ */ new Map();
+  let next = 0;
+  for (const node of graph.keys()) {
+    communities.set(node, next++);
+  }
+  return communities;
+}
+function communityDegrees(communities, degrees) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const [node, community] of communities) {
+    totals.set(community, (totals.get(community) ?? 0) + (degrees.get(node) ?? 0));
+  }
+  return totals;
+}
+function moveNodesLocally(graph, weights, communities, random, resolution, maxPasses) {
+  const { degrees, totalWeight } = weights;
+  if (totalWeight === 0) {
+    return false;
+  }
+  const totals = communityDegrees(communities, degrees);
+  const nodes = [...graph.keys()];
+  let movedEver = false;
+  let nextEmpty = 0;
+  for (const community of communities.values()) {
+    nextEmpty = Math.max(nextEmpty, community + 1);
+  }
+  for (let pass = 0; pass < maxPasses; pass++) {
+    const order = [...nodes];
+    shuffle(order, random);
+    let movedThisPass = false;
+    for (const node of order) {
+      const current = communities.get(node);
+      const degree = degrees.get(node);
+      if (current === void 0 || degree === void 0) {
+        continue;
+      }
+      const neighborCommunities = getNeighborCommunities$1(node, graph, communities);
+      const selfLoop = graph.get(node)?.get(node) ?? 0;
+      const weightToCurrent = (neighborCommunities.get(current) ?? 0) - selfLoop;
+      const degreeOfCurrent = (totals.get(current) ?? 0) - degree;
+      let bestCommunity = current;
+      let bestGain = 0;
+      if (degreeOfCurrent > 0) {
+        const alone = -weightToCurrent / totalWeight + resolution * degree * degreeOfCurrent / (2 * totalWeight * totalWeight);
+        if (alone > bestGain) {
+          bestGain = alone;
+          bestCommunity = nextEmpty;
+        }
+      }
+      for (const [community, weightToTarget] of neighborCommunities) {
+        if (community === current) {
+          continue;
+        }
+        const gain = (weightToTarget - weightToCurrent) / totalWeight - resolution * degree * ((totals.get(community) ?? 0) - degreeOfCurrent) / (2 * totalWeight * totalWeight);
+        if (gain > bestGain) {
+          bestGain = gain;
+          bestCommunity = community;
+        }
+      }
+      if (bestCommunity !== current) {
+        if (bestCommunity === nextEmpty) {
+          nextEmpty++;
+        }
+        communities.set(node, bestCommunity);
+        totals.set(current, (totals.get(current) ?? 0) - degree);
+        totals.set(bestCommunity, (totals.get(bestCommunity) ?? 0) + degree);
+        movedThisPass = true;
+        movedEver = true;
+      }
+    }
+    if (!movedThisPass) {
+      break;
+    }
+  }
+  return movedEver;
+}
+function aggregateLevel(graph, communities) {
   const aggregated = /* @__PURE__ */ new Map();
   const mapping = /* @__PURE__ */ new Map();
-  const communityNodes = /* @__PURE__ */ new Map();
-  for (const community of new Set(communities.values())) {
-    const superNode = `super_${String(community)}`;
-    communityNodes.set(community, superNode);
-    aggregated.set(superNode, /* @__PURE__ */ new Map());
-  }
   for (const [node, community] of communities) {
-    const superNode = communityNodes.get(community);
-    if (superNode !== void 0) {
-      mapping.set(node, superNode);
+    const superNode = `c${String(community)}`;
+    mapping.set(node, superNode);
+    if (!aggregated.has(superNode)) {
+      aggregated.set(superNode, /* @__PURE__ */ new Map());
     }
   }
   for (const [node, neighbors] of graph) {
-    const sourceCommunity = communities.get(node);
-    if (sourceCommunity === void 0) {
-      continue;
-    }
-    const sourceSuper = communityNodes.get(sourceCommunity);
-    if (sourceSuper === void 0) {
+    const source = mapping.get(node);
+    const row = source === void 0 ? void 0 : aggregated.get(source);
+    if (row === void 0) {
       continue;
     }
     for (const [neighbor, weight] of neighbors) {
-      const targetCommunity = communities.get(neighbor);
-      if (targetCommunity === void 0) {
-        continue;
-      }
-      const targetSuper = communityNodes.get(targetCommunity);
-      if (targetSuper === void 0) {
+      const target = mapping.get(neighbor);
+      if (target === void 0) {
         continue;
       }
-      if (sourceSuper !== targetSuper) {
-        const sourceNeighbors = aggregated.get(sourceSuper);
-        if (sourceNeighbors) {
-          const current = sourceNeighbors.get(targetSuper) ?? 0;
-          sourceNeighbors.set(targetSuper, current + weight);
-        }
-      }
+      row.set(target, (row.get(target) ?? 0) + weight);
     }
   }
   return { graph: aggregated, mapping };
@@ -7276,11 +7292,6 @@ class OptimizedLouvain {
    */
   constructor(graph) {
     this.graph = graph;
-    this.communities = /* @__PURE__ */ new Map();
-    this.communityWeights = /* @__PURE__ */ new Map();
-    this.nodeWeights = /* @__PURE__ */ new Map();
-    this.nodeDegrees = /* @__PURE__ */ new Map();
-    this.totalWeight = 0;
     this.pruningStats = {
       leafNodesPruned: 0,
       lowDegreeNodesPruned: 0,
@@ -7290,278 +7301,266 @@ class OptimizedLouvain {
   /**
    * Run optimized Louvain algorithm
    * @param options - Algorithm configuration options
-   * @returns Community detection result with communities, modularity, and iterations
+   * @returns Community detection result with communities, modularity, and iterations (levels)
    */
   detectCommunities(options = {}) {
-    const {
-      resolution = 1,
-      maxIterations = 100,
-      tolerance = 1e-6,
-      pruneLeaves = true,
-      importanceOrdering = true,
-      pruningThreshold = 0.01,
-      thresholdCycling = true
-    } = options;
-    this.initialize();
-    let modularity = this.calculateModularity(resolution);
-    let iteration = 0;
-    let improved = true;
-    while (iteration < maxIterations && improved) {
-      const orderedNodes = importanceOrdering ? this.getNodesInImportanceOrder() : Array.from(this.graph.nodes()).map((n) => n.id);
-      const threshold = thresholdCycling ? this.getAdaptiveThreshold(iteration, pruningThreshold) : 0;
-      improved = this.performLocalMoving(orderedNodes, {
-        pruneLeaves,
-        threshold,
-        resolution
-      });
-      if (improved) {
-        const newModularity = this.calculateModularity(resolution);
-        if (Math.abs(newModularity - modularity) < tolerance) {
-          break;
-        }
-        modularity = newModularity;
-        iteration++;
-      }
-    }
-    const communityGroups = /* @__PURE__ */ new Map();
-    for (const [nodeId, community] of this.communities) {
-      if (!communityGroups.has(community)) {
-        communityGroups.set(community, []);
+    const settings = {
+      resolution: options.resolution ?? 1,
+      maxIterations: options.maxIterations ?? 100,
+      tolerance: options.tolerance ?? 1e-6,
+      pruneLeaves: options.pruneLeaves ?? true,
+      importanceOrdering: options.importanceOrdering ?? true,
+      pruningThreshold: options.pruningThreshold ?? 0.01,
+      thresholdCycling: options.thresholdCycling ?? true
+    };
+    const { level: base, ids } = this.buildLevel();
+    const membership = new Int32Array(base.n);
+    for (let i = 0; i < base.n; i++) {
+      membership[i] = i;
+    }
+    let level = base;
+    let iterations = 0;
+    while (level.n > 1) {
+      const { community, count, moved } = this.localMoving(level, settings);
+      if (!moved) {
+        break;
       }
-      const group = communityGroups.get(community);
-      if (group) {
-        group.push(nodeId);
+      iterations++;
+      for (let i = 0; i < membership.length; i++) {
+        membership[i] = community[membership[i]];
       }
+      level = aggregate(level, community, count);
+    }
+    const groups = Array.from({ length: level.n }, () => []);
+    for (let i = 0; i < membership.length; i++) {
+      groups[membership[i]].push(ids[i]);
     }
     return {
-      communities: Array.from(communityGroups.values()),
-      modularity,
-      iterations: iteration
+      communities: groups.filter((group) => group.length > 0),
+      modularity: levelModularity(level, settings.resolution),
+      iterations
     };
   }
   /**
-   * Initialize data structures
+   * Get pruning statistics
+   * @returns Statistics about nodes pruned during optimization
    */
-  initialize() {
-    let communityId = 0;
-    for (const node of this.graph.nodes()) {
-      this.communities.set(node.id, communityId);
-      let nodeWeight = 0;
-      let degree = 0;
-      for (const neighbor of Array.from(this.graph.neighbors(node.id))) {
-        const edge = this.graph.getEdge(node.id, neighbor);
-        const weight = edge?.weight ?? 1;
-        nodeWeight += weight;
-        degree++;
-      }
-      if (!this.graph.isDirected) {
-        for (const neighbor of Array.from(this.graph.inNeighbors(node.id))) {
-          if (!this.graph.hasEdge(node.id, neighbor)) {
-            const edge = this.graph.getEdge(neighbor, node.id);
-            const weight = edge?.weight ?? 1;
-            nodeWeight += weight;
-            degree++;
-          }
-        }
-      }
-      this.nodeWeights.set(node.id, nodeWeight);
-      this.nodeDegrees.set(node.id, degree);
-      this.communityWeights.set(communityId, nodeWeight);
-      this.totalWeight += nodeWeight;
-      communityId++;
-    }
-    this.totalWeight = this.totalWeight / 2;
+  getPruningStats() {
+    return { ...this.pruningStats };
   }
   /**
-   * Get nodes ordered by importance (degree * log(weight))
-   * @returns Array of node IDs sorted by descending importance
+   * Index the graph's nodes 0..n-1 and build the level-0 CSR adjacency
+   * @returns The level-0 graph and the node id at each index
    */
-  getNodesInImportanceOrder() {
-    const nodeImportance = /* @__PURE__ */ new Map();
-    for (const [nodeId, degree] of this.nodeDegrees) {
-      const weight = this.nodeWeights.get(nodeId) ?? 0;
-      const importance = degree * Math.log(1 + weight);
-      nodeImportance.set(nodeId, importance);
+  buildLevel() {
+    const ids = [];
+    const index2 = /* @__PURE__ */ new Map();
+    for (const node of this.graph.nodes()) {
+      index2.set(node.id, ids.length);
+      ids.push(node.id);
+    }
+    const n = ids.length;
+    const edges = [];
+    const counts = new Int32Array(n + 1);
+    const self = new Float64Array(n);
+    const degree = new Float64Array(n);
+    for (const edge of this.graph.edges()) {
+      const s = index2.get(edge.source);
+      const t = index2.get(edge.target);
+      if (s === void 0 || t === void 0) {
+        continue;
+      }
+      const w = edge.weight ?? 1;
+      degree[s] += w;
+      degree[t] += w;
+      if (s === t) {
+        self[s] += w;
+        continue;
+      }
+      edges.push([s, t, w]);
+      counts[s + 1]++;
+      counts[t + 1]++;
     }
-    return Array.from(nodeImportance.entries()).sort((a, b) => b[1] - a[1]).map(([nodeId]) => nodeId);
+    return { level: buildCsr(n, counts, edges, self, degree), ids };
   }
   /**
-   * Perform local moving phase with optimizations
-   * @param nodes - Array of node IDs to process
+   * Move each node to the neighbouring community with the best modularity gain, until no move
+   * improves modularity
+   * @param level - The graph at this level
    * @param options - Local moving options
-   * @param options.pruneLeaves - Whether to skip leaf nodes
-   * @param options.threshold - Minimum gain threshold for moves
-   * @param options.resolution - Resolution parameter for modularity
-   * @returns True if any improvement was made, false otherwise
-   */
-  performLocalMoving(nodes, options) {
-    const { pruneLeaves, threshold, resolution } = options;
-    let improvement = false;
-    let hasChanged = true;
-    while (hasChanged) {
-      hasChanged = false;
-      for (const nodeId of nodes) {
-        if (pruneLeaves && this.isLeafNode(nodeId)) {
+   * @returns Each node's community (numbered 0..count-1), the count, and whether any node moved
+   */
+  localMoving(level, options) {
+    const { n, offsets, targets, weights, degree } = level;
+    const { resolution, maxIterations, tolerance, pruneLeaves } = options;
+    const twoM = degree.reduce((sum, d) => sum + d, 0);
+    const community = new Int32Array(n);
+    const total = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+      community[i] = i;
+      total[i] = degree[i];
+    }
+    if (twoM === 0) {
+      return { community, count: n, moved: false };
+    }
+    const order = this.nodeOrder(level, options.importanceOrdering);
+    const toCommunity = new Float64Array(n);
+    const touched = new Int32Array(n);
+    let moved = false;
+    let useThreshold = options.thresholdCycling;
+    for (let sweep = 0; sweep < maxIterations; sweep++) {
+      const threshold = useThreshold ? options.pruningThreshold * Math.pow(0.5, sweep / 10) : 0;
+      let sweepMoved = false;
+      let sweepGain = 0;
+      for (const i of order) {
+        const start = offsets[i];
+        const end = offsets[i + 1];
+        if (pruneLeaves && end - start === 1 && community[targets[start]] === community[i]) {
           this.pruningStats.leafNodesPruned++;
           continue;
         }
-        const currentCommunity = this.communities.get(nodeId) ?? 0;
-        const neighborCommunities = this.getNeighborCommunities(nodeId);
-        if (neighborCommunities.size === 0) {
+        if (end === start) {
           continue;
         }
-        let bestCommunity = currentCommunity;
-        let bestGain = 0;
-        this.removeNodeFromCommunity(nodeId, currentCommunity);
-        for (const community of neighborCommunities) {
-          const gain = this.calculateModularityGain(nodeId, community, resolution);
-          if (gain > bestGain + threshold) {
-            bestGain = gain;
-            bestCommunity = community;
+        const current = community[i];
+        let touchedCount = 0;
+        for (let e = start; e < end; e++) {
+          const c = community[targets[e]];
+          if (toCommunity[c] === 0) {
+            touched[touchedCount++] = c;
+          }
+          toCommunity[c] += weights[e];
+        }
+        const k = degree[i];
+        total[current] -= k;
+        const stayGain = toCommunity[current] - resolution * total[current] * k / twoM;
+        let best = current;
+        let bestGain = stayGain;
+        const minImprovement = threshold * k;
+        for (let t = 0; t < touchedCount; t++) {
+          const c = touched[t];
+          if (c !== current) {
+            const gain = toCommunity[c] - resolution * total[c] * k / twoM;
+            if (gain > bestGain + minImprovement) {
+              bestGain = gain;
+              best = c;
+            }
           }
+          toCommunity[c] = 0;
         }
-        const currentGain = this.calculateModularityGain(nodeId, currentCommunity, resolution);
-        if (currentGain > bestGain + threshold) {
-          bestGain = currentGain;
-          bestCommunity = currentCommunity;
-        }
-        this.addNodeToCommunity(nodeId, bestCommunity);
-        if (bestCommunity !== currentCommunity) {
-          hasChanged = true;
-          improvement = true;
+        total[best] += k;
+        if (best !== current) {
+          community[i] = best;
+          sweepMoved = true;
+          sweepGain += (bestGain - stayGain) / (twoM / 2);
         }
       }
-    }
-    return improvement;
-  }
-  /**
-   * Check if node is a leaf (degree 1)
-   * @param nodeId - The node ID to check
-   * @returns True if the node has degree 1, false otherwise
-   */
-  isLeafNode(nodeId) {
-    const degree = this.nodeDegrees.get(nodeId) ?? 0;
-    return degree === 1;
-  }
-  /**
-   * Get adaptive threshold that decreases with iterations
-   * @param iteration - Current iteration number
-   * @param baseThreshold - Base threshold value to scale
-   * @returns Adaptive threshold value that decays over iterations
-   */
-  getAdaptiveThreshold(iteration, baseThreshold) {
-    return baseThreshold * Math.pow(0.5, iteration / 10);
-  }
-  /**
-   * Calculate modularity gain from moving a node to a community
-   * @param nodeId - The node ID to move
-   * @param targetCommunity - The target community ID
-   * @param resolution - Resolution parameter for modularity calculation
-   * @returns The modularity gain from moving the node
-   */
-  calculateModularityGain(nodeId, targetCommunity, resolution) {
-    const nodeWeight = this.nodeWeights.get(nodeId) ?? 0;
-    let weightToTarget = 0;
-    for (const neighbor of Array.from(this.graph.neighbors(nodeId))) {
-      if (this.communities.get(neighbor) === targetCommunity) {
-        const edge = this.graph.getEdge(nodeId, neighbor);
-        weightToTarget += edge?.weight ?? 1;
+      moved ||= sweepMoved;
+      if (!sweepMoved || sweepGain < tolerance) {
+        if (useThreshold) {
+          useThreshold = false;
+          continue;
+        }
+        break;
       }
     }
-    if (!this.graph.isDirected) {
-      for (const neighbor of Array.from(this.graph.inNeighbors(nodeId))) {
-        if (this.communities.get(neighbor) === targetCommunity && !this.graph.hasEdge(nodeId, neighbor)) {
-          const edge = this.graph.getEdge(neighbor, nodeId);
-          weightToTarget += edge?.weight ?? 1;
-        }
+    const renumber = new Int32Array(n).fill(-1);
+    let count = 0;
+    for (let i = 0; i < n; i++) {
+      const c = community[i];
+      if (renumber[c] === -1) {
+        renumber[c] = count++;
       }
+      community[i] = renumber[c];
     }
-    const targetWeight = this.communityWeights.get(targetCommunity) ?? 0;
-    const gain = (weightToTarget - resolution * nodeWeight * targetWeight / (2 * this.totalWeight)) / this.totalWeight;
-    return gain;
-  }
-  /**
-   * Remove node from community (for gain calculation)
-   * @param nodeId - The node ID to remove
-   * @param community - The community ID to remove from
-   */
-  removeNodeFromCommunity(nodeId, community) {
-    const nodeWeight = this.nodeWeights.get(nodeId) ?? 0;
-    this.communityWeights.set(community, (this.communityWeights.get(community) ?? 0) - nodeWeight);
-    this.communities.delete(nodeId);
+    return { community, count, moved };
   }
   /**
-   * Add node to community
-   * @param nodeId - The node ID to add
-   * @param community - The community ID to add to
+   * Order nodes for local moving, by importance (degree * log(1 + weighted degree)) if asked
+   * @param level - The graph at this level
+   * @param importanceOrdering - Whether to sort by importance
+   * @returns Node indices in processing order
    */
-  addNodeToCommunity(nodeId, community) {
-    const nodeWeight = this.nodeWeights.get(nodeId) ?? 0;
-    this.communityWeights.set(community, (this.communityWeights.get(community) ?? 0) + nodeWeight);
-    this.communities.set(nodeId, community);
-  }
-  /**
-   * Get neighboring communities of a node
-   * @param nodeId - The node ID to find neighbor communities for
-   * @returns Set of community IDs that neighbors belong to
-   */
-  getNeighborCommunities(nodeId) {
-    const communities = /* @__PURE__ */ new Set();
-    for (const neighbor of Array.from(this.graph.neighbors(nodeId))) {
-      const community = this.communities.get(neighbor);
-      if (community !== void 0) {
-        communities.add(community);
-      }
+  nodeOrder(level, importanceOrdering) {
+    const order = new Int32Array(level.n);
+    for (let i = 0; i < level.n; i++) {
+      order[i] = i;
     }
-    if (!this.graph.isDirected) {
-      for (const neighbor of Array.from(this.graph.inNeighbors(nodeId))) {
-        const community = this.communities.get(neighbor);
-        if (community !== void 0) {
-          communities.add(community);
-        }
-      }
+    if (!importanceOrdering) {
+      return order;
     }
-    return communities;
-  }
-  /**
-   * Calculate total modularity
-   * @param resolution - Resolution parameter for modularity calculation
-   * @returns The modularity score of the current partition
-   */
-  calculateModularity(resolution) {
-    if (this.totalWeight === 0) {
-      return 0;
+    const importance = new Float64Array(level.n);
+    for (let i = 0; i < level.n; i++) {
+      importance[i] = (level.offsets[i + 1] - level.offsets[i]) * Math.log(1 + level.degree[i]);
     }
-    let modularity = 0;
-    const communityInternalWeights = /* @__PURE__ */ new Map();
-    for (const node of this.graph.nodes()) {
-      const nodeId = node.id;
-      const community = this.communities.get(nodeId) ?? 0;
-      for (const neighbor of Array.from(this.graph.neighbors(nodeId))) {
-        if (this.communities.get(neighbor) === community) {
-          const edge = this.graph.getEdge(nodeId, neighbor);
-          const weight = edge?.weight ?? 1;
-          communityInternalWeights.set(community, (communityInternalWeights.get(community) ?? 0) + weight);
+    return order.sort((a, b) => importance[b] - importance[a]);
+  }
+}
+function buildCsr(n, counts, edges, self, degree) {
+  const offsets = counts;
+  for (let i = 0; i < n; i++) {
+    offsets[i + 1] += offsets[i];
+  }
+  const targets = new Int32Array(offsets[n]);
+  const weights = new Float64Array(offsets[n]);
+  const fill = offsets.slice(0, n);
+  for (const [s, t, w] of edges) {
+    targets[fill[s]] = t;
+    weights[fill[s]++] = w;
+    targets[fill[t]] = s;
+    weights[fill[t]++] = w;
+  }
+  return { n, offsets, targets, weights, self, degree };
+}
+function aggregate(level, community, count) {
+  const self = new Float64Array(count);
+  const degree = new Float64Array(count);
+  const members = Array.from({ length: count }, () => []);
+  for (let i = 0; i < level.n; i++) {
+    const c = community[i];
+    members[c].push(i);
+    self[c] += level.self[i];
+    degree[c] += level.degree[i];
+  }
+  const edges = [];
+  const counts = new Int32Array(count + 1);
+  const toCommunity = new Float64Array(count);
+  const touched = [];
+  for (let c = 0; c < count; c++) {
+    for (const i of members[c]) {
+      for (let e = level.offsets[i]; e < level.offsets[i + 1]; e++) {
+        const d = community[level.targets[e]];
+        if (d === c) {
+          self[c] += level.weights[e] / 2;
+        } else if (d > c) {
+          if (toCommunity[d] === 0) {
+            touched.push(d);
+          }
+          toCommunity[d] += level.weights[e];
         }
       }
     }
-    for (const [community, internalWeight] of communityInternalWeights) {
-      const communityWeight = this.communityWeights.get(community) ?? 0;
-      const aIn = this.graph.isDirected ? internalWeight : internalWeight / 2;
-      const aTotal = communityWeight;
-      const actualFraction = aIn / this.totalWeight;
-      const expectedFraction = resolution * Math.pow(aTotal / (2 * this.totalWeight), 2);
-      modularity += actualFraction - expectedFraction;
+    for (const d of touched) {
+      edges.push([c, d, toCommunity[d]]);
+      counts[c + 1]++;
+      counts[d + 1]++;
+      toCommunity[d] = 0;
     }
-    return modularity;
+    touched.length = 0;
   }
-  /**
-   * Get pruning statistics
-   * @returns Statistics about nodes pruned during optimization
-   */
-  getPruningStats() {
-    return { ...this.pruningStats };
+  return buildCsr(count, counts, edges, self, degree);
+}
+function levelModularity(level, resolution) {
+  const twoM = level.degree.reduce((sum, d) => sum + d, 0);
+  if (twoM === 0) {
+    return 0;
   }
+  let modularity = 0;
+  for (let c = 0; c < level.n; c++) {
+    const share = level.degree[c] / twoM;
+    modularity += 2 * level.self[c] / twoM - resolution * share * share;
+  }
+  return modularity;
 }
 function louvainOptimized(graph, options = {}) {
   const optimizer = new OptimizedLouvain(graph);
@@ -7597,36 +7596,29 @@ function calculateModularity$1(graph, communities, resolution = 1) {
   if (totalEdgeWeight === 0) {
     return 0;
   }
-  let modularity = 0;
-  const countedEdges = /* @__PURE__ */ new Set();
-  for (const nodeI of graph.nodes()) {
-    for (const nodeJ of graph.nodes()) {
-      if (!graph.isDirected) {
-        const nodeIStr = String(nodeI.id);
-        const nodeJStr = String(nodeJ.id);
-        const edgeKey = nodeIStr <= nodeJStr ? `${nodeIStr}-${nodeJStr}` : `${nodeJStr}-${nodeIStr}`;
-        if (countedEdges.has(edgeKey)) {
-          continue;
-        }
-        countedEdges.add(edgeKey);
-      }
-      if (communities.get(nodeI.id) === communities.get(nodeJ.id)) {
-        const edge = graph.getEdge(nodeI.id, nodeJ.id);
-        const reverseEdge = !graph.isDirected ? graph.getEdge(nodeJ.id, nodeI.id) : null;
-        let edgeWeight = 0;
-        if (edge) {
-          edgeWeight += edge.weight ?? 1;
-        }
-        if (reverseEdge && nodeI.id !== nodeJ.id) {
-          edgeWeight += reverseEdge.weight ?? 1;
-        }
-        const degreeI = getNodeDegree(graph, nodeI.id);
-        const degreeJ = getNodeDegree(graph, nodeJ.id);
-        modularity += edgeWeight - resolution * degreeI * degreeJ / (2 * totalEdgeWeight);
-      }
+  const degreeSum = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes()) {
+    const community = communities.get(node.id);
+    if (community === void 0) {
+      continue;
     }
+    degreeSum.set(community, (degreeSum.get(community) ?? 0) + getNodeDegree(graph, node.id));
   }
-  return modularity / (2 * totalEdgeWeight);
+  const internalWeight = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges()) {
+    const communityI = communities.get(edge.source);
+    const communityJ = communities.get(edge.target);
+    if (communityI === void 0 || communityI !== communityJ) {
+      continue;
+    }
+    internalWeight.set(communityI, (internalWeight.get(communityI) ?? 0) + (edge.weight ?? 1));
+  }
+  let modularity = 0;
+  for (const [community, degrees] of degreeSum) {
+    const share = degrees / (2 * totalEdgeWeight);
+    modularity += (internalWeight.get(community) ?? 0) / totalEdgeWeight - resolution * share * share;
+  }
+  return modularity;
 }
 function louvain(graph, options = {}) {
   const resolution = options.resolution ?? 1;
@@ -11814,6 +11806,7 @@ function accelerated(acc) {
 export {
   CSRGraph,
   CompactDistanceArray,
+  ConvergenceError,
   DeltaPageRank,
   DirectionOptimizedBFS,
   Graph,