rand sampling from an array accepts an optional rng

Fixes #5978.

base/random.jl

@@ -149,6 +149,12 @@ rand(T::Type, dims::Dims) = rand(GLOBAL_RNG, T, dims)
 rand(T::Type, d1::Int, dims::Int...) = rand(T, tuple(d1, dims...))
 rand!(A::AbstractArray) = rand!(GLOBAL_RNG, A)
 
+rand(r::AbstractArray) = rand(GLOBAL_RNG, r)
+rand!(r::Range, A::AbstractArray) = rand!(GLOBAL_RNG, r, A)
+
+rand(r::AbstractArray, dims::Dims) = rand(GLOBAL_RNG, r, dims)
+rand(r::AbstractArray, dims::Int...) = rand(GLOBAL_RNG, r, dims)
+
 ## random floating point values
 
 @inline rand(r::AbstractRNG) = rand(r, CloseOpen)
@@ -344,58 +350,58 @@ end
 
 # this function uses 32 bit entropy for small ranges of length <= typemax(UInt32) + 1
 # RandIntGen is responsible for providing the right value of k
-function rand{T<:Union(UInt64, Int64)}(g::RandIntGen{T,UInt64})
+function rand{T<:Union(UInt64, Int64)}(mt::MersenneTwister, g::RandIntGen{T,UInt64})
     local x::UInt64
     if (g.k - 1) >> 32 == 0
-        x = rand(UInt32)
+        x = rand(mt, UInt32)
         while x > g.u
-            x = rand(UInt32)
+            x = rand(mt, UInt32)
         end
     else
-        x = rand(UInt64)
+        x = rand(mt, UInt64)
         while x > g.u
-            x = rand(UInt64)
+            x = rand(mt, UInt64)
         end
     end
     return reinterpret(T, reinterpret(UInt64, g.a) + rem_knuth(x, g.k))
 end
 
-function rand{T<:Integer, U<:Unsigned}(g::RandIntGen{T,U})
-    x = rand(U)
+function rand{T<:Integer, U<:Unsigned}(mt::MersenneTwister, g::RandIntGen{T,U})
+    x = rand(mt, U)
     while x > g.u
-        x = rand(U)
+        x = rand(mt, U)
     end
     (unsigned(g.a) + rem_knuth(x, g.k)) % T
 end
 
-rand{T<:Union(Signed,Unsigned,Bool,Char)}(r::UnitRange{T}) = rand(RandIntGen(r))
+rand{T<:Union(Signed,Unsigned,Bool,Char)}(mt::MersenneTwister, r::UnitRange{T}) = rand(mt, RandIntGen(r))
 
 # Randomly draw a sample from an AbstractArray r
 # (e.g. r is a range 0:2:8 or a vector [2, 3, 5, 7])
-rand(r::AbstractArray) = @inbounds return r[rand(1:length(r))]
+rand(mt::MersenneTwister, r::AbstractArray) = @inbounds return r[rand(mt, 1:length(r))]
 
-function rand!(g::RandIntGen, A::AbstractArray)
+function rand!(mt::MersenneTwister, g::RandIntGen, A::AbstractArray)
     for i = 1 : length(A)
-        @inbounds A[i] = rand(g)
+        @inbounds A[i] = rand(mt, g)
     end
     return A
 end
 
-rand!{T<:Union(Signed,Unsigned,Bool,Char)}(r::UnitRange{T}, A::AbstractArray) = rand!(RandIntGen(r), A)
+rand!{T<:Union(Signed,Unsigned,Bool,Char)}(mt::MersenneTwister, r::UnitRange{T}, A::AbstractArray) = rand!(mt, RandIntGen(r), A)
 
-rand!(r::Range, A::AbstractArray) = _rand!(r, A)
+rand!(mt::MersenneTwister, r::Range, A::AbstractArray) = _rand!(mt, r, A)
 
 # TODO: this more general version is "disabled" until #8246 is resolved
-function _rand!(r::AbstractArray, A::AbstractArray)
+function _rand!(mt::MersenneTwister, r::AbstractArray, A::AbstractArray)
     g = RandIntGen(1:(length(r)))
     for i = 1 : length(A)
-        @inbounds A[i] = r[rand(g)]
+        @inbounds A[i] = r[rand(mt, g)]
     end
     return A
 end
 
-rand{T}(r::AbstractArray{T}, dims::Dims) = _rand!(r, Array(T, dims))
-rand(r::AbstractArray, dims::Int...) = rand(r, dims)
+rand{T}(mt::MersenneTwister, r::AbstractArray{T}, dims::Dims) = _rand!(mt, r, Array(T, dims))
+rand(mt::MersenneTwister, r::AbstractArray, dims::Int...) = rand(mt, r, dims)
 
 ## random BitArrays (AbstractRNG)
 

doc/stdlib/base.rst

@@ -4071,19 +4071,21 @@ A ``MersenneTwister`` RNG can generate random numbers of the following types: ``
 
    Create a ``MersenneTwister`` RNG object. Different RNG objects can have their own seeds, which may be useful for generating different streams of random numbers.
 
-.. function:: rand([rng], [t::Type], [dims...])
+.. function:: rand([rng], [S], [dims...])
 
-   Generate a random value or an array of random values of the given type, ``t``, which defaults to ``Float64``.
+   Pick a random element or array of random elements from the set of values specified by ``S``; ``S`` can be
 
-.. function:: rand!([rng], A)
+   * an indexable collection (for example ``1:n`` or ``['x','y','z']``), or
 
-   Populate the array A with random values.
+   * a type: the set of values to pick from is then equivalent to ``typemin(S):typemax(S)`` for integers, and to [0,1) for floating point numbers;
 
-.. function:: rand(coll, [dims...])
+   ``S`` defaults to ``Float64``.
 
-   Pick a random element or array of random elements from the indexable collection ``coll`` (for example, ``1:n`` or ``['x','y','z']``).
+.. function:: rand!([rng], A)
+
+   Populate the array A with random values.
 
-.. function:: rand!(r, A)
+.. function:: rand!([rng], r, A)
 
    Populate the array A with random values drawn uniformly from the range ``r``.
 

test/random.jl

@@ -32,10 +32,20 @@ rand!(MersenneTwister(0), A)
             8690327730555225005 8435109092665372532]
 
 # rand from AbstractArray
-@test rand(0:3:1000) in 0:3:1000
-coll = Any[2, UInt128(128), big(619), "string", 'c']
-@test rand(coll) in coll
-@test issubset(rand(coll, 2, 3), coll)
+let mt = MersenneTwister()
+    srand(mt)
+    @test rand(mt, 0:3:1000) in 0:3:1000
+    @test issubset(rand!(mt, 0:3:1000, Array(Int, 100)), 0:3:1000)
+    coll = Any[2, UInt128(128), big(619), "string", 'c']
+    @test rand(mt, coll) in coll
+    @test issubset(rand(mt, coll, 2, 3), coll)
+
+    # check API with default RNG:
+    rand(0:3:1000)
+    rand!(0:3:1000, Array(Int, 100))
+    rand(coll)
+    rand(coll, 2, 3)
+end
 
 # randn
 @test randn(MersenneTwister(42)) == -0.5560268761463861