use a stable rng from StableRNGs for reproducibility (#170)

* use a stable rng from `StableRNGs`

* update workflows

* remove `GLOBAL_RNG` leftovers

* workflows: use `@latest` action where possible

* add explicit return

* update

* change `seed` to default `nothing` - add docs - remove `kw...`

* restore `MersenneTwister` rng in `getRNG`

* use a local `rng` foreach test

* replace missing `kw...`

* fix docstring

* remove stale imports

* revert chagnes to rng_from_rng_or_seed

Co-authored-by: Simon Schoelly <[email protected]>

Author: t-bltg

Project.toml

@@ -26,7 +26,8 @@ julia = "1.6"
 [extras]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
 DelimitedFiles = "8bb1440f-4735-579b-a4ab-409b98df4dab"
+StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Base64", "DelimitedFiles", "Test"]
+test = ["Base64", "DelimitedFiles", "StableRNGs", "Test"]

src/Graphs.jl

@@ -16,7 +16,6 @@ import LinearAlgebra: Diagonal, issymmetric, mul!
 using Random: AbstractRNG, GLOBAL_RNG, MersenneTwister, randperm, randsubseq!, seed!, shuffle, shuffle!
 using SparseArrays: SparseMatrixCSC, nonzeros, nzrange, rowvals
 import SparseArrays: blockdiag, sparse
-
 import Base: adjoint, write, ==, <, *, ≈, convert, isless, issubset, union, intersect,
             reverse, reverse!, isassigned, getindex, setindex!, show,
             print, copy, in, sum, size, eltype, length, ndims, transpose,

src/Parallel/Parallel.jl

@@ -6,7 +6,7 @@ using Distributed: @distributed
 using Base.Threads: @threads, nthreads, Atomic, atomic_add!, atomic_cas!
 using SharedArrays: SharedMatrix, SharedVector, sdata
 using ArnoldiMethod
-using Random:shuffle
+using Random: AbstractRNG, shuffle
 import SparseArrays: sparse
 import Base: push!, popfirst!, isempty, getindex
 

src/Parallel/centrality/betweenness.jl

@@ -2,9 +2,15 @@ betweenness_centrality(g::AbstractGraph, vs=vertices(g), distmx::AbstractMatrix=
 parallel == :distributed ? distr_betweenness_centrality(g, vs, distmx; normalize=normalize, endpoints=endpoints) : 
 threaded_betweenness_centrality(g, vs, distmx; normalize=normalize, endpoints=endpoints)
 
-betweenness_centrality(g::AbstractGraph, k::Integer, distmx::AbstractMatrix=weights(g); normalize=true, endpoints=false, parallel=:distributed) = 
-parallel == :distributed ? distr_betweenness_centrality(g, sample(vertices(g), k), distmx; normalize=normalize, endpoints=endpoints) :
-threaded_betweenness_centrality(g, sample(vertices(g), k), distmx; normalize=normalize, endpoints=endpoints)
+function betweenness_centrality(
+    g::AbstractGraph, k::Integer, distmx::AbstractMatrix=weights(g);
+    normalize=true, endpoints=false, parallel=:distributed,
+    rng::Union{Nothing, AbstractRNG}=nothing, seed::Union{Nothing, Integer}=nothing
+)
+    samples = sample(vertices(g), k; rng=rng, seed=seed)
+    parallel == :distributed ? distr_betweenness_centrality(g, samples, distmx; normalize=normalize, endpoints=endpoints) :
+    threaded_betweenness_centrality(g, samples, distmx; normalize=normalize, endpoints=endpoints)
+end
 
 function distr_betweenness_centrality(g::AbstractGraph,
     vs=vertices(g),
@@ -36,8 +42,13 @@ function distr_betweenness_centrality(g::AbstractGraph,
     return betweenness
 end
 
-distr_betweenness_centrality(g::AbstractGraph, k::Integer, distmx::AbstractMatrix=weights(g); normalize=true, endpoints=false) =
-    distr_betweenness_centrality(g, sample(vertices(g), k), distmx; normalize=normalize, endpoints=endpoints)
+function distr_betweenness_centrality(
+    g::AbstractGraph, k::Integer, distmx::AbstractMatrix=weights(g);
+    normalize=true, endpoints=false, rng::Union{Nothing, AbstractRNG}=nothing, seed::Union{Nothing, Integer}=nothing
+)   
+    samples = sample(vertices(g), k; rng=rng, seed=seed)
+    distr_betweenness_centrality(g, samples, distmx; normalize=normalize, endpoints=endpoints)
+end
 
 function threaded_betweenness_centrality(g::AbstractGraph,
     vs=vertices(g),
@@ -71,5 +82,10 @@ function threaded_betweenness_centrality(g::AbstractGraph,
     return betweenness
 end
 
-threaded_betweenness_centrality(g::AbstractGraph, k::Integer, distmx::AbstractMatrix=weights(g); normalize=true, endpoints=false) =
-    threaded_betweenness_centrality(g, sample(vertices(g), k), distmx; normalize=normalize, endpoints=endpoints)
+function threaded_betweenness_centrality(
+    g::AbstractGraph, k::Integer, distmx::AbstractMatrix=weights(g);
+    normalize=true, endpoints=false, rng::Union{Nothing, AbstractRNG}=nothing, seed::Union{Nothing, Integer}=nothing
+)
+    samples = sample(vertices(g), k; rng=rng, seed=seed)
+    threaded_betweenness_centrality(g, samples, distmx; normalize=normalize, endpoints=endpoints)
+end

src/Parallel/centrality/stress.jl

@@ -1,9 +1,14 @@
 stress_centrality(g::AbstractGraph, vs=vertices(g); parallel=:distributed) =
 parallel == :distributed ? distr_stress_centrality(g, vs) : threaded_stress_centrality(g, vs)
 
-stress_centrality(g::AbstractGraph, k::Integer; parallel=:distributed) =
-parallel == :distributed ? distr_stress_centrality(g, sample(vertices(g), k)) : 
-threaded_stress_centrality(g, sample(vertices(g), k))
+function stress_centrality(
+    g::AbstractGraph, k::Integer;
+    parallel=:distributed, rng::Union{Nothing, AbstractRNG}=nothing, seed::Union{Nothing, Integer}=nothing
+)
+    samples = sample(vertices(g), k; rng=rng, seed=seed)
+    parallel == :distributed ? distr_stress_centrality(g, samples) :
+    threaded_stress_centrality(g, samples)
+end
 
 function distr_stress_centrality(g::AbstractGraph,
     vs=vertices(g))::Vector{Int64}

src/Parallel/dominatingset/minimal_dom_set.jl

@@ -1,5 +1,5 @@
 """
-    dominating_set(g, reps, MinimalDominatingSet(); parallel=:threads, seed=-1)
+    dominating_set(g, reps, MinimalDominatingSet(); parallel=:threads, rng=nothing, seed=nothing)
 
 Perform [`Graphs.dominating_set(g, MinimalDominatingSet())`](@ref) `reps` times in parallel 
 and return the solution with the fewest vertices.
@@ -9,6 +9,15 @@ and return the solution with the fewest vertices.
 used. This implementation is more efficient if `reps` is large.
 - If `seed >= 0`, a random generator of each process/thread is seeded with this value.
 """
-dominating_set(g::AbstractGraph{T}, reps::Integer, alg::MinimalDominatingSet; parallel=:threads, seed=-1) where T <: Integer = 
-Graphs.Parallel.generate_reduce(g, (g::AbstractGraph{T})->Graphs.dominating_set(g, alg; seed=seed), 
-(x::Vector{T}, y::Vector{T})->length(x)<length(y), reps; parallel=parallel)
+function dominating_set(
+    g::AbstractGraph{T}, reps::Integer, alg::MinimalDominatingSet;
+    parallel=:threads, rng::Union{Nothing, AbstractRNG}=nothing, seed::Union{Nothing, Integer}=nothing
+) where T <: Integer
+    Graphs.Parallel.generate_reduce(
+        g,
+        (g::AbstractGraph{T})->Graphs.dominating_set(g, alg; rng=rng, seed=seed), 
+        (x::Vector{T}, y::Vector{T})->length(x)<length(y),
+        reps;
+        parallel=parallel
+    )
+end

src/Parallel/independentset/maximal_ind_set.jl

@@ -1,5 +1,5 @@
 """
-    independent_set(g, reps, MaximalIndependentSet(); parallel=:threads)
+    independent_set(g, reps, MaximalIndependentSet(); parallel=:threads, rng=nothing, seed=nothing)
 
 Perform [`Graphs.independent_set(g, MaximalIndependentSet())`](@ref) `reps` times in parallel 
 and return the solution with the most vertices.
@@ -8,6 +8,15 @@ and return the solution with the most vertices.
 - `parallel=:threads`: If `parallel=:distributed` then the multiprocessor implementation is
 used. This implementation is more efficient if `reps` is large.
 """
-independent_set(g::AbstractGraph{T}, reps::Integer, alg::MaximalIndependentSet; parallel=:threads) where T <: Integer = 
-Graphs.Parallel.generate_reduce(g, (g::AbstractGraph{T})->Graphs.independent_set(g, alg), 
-(x::Vector{T}, y::Vector{T})->length(x)>length(y), reps; parallel=parallel)
+function independent_set(
+    g::AbstractGraph{T}, reps::Integer, alg::MaximalIndependentSet;
+    parallel=:threads, rng::Union{Nothing, AbstractRNG}=nothing, seed::Union{Nothing, Integer}=nothing
+) where T <: Integer
+    Graphs.Parallel.generate_reduce(
+        g,
+        (g::AbstractGraph{T})->Graphs.independent_set(g, alg; rng=rng, seed=seed), 
+        (x::Vector{T}, y::Vector{T})->length(x)>length(y),
+        reps;
+        parallel=parallel
+    )
+end

src/Parallel/vertexcover/random_vertex_cover.jl

@@ -1,5 +1,5 @@
 """
-    vertex_cover(g, reps, RandomVertexCover(); parallel=:threads)
+    vertex_cover(g, reps, RandomVertexCover(); parallel=:threads, rng=nothing, seed=nothing)
 
 Perform [`Graphs.vertex_cover(g, RandomVertexCover())`](@ref) `reps` times in parallel 
 and return the solution with the fewest vertices.
@@ -8,6 +8,15 @@ and return the solution with the fewest vertices.
 - `parallel=:threads`: If `parallel=:distributed` then the multiprocessor implementation is
 used. This implementation is more efficient if `reps` is large.
 """
-vertex_cover(g::AbstractGraph{T}, reps::Integer, alg::RandomVertexCover; parallel=:threads) where T <: Integer = 
-Graphs.Parallel.generate_reduce(g, (g::AbstractGraph{T})->Graphs.vertex_cover(g, alg), 
-(x::Vector{T}, y::Vector{T})->length(x)<length(y), reps; parallel=parallel)
+function vertex_cover(
+    g::AbstractGraph{T}, reps::Integer, alg::RandomVertexCover;
+    parallel=:threads, rng::Union{Nothing, AbstractRNG}=nothing, seed::Union{Nothing, Integer}=nothing
+) where T <: Integer
+    Graphs.Parallel.generate_reduce(
+        g,
+        (g::AbstractGraph{T})->Graphs.vertex_cover(g, alg; rng=rng, seed=seed), 
+        (x::Vector{T}, y::Vector{T})->length(x)<length(y),
+        reps;
+        parallel=parallel
+    )
+end

src/SimpleGraphs/SimpleGraphs.jl

@@ -5,6 +5,8 @@ using LinearAlgebra
 using Graphs
 using SimpleTraits
 
+import Random: AbstractRNG
+
 import Base:
     eltype, show, ==, Pair, Tuple, copy, length, issubset, reverse, zero, in, iterate
 
@@ -13,9 +15,7 @@ import Graphs:
     src, dst, edgetype, nv, ne, vertices, edges, is_directed,
     has_vertex, has_edge, inneighbors, outneighbors, all_neighbors,
     deepcopy_adjlist, indegree, outdegree, degree, has_self_loops,
-    num_self_loops, insorted, squash
-
-using Random: GLOBAL_RNG, AbstractRNG
+    num_self_loops, insorted, squash, rng_from_rng_or_seed
 
 export AbstractSimpleGraph, AbstractSimpleEdge,
     SimpleEdge, SimpleGraph, SimpleGraphFromIterator, SimpleGraphEdge,

src/SimpleGraphs/generators/euclideangraphs.jl

@@ -1,5 +1,5 @@
 """
-    euclidean_graph(N, d; seed=-1, L=1., p=2., cutoff=-1., bc=:open)
+    euclidean_graph(N, d; rng=nothing, seed=nothing, L=1., p=2., cutoff=-1., bc=:open)
 
 Generate `N` uniformly distributed points in the box ``[0,L]^{d}``
 and return a Euclidean graph, a map containing the distance on each edge and
@@ -20,9 +20,11 @@ Dict{Graphs.SimpleGraphs.SimpleEdge{Int64},Float64} with 4 entries:
   Edge 4 => 5 => 0.168372
 ```
 """
-function euclidean_graph(N::Int, d::Int;
-    L=1., seed = -1, kws...)
-    rng = Graphs.getRNG(seed)
+function euclidean_graph(
+    N::Int, d::Int;
+    L=1., rng::Union{Nothing, AbstractRNG}=nothing, seed::Union{Nothing, Integer}=nothing, kws...
+)
+    rng = rng_from_rng_or_seed(rng, seed)
     points = rmul!(rand(rng, d, N), L)
     return (euclidean_graph(points; L=L, kws...)..., points)
 end
@@ -55,8 +57,10 @@ julia> g
 {10, 45} undirected simple Int64 graph
 ```
 """
-function euclidean_graph(points::Matrix;
-    L=1., p=2., cutoff=-1., bc=:open)
+function euclidean_graph(
+    points::Matrix;
+    L=1., p=2., cutoff=-1., bc=:open
+)
     d, N = size(points)
     weights = Dict{SimpleEdge{Int},Float64}()
     cutoff < 0. && (cutoff = typemax(Float64))