speed-up randperm by using our current rand(1:n)

And similarly for `randcycle` and `shuffle`.

We had a custom version of range generation for `randperm`, which was based
on the ideas of our previous default range sampler `SamplerRangeFast`
(generate `k`-bits integers using masking and reject out-of-range ones) and
took advantage of the fact that `randperm` needs to generate `rand(1:i)` for
`i = 2:n`.

But our current range sampler ("Nearly Division Less") is usually better than
this hack, and makes these functions more readable.
Typically, for array lengths `< 2^20`, the new version is faster, but gets
slightly slower beyond 2^22.

Author: rfourquet

stdlib/Random/src/misc.jl

@@ -176,11 +176,6 @@ julia> randsubseq(Xoshiro(123), 1:8, 0.3)
 randsubseq(A::AbstractArray, p::Real) = randsubseq(default_rng(), A, p)
 
 
-## rand Less Than Masked 52 bits (helper function)
-
-"Return a sampler generating a random `Int` (masked with `mask`) in ``[0, n)``, when `n <= 2^52`."
-ltm52(n::Int, mask::Int=nextpow(2, n)-1) = LessThan(n-1, Masked(mask, UInt52Raw(Int)))
-
 ## shuffle & shuffle!
 
 """
@@ -191,31 +186,22 @@ optionally supplying the random-number generator `rng`.
 
 # Examples
 ```jldoctest
-julia> shuffle!(Xoshiro(123), Vector(1:10))
-10-element Vector{Int64}:
-  5
-  4
-  2
-  3
-  6
- 10
-  8
-  1
-  9
-  7
+julia> shuffle!(Xoshiro(0), Vector(1:6))
+6-element Vector{Int64}:
+ 5
+ 1
+ 2
+ 6
+ 3
+ 4
 ```
 """
-function shuffle!(r::AbstractRNG, a::AbstractArray)
+function shuffle!(rng::AbstractRNG, a::AbstractArray)
     # keep it consistent with `randperm!` and `randcycle!` if possible
     require_one_based_indexing(a)
-    n = length(a)
-    @assert n <= Int64(2)^52
-    n == 0 && return a
-    mask = 3
-    @inbounds for i = 2:n
-        j = 1 + rand(r, ltm52(i, mask))
+    @inbounds for i = 2:length(a)
+        j = rand(rng, 1:i)
         a[i], a[j] = a[j], a[i]
-        i == 1 + mask && (mask = 2 * mask + 1)
     end
     return a
 end
@@ -247,18 +233,14 @@ indices, see [`randperm`](@ref).
 
 # Examples
 ```jldoctest
-julia> shuffle(Xoshiro(123), Vector(1:10))
-10-element Vector{Int64}:
-  5
-  4
-  2
-  3
-  6
- 10
-  8
-  1
-  9
-  7
+julia> shuffle(Xoshiro(0), 1:6)
+6-element Vector{Int64}:
+ 5
+ 1
+ 2
+ 6
+ 3
+ 4
 ```
 """
 shuffle(r::AbstractRNG, a::AbstractArray) = shuffle!(r, copymutable(a))
@@ -285,12 +267,14 @@ To randomly permute an arbitrary vector, see [`shuffle`](@ref) or
 
 # Examples
 ```jldoctest
-julia> randperm(Xoshiro(123), 4)
-4-element Vector{Int64}:
+julia> randperm(Xoshiro(0), 6)
+6-element Vector{Int64}:
+ 5
  1
- 4
  2
+ 6
  3
+ 4
 ```
 """
 randperm(r::AbstractRNG, n::T) where {T <: Integer} = randperm!(r, Vector{T}(undef, n))
@@ -306,28 +290,27 @@ optional `rng` argument specifies a random number generator (see
 
 # Examples
 ```jldoctest
-julia> randperm!(Xoshiro(123), Vector{Int}(undef, 4))
-4-element Vector{Int64}:
+julia> randperm!(Xoshiro(0), Vector{Int}(undef, 6))
+6-element Vector{Int64}:
+ 5
  1
- 4
  2
+ 6
  3
+ 4
 ```
 """
-function randperm!(r::AbstractRNG, a::Array{<:Integer})
+function randperm!(rng::AbstractRNG, a::Array{<:Integer})
     # keep it consistent with `shuffle!` and `randcycle!` if possible
     n = length(a)
-    @assert n <= Int64(2)^52
     n == 0 && return a
     a[1] = 1
-    mask = 3
     @inbounds for i = 2:n
-        j = 1 + rand(r, ltm52(i, mask))
+        j = rand(rng, 1:i)
         if i != j # a[i] is undef (and could be #undef)
             a[i] = a[j]
         end
         a[j] = i
-        i == 1 + mask && (mask = 2 * mask + 1)
     end
     return a
 end
@@ -356,10 +339,13 @@ which are sampled uniformly.  If `n == 0`, `randcycle` returns an empty vector.
 
 # Examples
 ```jldoctest
-julia> randcycle(Xoshiro(123), 6)
+julia> randcycle(Xoshiro(0), 6)
 6-element Vector{Int64}:
  5
+ 1
  4
+ 6
+ 3
  2
  6
  3
@@ -384,29 +370,29 @@ which are sampled uniformly.  If `A` is empty, `randcycle!` leaves it unchanged.
 
 # Examples
 ```jldoctest
-julia> randcycle!(Xoshiro(123), Vector{Int}(undef, 6))
+julia> randcycle!(Xoshiro(0), Vector{Int}(undef, 6))
 6-element Vector{Int64}:
  5
+ 1
  4
+ 6
+ 3
  2
  6
  3
  1
 ```
 """
-function randcycle!(r::AbstractRNG, a::Array{<:Integer})
+function randcycle!(rng::AbstractRNG, a::Array{<:Integer})
     # keep it consistent with `shuffle!` and `randperm!` if possible
     n = length(a)
-    @assert n <= Int64(2)^52
     n == 0 && return a
     a[1] = 1
-    mask = 3
     # Sattolo's algorithm:
     @inbounds for i = 2:n
-        j = 1 + rand(r, ltm52(i-1, mask))
+        j = rand(rng, 1:i-1)
         a[i] = a[j]
         a[j] = i
-        i == 1 + mask && (mask = 2 * mask + 1)
     end
     return a
 end