Xoshiro: allow any non-negative integer as a seed, via SHA2_256

Author: rfourquet

stdlib/LinearAlgebra/test/dense.jl

@@ -22,10 +22,10 @@ Random.seed!(1234323)
     @testset "for $elty" for elty in (Float32, Float64, ComplexF32, ComplexF64)
         ainit = convert(Matrix{elty}, ainit)
         for a in (copy(ainit), view(ainit, 1:n, 1:n))
-            @test cond(a,1) ≈ 122.15725126320953 atol=0.5
-            @test cond(a,2) ≈ 78.44837047684149 atol=0.5
-            @test cond(a,Inf) ≈ 174.10761543202744 atol=0.4
-            @test cond(a[:,1:5]) ≈ 6.7492840150789135 atol=0.01
+            @test cond(a,1) ≈ 198.3324294531168 atol=0.5
+            @test cond(a,2) ≈ 85.93920079319506 atol=0.5
+            @test cond(a,Inf) ≈ 149.7523084803039 atol=0.4
+            @test cond(a[:,1:5]) ≈ 8.319279144493297 atol=0.01
             @test_throws ArgumentError cond(a,3)
         end
     end

stdlib/LinearAlgebra/test/eigen.jl

@@ -163,7 +163,7 @@ end
 end
 
 @testset "eigen of an Adjoint" begin
-    Random.seed!(1)
+    Random.seed!(4)
     A = randn(3,3)
     @test eigvals(A') == eigvals(copy(A'))
     @test eigen(A')   == eigen(copy(A'))

stdlib/Random/Project.toml

@@ -3,6 +3,7 @@ uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 
 [deps]
 Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
+SHA = "ea8e919c-243c-51af-8825-aaa63cd721ce"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

stdlib/Random/src/RNGs.jl

@@ -384,7 +384,7 @@ end
 
 seed!(rng::_GLOBAL_RNG, ::Nothing) = seed!(rng)  # to resolve ambiguity
 
-seed!(seed::Union{Nothing,Integer,Vector{UInt32},Vector{UInt64},NTuple{4,UInt64}}=nothing) =
+seed!(seed::Union{Nothing,Integer,Vector{UInt32},Vector{UInt64}}=nothing) =
     seed!(GLOBAL_RNG, seed)
 
 rng_native_52(::_GLOBAL_RNG) = rng_native_52(default_rng())

stdlib/Random/src/Random.jl

@@ -13,6 +13,7 @@ include("DSFMT.jl")
 using .DSFMT
 using Base.GMP.MPZ
 using Base.GMP: Limb
+import SHA
 
 using Base: BitInteger, BitInteger_types, BitUnsigned, require_one_based_indexing
 

stdlib/Random/src/Xoshiro.jl

@@ -117,65 +117,21 @@ end
 
 # Shared implementation between Xoshiro and TaskLocalRNG -- seeding
 
-function seed!(x::Union{TaskLocalRNG,Xoshiro})
+function seed!(rng::Union{TaskLocalRNG,Xoshiro})
     # as we get good randomness from RandomDevice, we can skip hashing
-    parent = RandomDevice()
-    # Constants have nothing up their sleeve, see task.c
-    # 0x02011ce34bce797f == hash(UInt(1))|0x01
-    # 0x5a94851fb48a6e05 == hash(UInt(2))|0x01
-    # 0x3688cf5d48899fa7 == hash(UInt(3))|0x01
-    # 0x867b4bb4c42e5661 == hash(UInt(4))|0x01
-    setstate!(x,
-              0x02011ce34bce797f * rand(parent, UInt64),
-              0x5a94851fb48a6e05 * rand(parent, UInt64),
-              0x3688cf5d48899fa7 * rand(parent, UInt64),
-              0x867b4bb4c42e5661 * rand(parent, UInt64))
+    rd = RandomDevice()
+    setstate!(rng, rand(rd, UInt64), rand(rd, UInt64), rand(rd, UInt64), rand(rd, UInt64))
 end
 
