@graphty/algorithms 1.2.0 → 1.4.2

package/src/pathfinding/astar.ts

@@ -1,11 +1,10 @@
-import {graphNode} from "../utils/graphNode.js";
-import {MinPriorityQueue} from "../utils/priorityQueue.js";
-import {pathfindingUtils} from "./utils.js";
+import { graphNode } from "../utils/graphNode.js";
+import { MinPriorityQueue } from "../utils/priorityQueue.js";
+import { pathfindingUtils } from "./utils.js";
 
 /**
  * A* pathfinding algorithm
  * Finds the shortest path from start to goal using a heuristic function
- *
  * @param graph - The graph represented as an adjacency list
  * @param start - The starting node
  * @param goal - The goal node
@@ -20,7 +19,7 @@ export function astar<T>(
     start: T,
     goal: T,
     heuristic: (node: T, goal: T) => number,
-): {path: T[], cost: number} | null {
+): { path: T[]; cost: number } | null {
     if (!graph.has(start) || !graph.has(goal)) {
         return null;
     }
@@ -40,7 +39,7 @@ export function astar<T>(
         return null;
     }
 
-    openSet.insert({node: start, distance: startFScore});
+    openSet.insert({ node: start, distance: startFScore });
 
     while (!openSet.isEmpty()) {
         const current = openSet.extractMin();
@@ -58,7 +57,7 @@ export function astar<T>(
                 return null;
             }
 
-            return {path, cost: goalCost};
+            return { path, cost: goalCost };
         }
 
         closedSet.add(currentNode);
@@ -90,7 +89,7 @@ export function astar<T>(
                 // Add to open set if not already there
                 const neighborFScore = fScore.get(neighbor);
                 if (neighborFScore !== undefined) {
-                    openSet.insert({node: neighbor, distance: neighborFScore});
+                    openSet.insert({ node: neighbor, distance: neighborFScore });
                 }
             }
         }
@@ -102,6 +101,11 @@ export function astar<T>(
 /**
  * A* pathfinding with path reconstruction details
  * Returns detailed information about the search process
+ * @param graph - The graph represented as an adjacency list
+ * @param start - The starting node
+ * @param goal - The goal node
+ * @param heuristic - Heuristic function that estimates distance from node to goal
+ * @returns Detailed result including path, cost, visited nodes, and score maps
  */
 export function astarWithDetails<T>(
     graph: Map<T, Map<T, number>>,
@@ -109,12 +113,12 @@ export function astarWithDetails<T>(
     goal: T,
     heuristic: (node: T, goal: T) => number,
 ): {
-        path: T[] | null;
-        cost: number;
-        visited: Set<T>;
-        gScores: Map<T, number>;
-        fScores: Map<T, number>;
-    } {
+    path: T[] | null;
+    cost: number;
+    visited: Set<T>;
+    gScores: Map<T, number>;
+    fScores: Map<T, number>;
+} {
     const openSet = new MinPriorityQueue<graphNode<T>>();
     const gScore = new Map<T, number>();
     const fScore = new Map<T, number>();
@@ -134,7 +138,7 @@ export function astarWithDetails<T>(
         };
     }
 
-    openSet.insert({node: start, distance: startFScore});
+    openSet.insert({ node: start, distance: startFScore });
 
     while (!openSet.isEmpty()) {
         const current = openSet.extractMin();
@@ -181,7 +185,7 @@ export function astarWithDetails<T>(
                 fScore.set(neighbor, tentativeGScore + heuristic(neighbor, goal));
                 const neighborFScore = fScore.get(neighbor);
                 if (neighborFScore !== undefined) {
-                    openSet.insert({node: neighbor, distance: neighborFScore});
+                    openSet.insert({ node: neighbor, distance: neighborFScore });
                 }
             }
         }
@@ -201,29 +205,40 @@ export function astarWithDetails<T>(
  */
 export const heuristics = {
     /**
-   * Manhattan distance heuristic for grid-based graphs
-   */
+     * Manhattan distance heuristic for grid-based graphs
+     * @param a - First coordinate as [x, y] tuple
+     * @param b - Second coordinate as [x, y] tuple
+     * @returns The Manhattan distance between the two points
+     */
     manhattan: (a: [number, number], b: [number, number]): number => {
         return Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]);
     },
 
     /**
-   * Euclidean distance heuristic
-   */
+     * Euclidean distance heuristic
+     * @param a - First coordinate as [x, y] tuple
+     * @param b - Second coordinate as [x, y] tuple
+     * @returns The Euclidean distance between the two points
+     */
     euclidean: (a: [number, number], b: [number, number]): number => {
         return Math.sqrt(Math.pow(a[0] - b[0], 2) + Math.pow(a[1] - b[1], 2));
     },
 
     /**
-   * Chebyshev distance heuristic (diagonal movement allowed)
-   */
+     * Chebyshev distance heuristic (diagonal movement allowed)
+     * @param a - First coordinate as [x, y] tuple
+     * @param b - Second coordinate as [x, y] tuple
+     * @returns The Chebyshev distance between the two points
+     */
     chebyshev: (a: [number, number], b: [number, number]): number => {
         return Math.max(Math.abs(a[0] - b[0]), Math.abs(a[1] - b[1]));
     },
 
     /**
-   * Zero heuristic (makes A* behave like Dijkstra)
-   */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+     * Zero heuristic (makes A* behave like Dijkstra)
+     * @param _a - First node (unused)
+     * @param _b - Second node (unused)
+     * @returns Always returns 0
+     */
     zero: <T>(_a: T, _b: T): number => 0,
 };

