seed random positions

Author: hexaeder

Project.toml

@@ -5,6 +5,7 @@ version = "0.4.0"
 [deps]
 GeometryBasics = "5c1252a2-5f33-56bf-86c9-59e7332b4326"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 

docs/src/index.md

@@ -14,7 +14,6 @@ set_theme!(resolution=(800, 400)) #hide
 CairoMakie.inline!(true) # hide
 using NetworkLayout
 using GraphMakie, LightGraphs
-import Random; Random.seed!(2) # hide
 nothing #hide
 ```
 
@@ -104,15 +103,14 @@ Stress
 ```@example layouts
 g = complete_graph(10)
 layout = Stress()
-Random.seed!(1)
 f, ax, p = graphplot(g, layout=layout)
 hidedecorations!(ax); hidespines!(ax); ax.aspect = DataAspect(); f #hide
 ```
 
 ### Iterator Example
 ```@example layouts
 iterator = LayoutIterator(layout, adjacency_matrix(g))
-record(f, "stress_animation.mp4", iterator; framerate = 100) do pos
+record(f, "stress_animation.mp4", iterator; framerate = 10) do pos
     p[:node_positions][] = pos
     autolimits!(ax)
 end

src/NetworkLayout.jl

@@ -3,6 +3,7 @@ module NetworkLayout
 using GeometryBasics
 using Requires
 using LinearAlgebra: norm
+using Random
 
 export LayoutIterator, layout
 

src/sfdp.jl

@@ -22,39 +22,44 @@ the nodes.
 
   Provide list of initial positions. If length does not match Network size the initial
   positions will be truncated or filled up with random values between [-1,1] in every coordinate.
+
+- `seed=1`: Seed for random initial positions.
 """
 struct SFDP{Dim,Ptype,T<:AbstractFloat} <: IterativeLayout{Dim,Ptype}
     tol::T
     C::T
     K::T
     iterations::Int
     initialpos::Vector{Point{Dim,Ptype}}
+    seed::UInt
 end
 
 # TODO: check SFDP default parameters
-function SFDP(; dim=2, Ptype=Float64, tol=1.0, C=0.2, K=1.0, iterations=100, initialpos=Point{dim,Ptype}[])
+function SFDP(; dim=2, Ptype=Float64, tol=1.0, C=0.2, K=1.0, iterations=100, initialpos=Point{dim,Ptype}[],
+              seed=1)
     if !isempty(initialpos)
         initialpos = Point.(initialpos)
         Ptype = eltype(eltype(initialpos))
         # TODO fix initial pos if list has points of multiple types
         Ptype == Any && error("Please provide list of Point{N,T} with same T")
         dim = length(eltype(initialpos))
     end
-    return SFDP{dim,Ptype,typeof(tol)}(tol, C, K, iterations, initialpos)
+    return SFDP{dim,Ptype,typeof(tol)}(tol, C, K, iterations, initialpos, seed)
 end
 
 function Base.iterate(iter::LayoutIterator{SFDP{Dim,Ptype,T}}) where {Dim,Ptype,T}
     algo, adj_matrix = iter.algorithm, iter.adj_matrix
     N = size(adj_matrix, 1)
     M = length(algo.initialpos)
+    rng = MersenneTwister(algo.seed)
     startpos = Vector{Point{Dim,Ptype}}(undef, N)
     # take the first
     for i in 1:min(N, M)
         startpos[i] = algo.initialpos[i]
     end
     # fill the rest with random points
     for i in (M + 1):N
-        startpos[i] = 2 .* rand(Point{Dim,Ptype}) .- 1
+        startpos[i] = 2 .* rand(rng, Point{Dim,Ptype}) .- 1
     end
     # iteratorstate: (#iter, energy, step, progress, old pos, stopflag)
     return startpos, (1, typemax(T), one(T), 0, startpos, false)
@@ -98,7 +103,7 @@ function Base.iterate(iter::LayoutIterator{<:SFDP}, state)
         stopflag = true
     end
 
-    return locs, (iter+1, energy, step, progress, locs, stopflag)
+    return locs, (iter + 1, energy, step, progress, locs, stopflag)
 end
 
 # Calculate Attractive force

src/spring.jl

@@ -25,37 +25,42 @@ the nodes.
 
   Provide list of initial positions. If length does not match Network size the initial
   positions will be truncated or filled up with random values between [-1,1] in every coordinate.
+
+- `seed=1`: Seed for random initial positions.
 """
 struct Spring{Dim,Ptype} <: IterativeLayout{Dim,Ptype}
     C::Float64
     iterations::Int
     initialtemp::Float64
     initialpos::Vector{Point{Dim,Ptype}}