-function seed!(rng::Union{TaskLocalRNG,Xoshiro}, seed::NTuple{4,UInt64})
-    # TODO: Consider a less ad-hoc construction
-    # We can afford burning a handful of cycles here, and we don't want any
-    # surprises with respect to bad seeds / bad interactions.
-
-    s0 = s  = Base.hash_64_64(seed[1])
-    s1 = s += Base.hash_64_64(seed[2])
-    s2 = s += Base.hash_64_64(seed[3])
-    s3 = s += Base.hash_64_64(seed[4])
-
+function seed!(rng::Union{TaskLocalRNG,Xoshiro}, seed::Union{Vector{UInt32}, Vector{UInt64}})
+    c = SHA.SHA2_256_CTX()
+    SHA.update!(c, reinterpret(UInt8, seed))
+    s0, s1, s2, s3 = reinterpret(UInt64, SHA.digest!(c))
     setstate!(rng, s0, s1, s2, s3)
-
-    rand(rng, UInt64)
-    rand(rng, UInt64)
-    rand(rng, UInt64)
-    rand(rng, UInt64)
-    rng
 end
 
-function seed!(rng::Union{TaskLocalRNG, Xoshiro}, seed::UInt128)
-    seed0 = seed % UInt64
-    seed1 = (seed>>>64) % UInt64
-    seed!(rng, (seed0, seed1, zero(UInt64), zero(UInt64)))
-end
-seed!(rng::Union{TaskLocalRNG, Xoshiro}, seed::Integer) = seed!(rng, UInt128(seed))
-
-function seed!(rng::Union{TaskLocalRNG, Xoshiro}, seed::AbstractVector{UInt64})
-    if length(seed) > 4
-        throw(ArgumentError("seed should have no more than 256 bits"))
-    end
-    seed0 = length(seed)>0 ? seed[1] : UInt64(0)
-    seed1 = length(seed)>1 ? seed[2] : UInt64(0)
-    seed2 = length(seed)>2 ? seed[3] : UInt64(0)
-    seed3 = length(seed)>3 ? seed[4] : UInt64(0)
-    seed!(rng, (seed0, seed1, seed2, seed3))
-end
+seed!(rng::Union{TaskLocalRNG, Xoshiro}, seed::Integer) = seed!(rng, make_seed(seed))
 
-function seed!(rng::Union{TaskLocalRNG, Xoshiro}, seed::AbstractVector{UInt32})
-    if iseven(length(seed))
-        seed!(rng, reinterpret(UInt64, seed))
-    else
-        seed!(rng, UInt64[reinterpret(UInt64, @view(seed[begin:end-1])); seed[end] % UInt64])
-    end
-end
 
 @inline function rand(rng::Union{TaskLocalRNG, Xoshiro}, ::SamplerType{UInt128})
     first = rand(rng, UInt64)

stdlib/Random/test/runtests.jl

@@ -688,7 +688,7 @@ end
 @testset "$RNG(seed) & Random.seed!(m::$RNG, seed) produce the same stream" for RNG=(MersenneTwister,Xoshiro)
     seeds = Any[0, 1, 2, 10000, 10001, rand(UInt32, 8), rand(UInt128, 3)...]
     if RNG == Xoshiro
-        push!(seeds, rand(UInt64, rand(1:4)), Tuple(rand(UInt64, 4)))
+        push!(seeds, rand(UInt64, rand(1:4)))
     end
     for seed=seeds
         m = RNG(seed)
@@ -699,7 +699,7 @@ end
 end
 
 @testset "Random.seed!(seed) sets Random.GLOBAL_SEED" begin
-    seeds = Any[0, rand(UInt128), rand(UInt64, 4), Tuple(rand(UInt64, 4))]
+    seeds = Any[0, rand(UInt128), rand(UInt64, 4)]
 
     for seed=seeds
         Random.seed!(seed)

stdlib/SparseArrays/test/sparse.jl

@@ -1750,7 +1750,7 @@ end
     A = guardseed(1234321) do
         triu(sprand(10, 10, 0.2))
     end
-    @test getcolptr(SparseArrays.droptol!(A, 0.01)) == [1, 1, 3, 4, 5, 6, 7, 11, 13, 15, 18]
+    @test getcolptr(SparseArrays.droptol!(A, 0.01)) == [1, 1, 1, 1, 2, 2, 2, 4, 4, 5, 5]
     @test isequal(SparseArrays.droptol!(sparse([1], [1], [1]), 1), SparseMatrixCSC(1, 1, Int[1, 1], Int[], Int[]))
 end