@graphty/algorithms 1.3.1 → 1.5.0

package/src/clustering/mcl.ts

@@ -1,5 +1,5 @@
-import type {Graph} from "../core/graph.js";
-import type {NodeId} from "../types/index.js";
+import type { Graph } from "../core/graph.js";
+import type { NodeId } from "../types/index.js";
 
 /**
  * Markov Clustering (MCL) algorithm implementation
@@ -31,11 +31,11 @@ export interface MCLResult {
 
 /**
  * Perform Markov Clustering on a graph
+ * @param graph - The input graph to cluster
+ * @param options - MCL algorithm options (expansion, inflation, iterations, etc.)
+ * @returns MCL clustering result with communities, attractors, and convergence info
  */
-export function markovClustering(
-    graph: Graph,
-    options: MCLOptions = {},
-): MCLResult {
+export function markovClustering(graph: Graph, options: MCLOptions = {}): MCLResult {
     const {
         expansion = 2,
         inflation = 2,
@@ -65,7 +65,7 @@ export function markovClustering(
     let iteration = 0;
 
     for (iteration = 0; iteration < maxIterations; iteration++) {
-        const oldMatrix = matrix.map((row) => [... row]);
+        const oldMatrix = matrix.map((row) => [...row]);
 
         // Expansion step (matrix multiplication)
         matrix = matrixPower(matrix, expansion);
@@ -84,7 +84,7 @@ export function markovClustering(
     }
 
     // Extract clusters from final matrix
-    const {communities, attractors} = extractClusters(matrix, nodeIds);
+    const { communities, attractors } = extractClusters(matrix, nodeIds);
 
     return {
         communities,
@@ -96,10 +96,14 @@ export function markovClustering(
 
 /**
  * Build initial transition matrix from graph
+ * @param graph - The input graph
+ * @param nodeIds - Array of node IDs in the graph
+ * @param selfLoops - Whether to add self-loops to the matrix
+ * @returns Column-normalized transition matrix
  */
 function buildTransitionMatrix(graph: Graph, nodeIds: NodeId[], selfLoops: boolean): number[][] {
     const n = nodeIds.length;
-    const matrix = Array.from({length: n}, (): number[] => Array(n).fill(0) as number[]);
+    const matrix = Array.from({ length: n }, (): number[] => Array(n).fill(0) as number[]);
     const nodeToIndex = new Map<NodeId, number>();
 
     nodeIds.forEach((id, index) => nodeToIndex.set(id, index));
@@ -168,6 +172,9 @@ function buildTransitionMatrix(graph: Graph, nodeIds: NodeId[], selfLoops: boole
 
 /**
  * Raise matrix to a power (for expansion step)
+ * @param matrix - Input square matrix
+ * @param power - Power to raise the matrix to
+ * @returns Matrix raised to the specified power
  */
 function matrixPower(matrix: number[][], power: number): number[][] {
     if (power === 1) {
@@ -187,13 +194,16 @@ function matrixPower(matrix: number[][], power: number): number[][] {
 
 /**
  * Multiply two matrices
+ * @param a - First matrix
+ * @param b - Second matrix
+ * @returns Product matrix a * b
  */
 function matrixMultiply(a: number[][], b: number[][]): number[][] {
     const n = a.length;
     const m = b[0]?.length ?? 0;
     const p = b.length;
 
-    const result: number[][] = Array.from({length: n}, () => Array(m).fill(0) as number[]);
+    const result: number[][] = Array.from({ length: n }, () => Array(m).fill(0) as number[]);
 
     for (let i = 0; i < n; i++) {
         for (let j = 0; j < m; j++) {
@@ -207,7 +217,7 @@ function matrixMultiply(a: number[][], b: number[][]): number[][] {
 
                 const prevVal = resultRow[j];
                 if (prevVal !== undefined) {
-                    resultRow[j] = prevVal + (aVal * bVal);
+                    resultRow[j] = prevVal + aVal * bVal;
                 }
             }
         }
@@ -218,10 +228,13 @@ function matrixMultiply(a: number[][], b: number[][]): number[][] {
 
 /**
  * Inflation step: element-wise powering and column normalization
+ * @param matrix - Input matrix to inflate
+ * @param inflation - Inflation parameter for element-wise powering
+ * @returns Inflated and column-normalized matrix
  */
 function inflate(matrix: number[][], inflation: number): number[][] {
     const n = matrix.length;
-    const result: number[][] = Array.from({length: n}, () => Array(n).fill(0) as number[]);
+    const result: number[][] = Array.from({ length: n }, () => Array(n).fill(0) as number[]);
 
     // Element-wise powering
     for (let i = 0; i < n; i++) {
@@ -266,10 +279,13 @@ function inflate(matrix: number[][], inflation: number): number[][] {
 
 /**
  * Pruning step: remove small values
+ * @param matrix - Input matrix to prune
+ * @param threshold - Values below this threshold are set to zero
+ * @returns Pruned and re-normalized matrix
  */
 function prune(matrix: number[][], threshold: number): number[][] {
     const n = matrix.length;
-    const result: number[][] = Array.from({length: n}, () => Array(n).fill(0) as number[]);
+    const result: number[][] = Array.from({ length: n }, () => Array(n).fill(0) as number[]);
 
     for (let i = 0; i < n; i++) {
         for (let j = 0; j < n; j++) {
@@ -323,6 +339,10 @@ function prune(matrix: number[][], threshold: number): number[][] {
 
 /**
  * Check if the algorithm has converged
+ * @param oldMatrix - Matrix from previous iteration
+ * @param newMatrix - Matrix from current iteration
+ * @param tolerance - Convergence tolerance threshold
+ * @returns True if the maximum difference between matrices is below tolerance
  */
 function hasConverged(oldMatrix: number[][], newMatrix: number[][], tolerance: number): boolean {
     const n = oldMatrix.length;
@@ -348,8 +368,14 @@ function hasConverged(oldMatrix: number[][], newMatrix: number[][], tolerance: n
 
 /**
  * Extract clusters from the final matrix
+ * @param matrix - Final converged MCL matrix
+ * @param nodeIds - Array of node IDs corresponding to matrix indices
+ * @returns Object containing communities and attractor nodes
  */
-function extractClusters(matrix: number[][], nodeIds: NodeId[]): {
+function extractClusters(
+    matrix: number[][],
+    nodeIds: NodeId[],
+): {
     communities: NodeId[][];
     attractors: Set<NodeId>;
 } {
@@ -391,10 +417,14 @@ function extractClusters(matrix: number[][], nodeIds: NodeId[]): {
         }
 
         if (clusterNodes.length > 0) {
-            communities.push(clusterNodes.map((idx) => {
-                const nodeId = nodeIds[idx];
-                return nodeId;
-            }).filter((node): node is NodeId => node !== undefined));
+            communities.push(
+                clusterNodes
+                    .map((idx) => {
+                        const nodeId = nodeIds[idx];
+                        return nodeId;
+                    })
+                    .filter((node): node is NodeId => node !== undefined),
+            );
             clusterIndex++;
         }
     }
@@ -411,16 +441,16 @@ function extractClusters(matrix: number[][], nodeIds: NodeId[]): {
         }
     }
 
-    return {communities, attractors};
+    return { communities, attractors };
 }
 
 /**
  * Calculate modularity of MCL clustering result
+ * @param graph - The original graph that was clustered
+ * @param communities - Array of communities (each community is an array of node IDs)
+ * @returns Modularity score between -0.5 and 1.0
  */
-export function calculateMCLModularity(
-    graph: Graph,
-    communities: NodeId[][],
-): number {
+export function calculateMCLModularity(graph: Graph, communities: NodeId[][]): number {
     const m = graph.totalEdgeCount;
     if (m === 0) {
         return 0;

package/src/clustering/spectral.ts

@@ -1,6 +1,6 @@
-import type {Graph} from "../core/graph.js";
-import type {NodeId} from "../types/index.js";
-import {euclideanDistance} from "../utils/math-utilities.js";
+import type { Graph } from "../core/graph.js";
+import type { NodeId } from "../types/index.js";
+import { euclideanDistance } from "../utils/math-utilities.js";
 
 /**
  * Spectral Clustering implementation
@@ -29,24 +29,19 @@ export interface SpectralClusteringResult {
 /**
  * Perform spectral clustering on a graph
  *
- * @warning This implementation uses simplified power iteration for eigenvector
+ * Note: This implementation uses simplified power iteration for eigenvector
  * computation with approximate eigenvalues. For production use cases requiring
  * precise clustering, consider using a proper linear algebra library like ml-matrix.
  *
  * The approximate eigenvalues (0.1, 0.2 for second and third eigenvectors) work
  * well for most graph structures but may produce suboptimal results for graphs
  * with unusual spectral properties.
+ * @param graph - The input graph to cluster
+ * @param options - Spectral clustering options (k, laplacianType, etc.)
+ * @returns Spectral clustering result with communities and cluster assignments
  */
-export function spectralClustering(
-    graph: Graph,
-    options: SpectralClusteringOptions,
-): SpectralClusteringResult {
-    const {
-        k,
-        laplacianType = "normalized",
-        maxIterations = 100,
-        tolerance = 1e-4,
-    } = options;
+export function spectralClustering(graph: Graph, options: SpectralClusteringOptions): SpectralClusteringResult {
+    const { k, laplacianType = "normalized", maxIterations = 100, tolerance = 1e-4 } = options;
 
     // Input validation
     if (k < 1 || !Number.isInteger(k)) {
@@ -62,7 +57,7 @@ export function spectralClustering(
         const communities: NodeId[][] = nodeIds.map((id) => [id]);
         const clusterAssignments = new Map<NodeId, number>();
         nodeIds.forEach((id, index) => clusterAssignments.set(id, index));
-        return {communities, clusterAssignments};
+        return { communities, clusterAssignments };
     }
 
     // Build adjacency matrix
@@ -97,7 +92,7 @@ export function spectralClustering(
     const kmeans = kMeansClustering(dataPoints, k, maxIterations, tolerance);
 
     // Build communities
-    const communities: NodeId[][] = Array.from({length: k}, () => []);
+    const communities: NodeId[][] = Array.from({ length: k }, () => []);
     const clusterAssignments = new Map<NodeId, number>();
 
     for (let i = 0; i < nodeIds.length; i++) {
@@ -139,10 +134,13 @@ export function spectralClustering(
 
 /**
  * Build adjacency matrix from graph
+ * @param graph - The input graph
+ * @param nodeIds - Array of node IDs defining matrix index order
+ * @returns Square adjacency matrix with edge weights
  */
 function buildAdjacencyMatrix(graph: Graph, nodeIds: NodeId[]): number[][] {
     const n = nodeIds.length;
-    const matrix: number[][] = Array.from({length: n}, () => Array(n).fill(0) as number[]);
+    const matrix: number[][] = Array.from({ length: n }, () => Array(n).fill(0) as number[]);
     const nodeToIndex = new Map<NodeId, number>();
 
     nodeIds.forEach((id, index) => nodeToIndex.set(id, index));
@@ -180,10 +178,13 @@ function buildAdjacencyMatrix(graph: Graph, nodeIds: NodeId[]): number[][] {
 
 /**
  * Build Laplacian matrix from adjacency matrix
+ * @param adjacency - Square adjacency matrix
+ * @param type - Type of Laplacian (unnormalized, normalized, or randomWalk)
+ * @returns The computed Laplacian matrix
  */
 function buildLaplacianMatrix(adjacency: number[][], type: string): number[][] {
     const n = adjacency.length;
-    const laplacian: number[][] = Array.from({length: n}, () => Array(n).fill(0) as number[]);
+    const laplacian: number[][] = Array.from({ length: n }, () => Array(n).fill(0) as number[]);
 
     // Calculate degree matrix
     const degrees = Array(n).fill(0) as number[];
@@ -239,7 +240,14 @@ function buildLaplacianMatrix(adjacency: number[][], type: string): number[][] {
                     const adjacencyVal = adjacencyRow[j];
                     const di = degrees[i];
                     const dj = degrees[j];
-                    if (adjacencyVal !== undefined && adjacencyVal > 0 && di !== undefined && dj !== undefined && di > 0 && dj > 0) {
+                    if (
+                        adjacencyVal !== undefined &&
+                        adjacencyVal > 0 &&
+                        di !== undefined &&
+                        dj !== undefined &&
+                        di > 0 &&
+                        dj > 0
+                    ) {
                         const laplacianRow = laplacian[i];
                         if (laplacianRow) {
                             laplacianRow[j] = -adjacencyVal / Math.sqrt(di * dj);
@@ -283,15 +291,21 @@ function buildLaplacianMatrix(adjacency: number[][], type: string): number[][] {
 /**
  * Find k smallest eigenvectors using simplified eigendecomposition
  * This is a simplified implementation - in practice, you'd use LAPACK or similar
+ * @param matrix - The Laplacian matrix for eigendecomposition
+ * @param k - Number of smallest eigenvectors to find
+ * @returns Object containing eigenvalues and corresponding eigenvectors
  */
-function findSmallestEigenvectors(matrix: number[][], k: number): {
+function findSmallestEigenvectors(
+    matrix: number[][],
+    k: number,
+): {
     eigenvalues: number[];
     eigenvectors: number[][];
 } {
     const n = matrix.length;
 
     if (n === 0 || k === 0) {
-        return {eigenvalues: [], eigenvectors: []};
+        return { eigenvalues: [], eigenvectors: [] };
     }
 
     // For very small matrices, use the full power iteration approach
@@ -314,10 +328,12 @@ function findSmallestEigenvectors(matrix: number[][], k: number): {
 
     for (let eigIdx = 0; eigIdx < k; eigIdx++) {
         // Initialize random vector
-        let vector = Array(n).fill(0).map(() => Math.random() - 0.5);
+        let vector = Array(n)
+            .fill(0)
+            .map(() => Math.random() - 0.5);
 
         // Normalize initial vector
-        const initNorm = Math.sqrt(vector.reduce((sum, val) => sum + (val * val), 0));
+        const initNorm = Math.sqrt(vector.reduce((sum, val) => sum + val * val, 0));
         if (initNorm > 0) {
             vector = vector.map((val) => val / initNorm);
         }
@@ -329,8 +345,8 @@ function findSmallestEigenvectors(matrix: number[][], k: number): {
                 continue;
             }
 
-            const dot = vector.reduce((sum, val, idx) => sum + (val * (ejVector[idx] ?? 0)), 0);
-            vector = vector.map((val, idx) => val - (dot * (ejVector[idx] ?? 0)));
+            const dot = vector.reduce((sum, val, idx) => sum + val * (ejVector[idx] ?? 0), 0);
+            vector = vector.map((val, idx) => val - dot * (ejVector[idx] ?? 0));
         }
 
         // Power iteration
@@ -345,7 +361,7 @@ function findSmallestEigenvectors(matrix: number[][], k: number): {
                     if (matrixVal !== undefined && vecVal !== undefined) {
                         const nvVal = newVector[i];
                         if (nvVal !== undefined) {
-                            newVector[i] = nvVal + (matrixVal * vecVal);
+                            newVector[i] = nvVal + matrixVal * vecVal;
                         }
                     }
                 }
@@ -358,20 +374,20 @@ function findSmallestEigenvectors(matrix: number[][], k: number): {
                     continue;
                 }
 
-                const dot = newVector.reduce((sum, val, idx) => sum + (val * (ejVector[idx] ?? 0)), 0);
+                const dot = newVector.reduce((sum, val, idx) => sum + val * (ejVector[idx] ?? 0), 0);
                 for (let i = 0; i < n; i++) {
                     const ejVal = ejVector[i];
                     if (ejVal !== undefined) {
                         const nvVal = newVector[i];
                         if (nvVal !== undefined) {
-                            newVector[i] = nvVal - (dot * ejVal);
+                            newVector[i] = nvVal - dot * ejVal;
                         }
                     }
                 }
             }
 
             // Normalize
-            const norm = Math.sqrt(newVector.reduce((sum, val) => sum + ((val * val)), 0));
+            const norm = Math.sqrt(newVector.reduce((sum, val) => sum + val * val, 0));
             if (norm > 1e-10) {
                 vector = newVector.map((val) => val / norm);
             } else {
@@ -390,29 +406,30 @@ function findSmallestEigenvectors(matrix: number[][], k: number): {
                 if (matrixVal !== undefined && vecVal !== undefined) {
                     const avVal = Av[i];
                     if (avVal !== undefined) {
-                        Av[i] = avVal + (matrixVal * vecVal);
+                        Av[i] = avVal + matrixVal * vecVal;
                     }
                 }
             }
         }
         eigenvalue = vector.reduce((sum, val, idx) => {
             const avVal = Av[idx];
-            return sum + (val * (avVal ?? 0));
+            return sum + val * (avVal ?? 0);
         }, 0);
 
         eigenvectors.push(vector);
         eigenvalues.push(eigenvalue);
     }
 
-    return {eigenvalues, eigenvectors};
+    return { eigenvalues, eigenvectors };
 }
 
 /**
  * Normalize matrix rows to unit length
+ * @param matrix - Matrix to normalize in place
  */
 function normalizeRows(matrix: number[][]): void {
     for (const row of matrix) {
-        const norm = Math.sqrt(row.reduce((sum, val) => sum + (val * val), 0));
+        const norm = Math.sqrt(row.reduce((sum, val) => sum + val * val, 0));
         if (norm > 0) {
             for (let j = 0; j < row.length; j++) {
                 const val = row[j];
@@ -426,25 +443,30 @@ function normalizeRows(matrix: number[][]): void {
 
 /**
  * K-means clustering algorithm
+ * @param data - Array of data points, each point is an array of coordinates
+ * @param k - Number of clusters to form
+ * @param maxIterations - Maximum number of iterations
+ * @param tolerance - Convergence tolerance for centroid movement
+ * @returns Object containing cluster assignments and final centroids
  */
 function kMeansClustering(
     data: number[][],
     k: number,
     maxIterations: number,
     tolerance = 1e-4,
-): {assignments: number[], centroids: number[][]} {
+): { assignments: number[]; centroids: number[][] } {
     const n = data.length;
     const d = data[0]?.length ?? 0;
 
     // Handle edge cases
     if (n === 0 || k === 0) {
-        return {assignments: [], centroids: []};
+        return { assignments: [], centroids: [] };
     }
 
     if (k >= n) {
         // Each point is its own cluster
         return {
-            assignments: Array.from({length: n}, (_, i) => i),
+            assignments: Array.from({ length: n }, (_, i) => i),
             centroids: data.slice(0, n),
         };
     }
@@ -457,7 +479,7 @@ function kMeansClustering(
         const idx = Math.floor(Math.random() * n);
         if (!selectedIndices.has(idx) && data[idx]) {
             selectedIndices.add(idx);
-            centroids.push([... data[idx]]);
+            centroids.push([...data[idx]]);
         }
     }
 
@@ -509,14 +531,14 @@ function kMeansClustering(
             break;
         }
 
-        oldAssignments = [... assignments];
+        oldAssignments = [...assignments];
 
         // Store old centroids for tolerance-based convergence check
-        const oldCentroids = centroids.map((c) => [... c]);
+        const oldCentroids = centroids.map((c) => [...c]);
 
         // Update centroids
         const counts = Array(k).fill(0) as number[];
-        const sums: number[][] = Array.from({length: k}, () => Array(d).fill(0) as number[]);
+        const sums: number[][] = Array.from({ length: k }, () => Array(d).fill(0) as number[]);
 
         for (let i = 0; i < n; i++) {
             const cluster = assignments[i] ?? 0;
@@ -581,13 +603,21 @@ function kMeansClustering(
         }
     }
 
-    return {assignments, centroids};
+    return { assignments, centroids };
 }
 
 /**
  * Compute smallest eigenvectors for small k (optimized for k=2, k=3)
+ * @param matrix - The Laplacian matrix
+ * @param k - Number of eigenvectors to compute (1-3)
+ * @param n - Size of the matrix
+ * @returns Object containing eigenvalues and eigenvectors
  */
-function computeSmallestEigenvectorsSimple(matrix: number[][], k: number, n: number): {
+function computeSmallestEigenvectorsSimple(
+    matrix: number[][],
+    k: number,
+    n: number,
+): {
     eigenvalues: number[];
     eigenvectors: number[][];
 } {
@@ -603,11 +633,13 @@ function computeSmallestEigenvectorsSimple(matrix: number[][], k: number, n: num
     if (k >= 2) {
         // Use power iteration on I - L/lambda_max to find second smallest
         const maxEig = 2; // For normalized Laplacian, max eigenvalue <= 2
-        let vector = Array(n).fill(0).map(() => Math.random() - 0.5);
+        let vector = Array(n)
+            .fill(0)
+            .map(() => Math.random() - 0.5);
 
         // Make orthogonal to first eigenvector
-        const dot1 = vector.reduce((sum, val) => sum + (val / Math.sqrt(n)), 0);
-        vector = vector.map((val) => val - (dot1 / Math.sqrt(n)));
+        const dot1 = vector.reduce((sum, val) => sum + val / Math.sqrt(n), 0);
+        vector = vector.map((val) => val - dot1 / Math.sqrt(n));
 
         // Power iteration on shifted matrix
         for (let iter = 0; iter < 100; iter++) {
@@ -624,18 +656,18 @@ function computeSmallestEigenvectorsSimple(matrix: number[][], k: number, n: num
                 for (let j = 0; j < n; j++) {
                     const matrixVal = matrix[i]?.[j] ?? 0;
                     const vecVal = vector[j] ?? 0;
-                    newVector[i] = (newVector[i] ?? 0) - ((matrixVal * vecVal) / maxEig);
+                    newVector[i] = (newVector[i] ?? 0) - (matrixVal * vecVal) / maxEig;
                 }
             }
 
             // Orthogonalize against first eigenvector
-            const dot = newVector.reduce((sum, val) => sum + (val / Math.sqrt(n)), 0);
+            const dot = newVector.reduce((sum, val) => sum + val / Math.sqrt(n), 0);
             for (let i = 0; i < n; i++) {
-                newVector[i] = (newVector[i] ?? 0) - (dot / Math.sqrt(n));
+                newVector[i] = (newVector[i] ?? 0) - dot / Math.sqrt(n);
             }
 
             // Normalize
-            const norm = Math.sqrt(newVector.reduce((sum, val) => sum + (val * val), 0));
+            const norm = Math.sqrt(newVector.reduce((sum, val) => sum + val * val, 0));
             if (norm > 1e-10) {
                 vector = newVector.map((val) => val / norm);
             }
@@ -647,12 +679,14 @@ function computeSmallestEigenvectorsSimple(matrix: number[][], k: number, n: num
 
     // For k = 3, add another eigenvector
     if (k >= 3) {
-        let vector = Array(n).fill(0).map(() => Math.random() - 0.5);
+        let vector = Array(n)
+            .fill(0)
+            .map(() => Math.random() - 0.5);
 
         // Orthogonalize against previous eigenvectors
         for (const prev of eigenvectors) {
-            const dot = vector.reduce((sum, val, idx) => sum + (val * (prev[idx] ?? 0)), 0);
-            vector = vector.map((val, idx) => val - (dot * (prev[idx] ?? 0)));
+            const dot = vector.reduce((sum, val, idx) => sum + val * (prev[idx] ?? 0), 0);
+            vector = vector.map((val, idx) => val - dot * (prev[idx] ?? 0));
         }
 
         // Similar power iteration
@@ -669,20 +703,20 @@ function computeSmallestEigenvectorsSimple(matrix: number[][], k: number, n: num
                 for (let j = 0; j < n; j++) {
                     const matrixVal = matrix[i]?.[j] ?? 0;
                     const vecVal = vector[j] ?? 0;
-                    newVector[i] = (newVector[i] ?? 0) - ((matrixVal * vecVal) / 2);
+                    newVector[i] = (newVector[i] ?? 0) - (matrixVal * vecVal) / 2;
                 }
             }
 
             // Orthogonalize
             for (const prev of eigenvectors) {
-                const dot = newVector.reduce((sum, val, idx) => sum + (val * (prev[idx] ?? 0)), 0);
+                const dot = newVector.reduce((sum, val, idx) => sum + val * (prev[idx] ?? 0), 0);
                 for (let i = 0; i < n; i++) {
-                    newVector[i] = (newVector[i] ?? 0) - (dot * (prev[i] ?? 0));
+                    newVector[i] = (newVector[i] ?? 0) - dot * (prev[i] ?? 0);
                 }
             }
 
             // Normalize
-            const norm = Math.sqrt(newVector.reduce((sum, val) => sum + (val * val), 0));
+            const norm = Math.sqrt(newVector.reduce((sum, val) => sum + val * val, 0));
             if (norm > 1e-10) {
                 vector = newVector.map((val) => val / norm);
             }
@@ -692,5 +726,5 @@ function computeSmallestEigenvectorsSimple(matrix: number[][], k: number, n: num
         eigenvalues.push(0.2); // Approximate
     }
 
-    return {eigenvalues: eigenvalues.slice(0, k), eigenvectors: eigenvectors.slice(0, k)};
+    return { eigenvalues: eigenvalues.slice(0, k), eigenvectors: eigenvectors.slice(0, k) };
 }