Function spectralCluster

src/core/clustering.ts:137–175

(vectors: number[][], maxClusters: number = 20)

}

export function spectralCluster(vectors: number[][], maxClusters: number = 20): ClusterResult[] {
  const n = vectors.length;
  if (n <= 1) return [{ indices: Array.from({ length: n }, (_, i) => i) }];
  if (n <= maxClusters) return vectors.map((_, i) => ({ indices: [i] }));

  const affinity = buildAffinityMatrix(vectors);
  const laplacian = normalizedLaplacian(affinity);
  const eigen = new EigenvalueDecomposition(laplacian);

  const eigenvalues = eigen.realEigenvalues;
  const eigenvectors = eigen.eigenvectorMatrix;

  const k = findOptimalK(eigenvalues, Math.min(maxClusters, Math.max(2, Math.floor(Math.sqrt(n)))));

  const sortedIndices = eigenvalues
    .map((v: number, i: number) => ({ v, i }))
    .sort((a: { v: number }, b: { v: number }) => a.v - b.v)
    .map((x: { i: number }) => x.i);

  const embedding: number[][] = [];
  for (let i = 0; i < n; i++) {
    const row: number[] = [];
    for (let j = 0; j < k; j++) row.push(eigenvectors.get(i, sortedIndices[j]));
    const norm = Math.sqrt(row.reduce((s, v) => s + v * v, 0));
    if (norm > 1e-10) for (let d = 0; d < row.length; d++) row[d] /= norm;
    embedding.push(row);
  }

  const assignments = kMeans(embedding, k);

  const clusters: Map<number, number[]> = new Map();
  for (let i = 0; i < n; i++) {
    const c = assignments[i];
    if (!clusters.has(c)) clusters.set(c, []);
    clusters.get(c)!.push(i);
  }

  return Array.from(clusters.values()).map((indices) => ({ indices }));
}

export function findPathPattern(paths: string[]): string | null {
  if (paths.length <= 1) return null;