package/src/pathfinding/utils.ts

@@ -4,8 +4,11 @@
 
 export const pathfindingUtils = {
     /**
-   * Reconstructs a path from start to goal using the cameFrom map
-   */
+     * Reconstructs a path from start to goal using the cameFrom map
+     * @param cameFrom - Map of each node to its predecessor on the path
+     * @param goal - The goal node to reconstruct the path to
+     * @returns An array of nodes representing the path from start to goal
+     */
     reconstructPath<T>(cameFrom: Map<T, T>, goal: T): T[] {
         const path: T[] = [goal];
         let current = goal;
@@ -24,13 +27,13 @@ export const pathfindingUtils = {
     },
 
     /**
-   * Creates a grid graph for testing pathfinding algorithms
-   */
-    createGridGraph(
-        width: number,
-        height: number,
-        obstacles = new Set<string>(),
-    ): Map<string, Map<string, number>> {
+     * Creates a grid graph for testing pathfinding algorithms
+     * @param width - The width of the grid
+     * @param height - The height of the grid
+     * @param obstacles - Set of obstacle coordinates as "x,y" strings
+     * @returns A grid graph with 4-directional movement
+     */
+    createGridGraph(width: number, height: number, obstacles = new Set<string>()): Map<string, Map<string, number>> {
         const graph = new Map<string, Map<string, number>>();
 
         for (let x = 0; x < width; x++) {
@@ -44,7 +47,10 @@ export const pathfindingUtils = {
 
                 // Add 4-directional neighbors
                 const directions = [
-                    [0, 1], [1, 0], [0, -1], [-1, 0],
+                    [0, 1],
+                    [1, 0],
+                    [0, -1],
+                    [-1, 0],
                 ];
 
                 for (const dir of directions) {
@@ -71,8 +77,10 @@ export const pathfindingUtils = {
     },
 
     /**
-   * Parses a grid coordinate string
-   */
+     * Parses a grid coordinate string
+     * @param coord - The coordinate string in "x,y" format
+     * @returns A tuple of [x, y] coordinates
+     */
     parseGridCoordinate(coord: string): [number, number] {
         const parts = coord.split(",").map(Number);
         const x = parts[0];
@@ -84,4 +92,3 @@ export const pathfindingUtils = {
         return [x, y];
     },
 };
-

package/src/research/grsbm.ts

@@ -1,5 +1,6 @@
-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";
+import { SeededRandom } from "../utils/math-utilities.js";
 
 /**
  * Configuration options for the GRSBM (Greedy Recursive Spectral Bisection) algorithm
@@ -79,7 +80,6 @@ export interface ClusterExplanation {
  * community structure by tracking the reasoning behind each split.
  *
  * Based on: "Explainable Community Detection via Hierarchical Spectral Clustering" (2024)
- *
  * @param graph - Input graph to cluster
  * @param config - Configuration options
  * @returns Hierarchical clustering result with explanations
@@ -95,7 +95,9 @@ export function grsbm(graph: Graph, config: GRSBMConfig = {}): GRSBMResult {
     } = config;
 
     // Set random seed for reproducibility
-    Math.random = seedRandom(seed);
+    const rng = SeededRandom.createGenerator(seed);
+    const originalRandom = Math.random;
+    Math.random = rng;
 
     const nodes = Array.from(graph.nodes());
     const nodeCount = nodes.length;
@@ -106,7 +108,7 @@ export function grsbm(graph: Graph, config: GRSBMConfig = {}): GRSBMResult {
 
     // Initialize root cluster with all nodes
     const rootMembers = new Set(nodes.map((node) => node.id));
-    const initialModularity = calculateModularity(graph, new Map([... rootMembers].map((id) => [id, 0])));
+    const initialModularity = calculateModularity(graph, new Map([...rootMembers].map((id) => [id, 0])));
 
     const root: GRSBMCluster = {
         id: "root",
@@ -130,25 +132,18 @@ export function grsbm(graph: Graph, config: GRSBMConfig = {}): GRSBMResult {
         }
 
         // Check stopping criteria
-        if (currentCluster.depth >= maxDepth ||
-            currentCluster.members.size < minClusterSize * 2) {
+        if (currentCluster.depth >= maxDepth || currentCluster.members.size < minClusterSize * 2) {
             continue;
         }
 
         // Attempt spectral bisection
-        const bisectionResult = spectralBisection(
-            graph,
-            currentCluster,
-            numEigenvectors,
-            tolerance,
-            maxIterations,
-        );
+        const bisectionResult = spectralBisection(graph, currentCluster, numEigenvectors, tolerance, maxIterations);
 
         if (!bisectionResult) {
             continue; // Could not split this cluster
         }
 
-        const {leftMembers, rightMembers, spectralScore, keyNodes, spectralValues, reason} = bisectionResult;
+        const { leftMembers, rightMembers, spectralScore, keyNodes, spectralValues, reason } = bisectionResult;
 
         // Create child clusters
         const leftCluster: GRSBMCluster = {
@@ -180,7 +175,8 @@ export function grsbm(graph: Graph, config: GRSBMConfig = {}): GRSBMResult {
         const modularityImprovement = newModularity - currentCluster.modularity;
 
         // Only split if modularity improves or is neutral (allow small splits)
-        if (modularityImprovement >= -0.01) { // Small tolerance for neutral splits
+        if (modularityImprovement >= -0.01) {
+            // Small tolerance for neutral splits
             leftCluster.modularity = newModularity;
             rightCluster.modularity = newModularity;
 
@@ -228,6 +224,9 @@ export function grsbm(graph: Graph, config: GRSBMConfig = {}): GRSBMResult {
 
     assignClusterIds(root);
 
+    // Restore original random function
+    Math.random = originalRandom;
+
     return {
         root,
         clusters,
@@ -239,6 +238,12 @@ export function grsbm(graph: Graph, config: GRSBMConfig = {}): GRSBMResult {
 
 /**
  * Perform spectral bisection on a cluster
+ * @param graph - The input graph
+ * @param cluster - The cluster to bisect
+ * @param numEigenvectors - Number of eigenvectors to compute
+ * @param tolerance - Convergence tolerance
+ * @param maxIterations - Maximum number of iterations
+ * @returns Bisection result with left/right members, scores, and explanation, or null if bisection failed
  */
 function spectralBisection(
     graph: Graph,
@@ -272,9 +277,7 @@ function spectralBisection(
     }
 
     // Find optimal split point
-    const sortedIndices = eigenvector
-        .map((value, index) => ({value, index}))
-        .sort((a, b) => a.value - b.value);
+    const sortedIndices = eigenvector.map((value, index) => ({ value, index })).sort((a, b) => a.value - b.value);
 
     let bestSplitIndex = Math.floor(n / 2);
     let bestModularity = -Infinity;
@@ -329,7 +332,7 @@ function spectralBisection(
 
     // Identify key nodes (those with extreme spectral values)
     const extremeThreshold = 0.1;
-    const sortedValues = [... eigenvector].sort((a, b) => Math.abs(b) - Math.abs(a));
+    const sortedValues = [...eigenvector].sort((a, b) => Math.abs(b) - Math.abs(a));
     const threshold = sortedValues[Math.floor(sortedValues.length * extremeThreshold)] ?? 0;
 
     const keyNodes: NodeId[] = [];
@@ -363,6 +366,9 @@ function spectralBisection(
 
 /**
  * Create Laplacian matrix for a subgraph
+ * @param graph - The input graph
+ * @param nodes - The nodes to include in the subgraph
+ * @returns The Laplacian matrix as a 2D array
  */
 function createLaplacianMatrix(graph: Graph, nodes: NodeId[]): number[][] {
     const n = nodes.length;
@@ -377,7 +383,7 @@ function createLaplacianMatrix(graph: Graph, nodes: NodeId[]): number[][] {
     }
 
     // Initialize Laplacian matrix
-    const laplacian = Array.from({length: n}, () => new Array<number>(n).fill(0));
+    const laplacian = Array.from({ length: n }, () => new Array<number>(n).fill(0));
 
     // Fill adjacency part and calculate degrees
     const degrees = new Array<number>(n).fill(0);
@@ -414,6 +420,10 @@ function createLaplacianMatrix(graph: Graph, nodes: NodeId[]): number[][] {
 
 /**
  * Compute the Fiedler vector (second smallest eigenvector) using power iteration
+ * @param laplacian - The Laplacian matrix
+ * @param tolerance - Convergence tolerance
+ * @param maxIterations - Maximum number of iterations
+ * @returns The Fiedler vector, or null if computation failed
  */
 function computeFiedlerVector(laplacian: number[][], tolerance: number, maxIterations: number): number[] | null {
     const n = laplacian.length;
@@ -437,7 +447,7 @@ function computeFiedlerVector(laplacian: number[][], tolerance: number, maxItera
     }
 
     // Normalize
-    const norm = Math.sqrt(vector.reduce((sum: number, val: number) => sum + (val * val), 0));
+    const norm = Math.sqrt(vector.reduce((sum: number, val: number) => sum + val * val, 0));
     if (norm > 0) {
         for (let i = 0; i < n; i++) {
             const val = vector[i];
@@ -488,7 +498,7 @@ function computeFiedlerVector(laplacian: number[][], tolerance: number, maxItera
         }
 
         // Normalize
-        const newNorm = Math.sqrt(newVector.reduce((sum, val) => sum + (val * val), 0));
+        const newNorm = Math.sqrt(newVector.reduce((sum, val) => sum + val * val, 0));
         if (newNorm < tolerance) {
             break; // Converged to zero vector
         }
@@ -522,6 +532,9 @@ function computeFiedlerVector(laplacian: number[][], tolerance: number, maxItera
 
 /**
  * Calculate modularity of a graph partitioning
+ * @param graph - The input graph
+ * @param assignment - Map from node ID to community ID
+ * @returns The modularity score
  */
 function calculateModularity(graph: Graph, assignment: Map<NodeId, number>): number {
     const totalEdges = graph.uniqueEdgeCount;
@@ -571,19 +584,3 @@ function calculateModularity(graph: Graph, assignment: Map<NodeId, number>): num
 
     return modularity;
 }
-
-/**
- * Simple seeded random number generator for reproducibility
- */
-function seedRandom(seed: number): () => number {
-    const m = 0x80000000; // 2**31
-    const a = 1103515245;
-    const c = 12345;
-
-    seed = seed % m;
-
-    return function() {
-        seed = ((a * seed) + c) % m;
-        return seed / (m - 1);
-    };
-}

package/src/research/index.ts

@@ -7,11 +7,11 @@
  */
 
 // Synergistic Deep Graph Clustering
-export {syncClustering, type SynCConfig, type SynCResult} from "./sync.js";
+export { syncClustering, type SynCConfig, type SynCResult } from "./sync.js";
 
 // TeraHAC - Hierarchical Agglomerative Clustering
-export {teraHAC, type TeraHACConfig, type TeraHACResult} from "./terahac.js";
-export {type ClusterNode as TeraHACClusterNode} from "./terahac.js";
+export { teraHAC, type TeraHACConfig, type TeraHACResult } from "./terahac.js";
+export { type ClusterNode as TeraHACClusterNode } from "./terahac.js";
 
 // GRSBM - Greedy Recursive Spectral Bisection with Modularity
-export {type ClusterExplanation, grsbm, type GRSBMCluster, type GRSBMConfig, type GRSBMResult} from "./grsbm.js";
+export { type ClusterExplanation, grsbm, type GRSBMCluster, type GRSBMConfig, type GRSBMResult } from "./grsbm.js";

package/src/research/sync.ts

@@ -1,5 +1,6 @@
-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";
+import { euclideanDistance, SeededRandom } from "../utils/math-utilities.js";
 
 /**
  * Configuration options for the SynC (Synergistic Deep Graph Clustering) algorithm
@@ -43,24 +44,17 @@ export interface SynCResult {
  * embeddings and cluster assignments while preserving graph structure.
  *
  * Based on: "Synergistic Deep Graph Clustering" (arXiv:2406.15797, June 2024)
- *
  * @param graph - Input graph to cluster
  * @param config - Configuration options
  * @returns Clustering result with assignments and embeddings
  */
 export function syncClustering(graph: Graph, config: SynCConfig): SynCResult {
-    const {
-        numClusters,
-        maxIterations = 100,
-        tolerance = 1e-6,
-        seed = 42,
-        learningRate = 0.01,
-        lambda = 0.1,
-    } = config;
+    const { numClusters, maxIterations = 100, tolerance = 1e-6, seed = 42, learningRate = 0.01, lambda = 0.1 } = config;
 
     // Set random seed for reproducibility (save original)
     const originalRandom = Math.random;
-    Math.random = seedRandom(seed);
+    const rng = SeededRandom.createGenerator(seed);
+    Math.random = rng;
 
     const nodes = Array.from(graph.nodes());
     const nodeCount = nodes.length;
@@ -76,7 +70,9 @@ export function syncClustering(graph: Graph, config: SynCConfig): SynCResult {
     }
 
     if (numClusters <= 0 || numClusters > nodeCount) {
-        throw new Error(`Invalid number of clusters: ${String(numClusters)}. Must be between 1 and ${String(nodeCount)}`);
+        throw new Error(
+            `Invalid number of clusters: ${String(numClusters)}. Must be between 1 and ${String(nodeCount)}`,
+        );
     }
 
     // Initialize node embeddings (simplified version using graph features)
@@ -182,6 +178,10 @@ export function syncClustering(graph: Graph, config: SynCConfig): SynCResult {
 
 /**
  * Initialize node embedding based on graph structure and features
+ * @param graph - The input graph
+ * @param nodeId - The node ID to initialize embedding for
+ * @param dim - The embedding dimension
+ * @returns The initialized embedding vector
  */
 function initializeNodeEmbedding(graph: Graph, nodeId: NodeId, dim: number): number[] {
     const embedding = new Array<number>(dim).fill(0);
@@ -192,7 +192,7 @@ function initializeNodeEmbedding(graph: Graph, nodeId: NodeId, dim: number): num
 
     // Initialize with small random values influenced by graph structure
     for (let i = 0; i < dim; i++) {
-        embedding[i] = ((Math.random() - 0.5) * 0.1) + (normalizedDegree * 0.1);
+        embedding[i] = (Math.random() - 0.5) * 0.1 + normalizedDegree * 0.1;
     }
 
     return embedding;
@@ -200,6 +200,9 @@ function initializeNodeEmbedding(graph: Graph, nodeId: NodeId, dim: number): num
 
 /**
  * Initialize cluster centers using k-means++ style initialization
+ * @param embeddings - Map of node IDs to embedding vectors
+ * @param numClusters - Number of cluster centers to initialize
+ * @returns Array of initialized cluster center vectors
  */
 function initializeClusterCenters(embeddings: Map<NodeId, number[]>, numClusters: number): number[][] {
     const embeddingArray = Array.from(embeddings.values());
@@ -208,7 +211,7 @@ function initializeClusterCenters(embeddings: Map<NodeId, number[]>, numClusters
     // Choose first center randomly
     const firstCenter = embeddingArray[Math.floor(Math.random() * embeddingArray.length)];
     if (firstCenter) {
-        centers.push([... firstCenter] as number[]);
+        centers.push([...firstCenter] as number[]);
     }
 
     // Choose remaining centers using k-means++ initialization
@@ -237,7 +240,7 @@ function initializeClusterCenters(embeddings: Map<NodeId, number[]>, numClusters
             if (randomValue <= 0) {
                 const newCenter = embeddingArray[i];
                 if (newCenter) {
-                    centers.push([... newCenter] as number[]);
+                    centers.push([...newCenter] as number[]);
                 }
 
                 break;
@@ -250,6 +253,11 @@ function initializeClusterCenters(embeddings: Map<NodeId, number[]>, numClusters
 
 /**
  * Update node embeddings using gradient descent
+ * @param graph - The input graph
+ * @param embeddings - Map of node IDs to embedding vectors
+ * @param clusters - Map of node IDs to cluster assignments
+ * @param learningRate - Learning rate for gradient descent
+ * @param lambda - Regularization parameter
  */
 function updateEmbeddings(
     graph: Graph,
@@ -291,7 +299,7 @@ function updateEmbeddings(
                 const gradVal = gradient[i];
                 const diffVal = diff[i];
                 if (gradVal !== undefined && diffVal !== undefined) {
-                    gradient[i] = gradVal + (lambda * diffVal);
+                    gradient[i] = gradVal + lambda * diffVal;
                 }
             }
         }
@@ -301,7 +309,7 @@ function updateEmbeddings(
             const gradVal = gradient[i];
             const nodeVal = nodeEmbedding[i];
             if (gradVal !== undefined && nodeVal !== undefined) {
-                gradient[i] = gradVal + (lambda * nodeVal);
+                gradient[i] = gradVal + lambda * nodeVal;
             }
         }
     }
@@ -317,7 +325,7 @@ function updateEmbeddings(
             const embVal = embedding[i];
             const gradVal = gradient[i];
             if (embVal !== undefined && gradVal !== undefined) {
-                embedding[i] = embVal - (learningRate * gradVal);
+                embedding[i] = embVal - learningRate * gradVal;
             }
         }
     }
@@ -325,6 +333,10 @@ function updateEmbeddings(
 
 /**
  * Update cluster centers based on current assignments
+ * @param embeddings - Map of node IDs to embedding vectors
+ * @param clusters - Map of node IDs to cluster assignments
+ * @param clusterCenters - Array of cluster center vectors to update
+ * @param numClusters - Number of clusters
  */
 function updateClusterCenters(
     embeddings: Map<NodeId, number[]>,
@@ -333,8 +345,9 @@ function updateClusterCenters(
     numClusters: number,
 ): void {
     const dimensions = clusterCenters[0]?.length ?? 0;
-    const clusterSums: number[][] = Array.from({length: numClusters}, () =>
-        new Array(dimensions).fill(0) as number[],
+    const clusterSums: number[][] = Array.from(
+        { length: numClusters },
+        () => new Array(dimensions).fill(0) as number[],
     );
     const clusterCounts = new Array<number>(numClusters).fill(0);
 
@@ -380,6 +393,12 @@ function updateClusterCenters(
 
 /**
  * Calculate the total loss function
+ * @param graph - The input graph
+ * @param embeddings - Map of node IDs to embedding vectors
+ * @param clusters - Map of node IDs to cluster assignments
+ * @param clusterCenters - Array of cluster center vectors
+ * @param lambda - Regularization parameter
+ * @returns The total loss value
  */
 function calculateLoss(
     graph: Graph,
@@ -433,37 +452,5 @@ function calculateLoss(
         }
     }
 
-    return clusteringLoss + (lambda * reconstructionLoss) + (lambda * regularizationLoss);
-}
-
-/**
- * Calculate Euclidean distance between two vectors
- */
-function euclideanDistance(a: number[], b: number[]): number {
-    let sum = 0;
-    for (let i = 0; i < a.length; i++) {
-        const aVal = a[i];
-        const bVal = b[i];
-        if (aVal !== undefined && bVal !== undefined) {
-            const diff = aVal - bVal;
-            sum += diff * diff;
-        }
-    }
-    return Math.sqrt(sum);
-}
-
-/**
- * Simple seeded random number generator for reproducibility
- */
-function seedRandom(seed: number): () => number {
-    const m = 0x80000000; // 2**31
-    const a = 1103515245;
-    const c = 12345;
-
-    seed = seed % m;
-
-    return function() {
-        seed = ((a * seed) + c) % m;
-        return seed / (m - 1);
-    };
+    return clusteringLoss + lambda * reconstructionLoss + lambda * regularizationLoss;
 }