feat: add seed parameter to unseeded stochastic functions

Add seed parameter to h_eigenvector_centrality, degree_assortativity,
simulate_kuramoto, and random_edge_shuffle for reproducibility.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: leotrs

xgi/algorithms/assortativity.py

@@ -65,7 +65,7 @@ def dynamical_assortativity(H):
     return kk1 * k1**2 / k2**2 - 1
 
 
-def degree_assortativity(H, kind="uniform", exact=False, num_samples=1000):
+def degree_assortativity(H, kind="uniform", exact=False, num_samples=1000, seed=None):
     """Computes the degree assortativity of a hypergraph
 
     Parameters
@@ -81,6 +81,8 @@ def degree_assortativity(H, kind="uniform", exact=False, num_samples=1000):
     num_samples : int, optional
         if not exact, specify the number of samples for the computation.
         By default, 1000.
+    seed : int or None, optional
+        The seed for the random number generator. By default, None.
 
     Returns
     -------
@@ -104,6 +106,10 @@ def degree_assortativity(H, kind="uniform", exact=False, num_samples=1000):
     DOI: 10.1093/comnet/cnaa018
     """
 
+    if seed is not None:
+        random.seed(seed)
+        np.random.seed(seed)
+
     if H.num_nodes == 0:
         raise XGIError("Hypergraph must contain nodes")
     elif H.num_edges == 0:

xgi/algorithms/centrality.py

@@ -294,7 +294,7 @@ def katz_centrality(H, cutoff=100):
     return {nodedict[idx]: c[idx] for idx in nodedict}
 
 
-def h_eigenvector_centrality(H, max_iter=100, tol=1e-6):
+def h_eigenvector_centrality(H, max_iter=100, tol=1e-6, seed=None):
     """Compute the H-eigenvector centrality of a hypergraph.
 
     The H-eigenvector terminology comes from Qi (2005) which
@@ -309,6 +309,8 @@ def h_eigenvector_centrality(H, max_iter=100, tol=1e-6):
         By default, 100.
     tol : float > 0, optional
         The desired convergence tolerance. By default, 1e-6.
+    seed : int or None, optional
+        The seed for the random number generator. By default, None.
 
     Returns
     -------
@@ -354,6 +356,9 @@ def h_eigenvector_centrality(H, max_iter=100, tol=1e-6):
     node_dict = new_H.nodes.memberships()
     r = new_H.edges.size.max()
 
+    if seed is not None:
+        np.random.seed(seed)
+
     x = np.random.uniform(size=(new_H.num_nodes))
     x = x / norm(x, 1)
     y = np.abs(np.array(ttsv1(node_dict, edge_dict, r, x)))

xgi/core/hypergraph.py

@@ -974,7 +974,7 @@ def double_edge_swap(self, n_id1, n_id2, e_id1, e_id2):
         self._edge[e_id1] = temp_members1
         self._edge[e_id2] = temp_members2
 
-    def random_edge_shuffle(self, e_id1=None, e_id2=None):
+    def random_edge_shuffle(self, e_id1=None, e_id2=None, seed=None):
         """Randomly redistributes nodes between two hyperedges.
 
         The process is as follows:
@@ -989,6 +989,8 @@ def random_edge_shuffle(self, e_id1=None, e_id2=None):
             ID of first edge to shuffle.
         e_id2 : node ID, optional
             ID of second edge to shuffle.
+        seed : int or None, optional
+            The seed for the random number generator. By default, None.
 
         Note
         ----
@@ -1007,13 +1009,15 @@ def random_edge_shuffle(self, e_id1=None, e_id2=None):
         Example
         -------
         >>> import xgi
-        >>> random.seed(42)
         >>> H = xgi.Hypergraph([[1, 2, 3], [3, 4], [4, 5]])
-        >>> H.random_edge_shuffle()
+        >>> H.random_edge_shuffle(seed=42)
         >>> H.edges.members()
         [{2, 4, 5}, {3, 4}, {1, 3}]
 
         """
+        if seed is not None:
+            random.seed(seed)
+
         if len(self._edge) < 2:
             raise ValueError("Hypergraph must have at least two edges.")
 

xgi/dynamics/synchronization.py

@@ -15,7 +15,7 @@
 ]
 
 
-def simulate_kuramoto(H, k2, k3, omega=None, theta=None, timesteps=10000, dt=0.002):
+def simulate_kuramoto(H, k2, k3, omega=None, theta=None, timesteps=10000, dt=0.002, seed=None):
     """Simulates the Kuramoto model on hypergraphs.
     This solves the Kuramoto model ODE on hypergraphs with edges of sizes 2 and 3
     using the Euler Method. It returns timeseries of the phases.
@@ -38,6 +38,8 @@ def simulate_kuramoto(H, k2, k3, omega=None, theta=None, timesteps=10000, dt=0.0
         The number of timesteps for Euler Method.
     dt : float greater than 0, default: 0.002
         The size of timesteps for Euler Method.
+    seed : int or None, optional
+        The seed for the random number generator. By default, None.
 
     Returns
     -------
@@ -74,6 +76,9 @@ def simulate_kuramoto(H, k2, k3, omega=None, theta=None, timesteps=10000, dt=0.0
     theta_time = np.zeros((timesteps, n))
     times = np.arange(timesteps) * dt
 
+    if seed is not None:
+        np.random.seed(seed)
+
     if omega is None:
         omega = np.random.normal(0, 1, n)