Merge pull request JuliaLang#25278 from JuliaLang/rf/rand/fromtuples

add rand(::Tuple)

NEWS.md

@@ -62,6 +62,7 @@ Standard library changes
  * `Base.tail` now works on named tuples ([#29595]).
  * `randperm` and `randcycle` now use the type of their argument to determine the element type of
  the returned array ([#29670]).
+ * A new method `rand(::Tuple)` implements sampling from the values of a tuple ([#25278]).
 
 Compiler/Runtime improvements
 -----------------------------

stdlib/Random/src/Random.jl

@@ -217,6 +217,8 @@ rand(rng::AbstractRNG, ::UniformT{T}) where {T} = rand(rng, T)
 #### scalars
 
 rand(rng::AbstractRNG, X) = rand(rng, Sampler(rng, X, Val(1)))
+# this is needed to disambiguate
+rand(rng::AbstractRNG, X::Dims) = rand(rng, Sampler(rng, X, Val(1)))
 rand(rng::AbstractRNG=GLOBAL_RNG, ::Type{X}=Float64) where {X} = rand(rng, Sampler(rng, X, Val(1)))
 
 rand(X) = rand(GLOBAL_RNG, X)
@@ -249,9 +251,6 @@ rand( X, d::Integer, dims::Integer...) = rand(X, Dims((d, dims...
 # rand(r, ()) would match both this method and rand(r, dims::Dims)
 # moreover, a call like rand(r, NotImplementedType()) would be an infinite loop
 
-# this is needed to disambiguate
-rand(r::AbstractRNG, dims::Dims) = error("rand(rng, dims) is discontinued; try rand(rng, Float64, dims)")
-
 rand(r::AbstractRNG, ::Type{X}, dims::Dims) where {X} = rand!(r, Array{X}(undef, dims), X)
 rand( ::Type{X}, dims::Dims) where {X} = rand(GLOBAL_RNG, X, dims)
 
@@ -283,7 +282,7 @@ include("misc.jl")
 Pick a random element or array of random elements from the set of values specified by `S`;
 `S` can be
 
-* an indexable collection (for example `1:n` or `['x','y','z']`),
+* an indexable collection (for example `1:9` or `('x', "y", :z)`),
 * an `AbstractDict` or `AbstractSet` object,
 * a string (considered as a collection of characters), or
 * a type: the set of values to pick from is then equivalent to `typemin(S):typemax(S)` for

stdlib/Random/src/generation.jl

@@ -430,3 +430,54 @@ function rand(rng::AbstractRNG, sp::SamplerSimple{<:AbstractString,<:Sampler})::
  isvalid_unsafe(str, pos) && return str[pos]
  end
 end
+
+
+## random elements from tuples
+
+### 1
+
+Sampler(::Type{<:AbstractRNG}, t::Tuple{A}, ::Repetition) where {A} =
+ SamplerTrivial(t)
+
+rand(rng::AbstractRNG, sp::SamplerTrivial{Tuple{A}}) where {A} =
+ @inbounds return sp[][1]
+
+### 2
+
+Sampler(RNG::Type{<:AbstractRNG}, t::Tuple{A,B}, n::Repetition) where {A,B} =
+ SamplerSimple(t, Sampler(RNG, Bool, n))
+
+rand(rng::AbstractRNG, sp::SamplerSimple{Tuple{A,B}}) where {A,B} =
+ @inbounds return sp[][1 + rand(rng, sp.data)]
+
+### 3
+
+Sampler(RNG::Type{<:AbstractRNG}, t::Tuple{A,B,C}, n::Repetition) where {A,B,C} =
+ SamplerSimple(t, Sampler(RNG, UInt52(), n))
+
+function rand(rng::AbstractRNG, sp::SamplerSimple{Tuple{A,B,C}}) where {A,B,C}
+ local r
+ while true
+ r = rand(rng, sp.data)
+ r != 0x000fffffffffffff && break # _very_ likely
+ end
+ @inbounds return sp[][1 + r ÷ 0x0005555555555555]
+end
+
+### 4
+
+Sampler(RNG::Type{<:AbstractRNG}, t::Tuple{A,B,C,D}, n::Repetition) where {A,B,C,D} =
+ SamplerSimple(t, Sampler(RNG, UInt52Raw(Int), n))
+
+function rand(rng::AbstractRNG, sp::SamplerSimple{Tuple{A,B,C,D}}) where {A,B,C,D}
+ r = rand(rng, sp.data) & 3
+ @inbounds return sp[][1 + r]
+end
+
+### n
+
+Sampler(RNG::Type{<:AbstractRNG}, t::Tuple, n::Repetition) =
+ SamplerSimple(t, Sampler(RNG, Base.OneTo(length(t)), n))
+
+rand(rng::AbstractRNG, sp::SamplerSimple{<:Tuple}) =
+ @inbounds return sp[][rand(rng, sp.data)]

stdlib/Random/test/runtests.jl

@@ -702,3 +702,14 @@ end
  a = rand(Int, 1)
  @test shuffle(a) == a
 end
+
+@testset "rand(::Tuple)" begin
+ for x in (0x1, 1)
+ @test rand((x,)) == 0x1
+ @test rand((x, 2)) ∈ 1:2
+ @test rand((x, 2, 3)) ∈ 1:3
+ @test rand((x, 2, 3, 4)) ∈ 1:4
+ @test rand((x, 2, 3, 4, 5)) ∈ 1:5
+ @test rand((x, 2, 3, 4, 6)) ∈ 1:6
+ end
+end

stdlib/SparseArrays/src/linalg.jl

@@ -1,6 +1,7 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 import LinearAlgebra: checksquare
+using Random: rand!
 
 ## sparse matrix multiplication
 
@@ -929,12 +930,6 @@ function opnormestinv(A::SparseMatrixCSC{T}, t::Integer = min(2,maximum(size(A))
 
  S = zeros(T <: Real ? Int : Ti, n, t)
 
- function _rand_pm1!(v)
- for i in eachindex(v)
- v[i] = rand()<0.5 ? 1 : -1
- end
- end
-
  function _any_abs_eq(v,n::Int)
  for vv in v
  if abs(vv)==n
@@ -949,7 +944,7 @@ function opnormestinv(A::SparseMatrixCSC{T}, t::Integer = min(2,maximum(size(A))
  X[1:n,1] .= 1
  for j = 2:t
  while true
- _rand_pm1!(view(X,1:n,j))
+ rand!(view(X,1:n,j), (-1, 1))
  yaux = X[1:n,j]' * X[1:n,1:j-1]
  if !_any_abs_eq(yaux,n)
  break
@@ -1010,7 +1005,7 @@ function opnormestinv(A::SparseMatrixCSC{T}, t::Integer = min(2,maximum(size(A))
  end
  end
  if repeated
- _rand_pm1!(view(S,1:n,j))
+ rand!(view(S,1:n,j), (-1, 1))
  else
  break
  end