+    seed::UInt
 end
 
-function Spring(; dim=2, Ptype=Float64, C=2.0, iterations=100, initialtemp=2.0, initialpos=Point{dim,Ptype}[])
+function Spring(; dim=2, Ptype=Float64, C=2.0, iterations=100, initialtemp=2.0, initialpos=Point{dim,Ptype}[],
+                seed=1)
     if !isempty(initialpos)
         initialpos = Point.(initialpos)
         Ptype = eltype(eltype(initialpos))
         # TODO fix initial pos if list has points of multiple types
         Ptype == Any && error("Please provide list of Point{N,T} with same T")
         dim = length(eltype(initialpos))
     end
-    return Spring{dim,Ptype}(C, iterations, initialtemp, initialpos)
+    return Spring{dim,Ptype}(C, iterations, initialtemp, initialpos, seed)
 end
 
-function Base.iterate(iter::LayoutIterator{<:Spring{Dim, Ptype}}) where {Dim, Ptype}
+function Base.iterate(iter::LayoutIterator{<:Spring{Dim,Ptype}}) where {Dim,Ptype}
     algo, adj_matrix = iter.algorithm, iter.adj_matrix
     N = size(adj_matrix, 1)
     M = length(algo.initialpos)
+    rng = MersenneTwister(algo.seed)
     startpos = Vector{Point{Dim,Ptype}}(undef, N)
     # take the first
     for i in 1:min(N, M)
         startpos[i] = algo.initialpos[i]
     end
     # fill the rest with random points
     for i in (M + 1):N
-        startpos[i] = 2 .* rand(Point{Dim,Ptype}) .- 1
+        startpos[i] = 2 .* rand(rng, Point{Dim,Ptype}) .- 1
     end
     # iteratorstate: #iter nr, old pos
     return (startpos, (1, startpos))

src/stress.jl

@@ -42,6 +42,8 @@ representation of a network and returns coordinates of the nodes.
   Provide list of initial positions. If length does not match Network size the initial
   positions will be truncated or filled up with random normal distributed values in every coordinate.
 
+- `seed=1`: Seed for random initial positions.
+
 ## Reference:
 The main equation to solve is (8) of:
 
@@ -67,11 +69,12 @@ struct Stress{Dim,Ptype,IT<:Union{Symbol,Int},FT<:AbstractFloat,M<:AbstractMatri
     abstolx::FT
     weights::M
     initialpos::Vector{Point{Dim,Ptype}}
+    seed::UInt
 end
 
 function Stress(; dim=2, Ptype=Float64, iterations=:auto, abstols=(√(eps(Float64))),
                 reltols=(√(eps(Float64))), abstolx=(√(eps(Float64))), weights=Array{Float64}(undef, 0, 0),
-                initialpos=Point{dim,Ptype}[])
+                initialpos=Point{dim,Ptype}[], seed=1)
     if !isempty(initialpos)
         initialpos = Point.(initialpos)
         Ptype = eltype(eltype(initialpos))
@@ -80,7 +83,7 @@ function Stress(; dim=2, Ptype=Float64, iterations=:auto, abstols=(√(eps(Float
         dim = length(eltype(initialpos))
     end
     IT, FT, WT = typeof(iterations), typeof(abstols), typeof(weights)
-    Stress{dim,Ptype,IT,FT,WT}(iterations, abstols, reltols, abstolx, weights, initialpos)
+    Stress{dim,Ptype,IT,FT,WT}(iterations, abstols, reltols, abstolx, weights, initialpos, seed)
 end
 
 function initialweights(D, T)::SparseMatrixCSC{T,Int64}
@@ -94,14 +97,15 @@ function Base.iterate(iter::LayoutIterator{<:Stress{Dim,Ptype,IT,FT}}) where {Di
     algo, δ = iter.algorithm, iter.adj_matrix
     N = size(δ, 1)
     M = length(algo.initialpos)
+    rng = MersenneTwister(algo.seed)
     startpos = Vector{Point{Dim,Ptype}}(undef, N)
     # take the first
     for i in 1:min(N, M)
         startpos[i] = algo.initialpos[i]
     end
     # fill the rest with random points
     for i in (M + 1):N
-        startpos[i] = randn(Point{Dim,Ptype})
+        startpos[i] = randn(rng, Point{Dim,Ptype})
     end
 
     # calculate iteration if :auto