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

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.

Here are some speedups:

![randperm-ndl-speedup](https://github.com/JuliaLang/julia/assets/8462914/b999ba43-e588-49f4-91a2-a4b23e79716d)

The slow down for big arrays seems fine to me, but I will see if I can
find an easy workaround.

Fix #57771.

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!
 
 function shuffle(rng::AbstractRNG, tup::NTuple{N}) where {N}
@@ -219,31 +214,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
@@ -278,18 +264,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
 ```
 """
 function shuffle end
@@ -318,12 +300,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))
@@ -342,29 +326,28 @@ 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::AbstractArray{<:Integer})
+function randperm!(rng::AbstractRNG, a::AbstractArray{<:Integer})
     # keep it consistent with `shuffle!` and `randcycle!` if possible
     Base.require_one_based_indexing(a)
     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
@@ -393,14 +376,14 @@ 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
- 2
  6
  3
- 1
+ 2
 ```
 """
 randcycle(r::AbstractRNG, n::T) where {T <: Integer} = randcycle!(r, Vector{T}(undef, n))
@@ -424,30 +407,27 @@ 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
- 2
  6
  3
- 1
+ 2
 ```
 """
-function randcycle!(r::AbstractRNG, a::AbstractArray{<:Integer})
+function randcycle!(rng::AbstractRNG, a::AbstractArray{<:Integer})
     # keep it consistent with `shuffle!` and `randperm!` if possible
     Base.require_one_based_indexing(a)
     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