Random Numbers

    Most functions related to random generation accept an optional AbstractRNG object as first argument, which defaults to the global one if not provided. Moreover, some of them accept optionally dimension specifications dims... (which can be given as a tuple) to generate arrays of random values.

    A MersenneTwister or RandomDevice RNG can generate uniformly random numbers of the following types: Float16, , Float64, , Bool, , UInt8, , UInt16, , UInt32, , UInt64, , UInt128, (or complex numbers of those types). Random floating point numbers are generated uniformly in $[0, 1)$. As BigInt represents unbounded integers, the interval must be specified (e.g. rand(big.(1:6))).

    Additionally, normal and exponential distributions are implemented for some AbstractFloat and Complex types, see randn and for details.

    Random.Random — Module.

    Support for generating random numbers. Provides , randn, , MersenneTwister, and .

    source

    — Function.

    1. rand([rng=GLOBAL_RNG], [S], [dims...])

    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: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 integers (this is not applicable to BigInt), to $[0, 1)$ for floating point numbers and to $[0, 1)+i[0, 1)]$ for complex floating point numbers;

    S defaults to .

    Julia 1.1

    Support for S as a tuple requires at least Julia 1.1.

    Examples

    1. julia> rand(Int, 2)
    2. 2-element Array{Int64,1}:
    3.  1339893410598768192
    4.  1575814717733606317
    6. julia> using Random
    8. julia> rand(MersenneTwister(0), Dict(1=>2, 3=>4))
    9. 1=>2

    Note

    The complexity of rand(rng, s::Union{AbstractDict,AbstractSet}) is linear in the length of s, unless an optimized method with constant complexity is available, which is the case for Dict, Set and BitSet. For more than a few calls, use rand(rng, collect(s)) instead, or either rand(rng, Dict(s)) or rand(rng, Set(s)) as appropriate.

    source

    — Function.

    1. rand!([rng=GLOBAL_RNG], A, [S=eltype(A)])

    Populate the array A with random values. If S is specified (S can be a type or a collection, cf. rand for details), the values are picked randomly from S. This is equivalent to copyto!(A, rand(rng, S, size(A))) but without allocating a new array.

    Examples

    1. julia> rng = MersenneTwister(1234);
    3. julia> rand!(rng, zeros(5))
    4. 5-element Array{Float64,1}:
    5.  0.5908446386657102
    6.  0.7667970365022592
    7.  0.5662374165061859
    8.  0.4600853424625171
    9.  0.7940257103317943

    Random.bitrand — Function.

    1. bitrand([rng=GLOBAL_RNG], [dims...])

    Generate a BitArray of random boolean values.

    Examples

    1. julia> rng = MersenneTwister(1234);
    3. julia> bitrand(rng, 10)
    4. 10-element BitArray{1}:
    5.  0
    6.  1
    7.  1
    8.  1
    9.  1
    10.  0
    11.  1
    12.  0
    13.  0
    14.  1

    Base.randn — Function.

    1. randn([rng=GLOBAL_RNG], [T=Float64], [dims...])

    Generate a normally-distributed random number of type T with mean 0 and standard deviation 1. Optionally generate an array of normally-distributed random numbers. The Base module currently provides an implementation for the types , Float32, and (the default), and their Complex counterparts. When the type argument is complex, the values are drawn from the circularly symmetric complex normal distribution of variance 1 (corresponding to real and imaginary part having independent normal distribution with mean zero and variance 1/2).

    Examples

    1. julia> using Random
    3. julia> rng = MersenneTwister(1234);
    5. julia> randn(rng, ComplexF64)
    6. 0.6133070881429037 - 0.6376291670853887im
    8. julia> randn(rng, ComplexF32, (2, 3))
    9. 2×3 Array{Complex{Float32},2}:
    10.  -0.349649-0.638457im  0.376756-0.192146im  -0.396334-0.0136413im
    11.   0.611224+1.56403im   0.355204-0.365563im  0.0905552+1.31012im

    Random.randn! — Function.

    1. randn!([rng=GLOBAL_RNG], A::AbstractArray) -> A

    Fill the array A with normally-distributed (mean 0, standard deviation 1) random numbers. Also see the function.

    Examples

    1. julia> rng = MersenneTwister(1234);
    3. julia> randn!(rng, zeros(5))
    4. 5-element Array{Float64,1}:
    5.   0.8673472019512456
    6.  -0.9017438158568171
    7.  -0.4944787535042339
    8.  -0.9029142938652416
    9.   0.8644013132535154

    source

    — Function.

    1. randexp([rng=GLOBAL_RNG], [T=Float64], [dims...])

    Generate a random number of type T according to the exponential distribution with scale 1. Optionally generate an array of such random numbers. The Base module currently provides an implementation for the types Float16, , and Float64 (the default).

    Examples

    1. julia> rng = MersenneTwister(1234);
    3. julia> randexp(rng, Float32)
    4. 2.4835055f0
    6. julia> randexp(rng, 3, 3)
    7. 3×3 Array{Float64,2}:
    8.  1.5167    1.30652   0.344435
    9.  0.604436  2.78029   0.418516
    10.  0.695867  0.693292  0.643644

    Random.randexp! — Function.

    1. randexp!([rng=GLOBAL_RNG], A::AbstractArray) -> A

    Fill the array A with random numbers following the exponential distribution (with scale 1).

    Examples

    1. julia> rng = MersenneTwister(1234);
    3. julia> randexp!(rng, zeros(5))
    4. 5-element Array{Float64,1}:
    5.  2.4835053723904896
    6.  1.516703605376473
    7.  0.6044364871025417
    8.  0.6958665886385867
    9.  1.3065196315496677

    Random.randstring — Function.

    1. randstring([rng=GLOBAL_RNG], [chars], [len=8])

    Create a random string of length len, consisting of characters from chars, which defaults to the set of upper- and lower-case letters and the digits 0-9. The optional rng argument specifies a random number generator, see .

    Examples

    1. julia> Random.seed!(0); randstring()
    2. "0IPrGg0J"
    4. julia> randstring(MersenneTwister(0), 'a':'z', 6)
    5. "aszvqk"
    7. julia> randstring("ACGT")
    8. "TATCGGTC"

    Note

    chars can be any collection of characters, of type Char or UInt8 (more efficient), provided rand can randomly pick characters from it.

    Random.randsubseq — Function.

      Return a vector consisting of a random subsequence of the given array A, where each element of A is included (in order) with independent probability p. (Complexity is linear in p*length(A), so this function is efficient even if p is small and A is large.) Technically, this process is known as “Bernoulli sampling” of A.

      Examples

      Random.randsubseq! — Function.

      1. randsubseq!([rng=GLOBAL_RNG,] S, A, p)

      Like , but the results are stored in S (which is resized as needed).

      1. julia> rng = MersenneTwister(1234);
      3. julia> S = Int64[];
      5. julia> randsubseq!(rng, S, collect(1:8), 0.3);
      7. julia> S
      8. 2-element Array{Int64,1}:
      9.  7
      10.  8

      source

      — Function.

      1. randperm([rng=GLOBAL_RNG,] n::Integer)

      Construct a random permutation of length . The optional rng argument specifies a random number generator (see Random Numbers). The element type of the result is the same as the type of n.

      To randomly permute an arbitrary vector, see or shuffle!.

      Julia 1.1

      In Julia 1.1 randperm returns a vector v with eltype(v) == typeof(n) while in Julia 1.0 eltype(v) == Int.

      Examples

      1. julia> randperm(MersenneTwister(1234), 4)
      2. 4-element Array{Int64,1}:
      3.  2
      4.  1
      5.  4
      6.  3

      Random.randperm! — Function.

      1. randperm!([rng=GLOBAL_RNG,] A::Array{<:Integer})

      Construct in A a random permutation of length length(A). The optional rng argument specifies a random number generator (see ). To randomly permute an arbitrary vector, see shuffle or .

      Examples

      1. julia> randperm!(MersenneTwister(1234), Vector{Int}(undef, 4))
      2. 4-element Array{Int64,1}:
      3.  2
      4.  1
      5.  4
      6.  3

      source

      — Function.

      1. randcycle([rng=GLOBAL_RNG,] n::Integer)

      Construct a random cyclic permutation of length n. The optional rng argument specifies a random number generator, see Random Numbers. The element type of the result is the same as the type of n.

      Julia 1.1

      In Julia 1.1 randcycle returns a vector v with eltype(v) == typeof(n) while in Julia 1.0 eltype(v) == Int.

      Examples

      1. julia> randcycle(MersenneTwister(1234), 6)
      2. 6-element Array{Int64,1}:
      3.  3
      4.  5
      5.  4
      6.  6
      7.  1
      8.  2

      Random.randcycle! — Function.

      1. randcycle!([rng=GLOBAL_RNG,] A::Array{<:Integer})

      Construct in A a random cyclic permutation of length length(A). The optional rng argument specifies a random number generator, see .

      Examples

      1. julia> randcycle!(MersenneTwister(1234), Vector{Int}(undef, 6))
      2. 6-element Array{Int64,1}:
      3.  3
      4.  5
      5.  4
      6.  6
      7.  1
      8.  2

      source

      — Function.

      1. shuffle([rng=GLOBAL_RNG,] v::AbstractArray)

      Return a randomly permuted copy of v. The optional rng argument specifies a random number generator (see Random Numbers). To permute v in-place, see . To obtain randomly permuted indices, see randperm.

      Examples

      1. julia> rng = MersenneTwister(1234);
      3. julia> shuffle(rng, Vector(1:10))
      4. 10-element Array{Int64,1}:
      5.   6
      6.   1
      7.  10
      8.   2
      9.   3
      10.   9
      11.   5
      12.   7
      13.   4
      14.   8

      Random.shuffle! — Function.

      1. shuffle!([rng=GLOBAL_RNG,] v::AbstractArray)

      In-place version of : randomly permute v in-place, optionally supplying the random-number generator rng.

      Examples

      1. julia> rng = MersenneTwister(1234);
      3. julia> shuffle!(rng, Vector(1:16))
      4. 16-element Array{Int64,1}:
      5.   2
      6.  15
      7.   5
      8.  14
      9.   1
      10.   9
      11.  10
      12.   6
      13.  11
      14.   3
      15.  16
      16.   7
      17.   4
      18.  12
      19.   8
      20.  13

      source

      — Function.

      1. seed!([rng=GLOBAL_RNG], seed) -> rng
      2. seed!([rng=GLOBAL_RNG]) -> rng

      Reseed the random number generator: rng will give a reproducible sequence of numbers if and only if a seed is provided. Some RNGs don’t accept a seed, like RandomDevice. After the call to seed!, rng is equivalent to a newly created object initialized with the same seed.

      If rng is not specified, it defaults to seeding the state of the shared thread-local generator.

      Examples

      1. julia> Random.seed!(1234);
      3. julia> x1 = rand(2)
      4. 2-element Array{Float64,1}:
      5.  0.590845
      6.  0.766797
      8. julia> Random.seed!(1234);
      10. julia> x2 = rand(2)
      11. 2-element Array{Float64,1}:
      12.  0.590845
      13.  0.766797
      15. julia> x1 == x2
      16. true
      18. julia> rng = MersenneTwister(1234); rand(rng, 2) == x1
      19. true
      21. julia> MersenneTwister(1) == Random.seed!(rng, 1)
      22. true
      24. julia> rand(Random.seed!(rng), Bool) # not reproducible
      26. julia> rand(Random.seed!(rng), Bool)
      27. false
      29. julia> rand(MersenneTwister(), Bool) # not reproducible either
      30. true

      source

      — Type.

      1. AbstractRNG

      Supertype for random number generators such as MersenneTwister and .

      source

      — Type.

      Create a MersenneTwister RNG object. Different RNG objects can have their own seeds, which may be useful for generating different streams of random numbers. The seed may be a non-negative integer or a vector of UInt32 integers. If no seed is provided, a randomly generated one is created (using entropy from the system). See the seed! function for reseeding an already existing MersenneTwister object.

      Examples

      1. julia> rng = MersenneTwister(1234);
      3. julia> x1 = rand(rng, 2)
      4. 2-element Array{Float64,1}:
      5.  0.5908446386657102
      6.  0.7667970365022592
      8. julia> rng = MersenneTwister(1234);
      10. julia> x2 = rand(rng, 2)
      11. 2-element Array{Float64,1}:
      12.  0.5908446386657102
      13.  0.7667970365022592
      15. julia> x1 == x2
      16. true

      Random.RandomDevice — Type.

      1. RandomDevice()

      Create a RandomDevice RNG object. Two such objects will always generate different streams of random numbers. The entropy is obtained from the operating system.

      There are two mostly orthogonal ways to extend Random functionalities:

      1. generating random values of custom types
      2. creating new generators

      The API for 1) is quite functional, but is relatively recent so it may still have to evolve in subsequent releases of the Random module. For example, it’s typically sufficient to implement one rand method in order to have all other usual methods work automatically.

      The API for 2) is still rudimentary, and may require more work than strictly necessary from the implementor, in order to support usual types of generated values.

      Generating random values for some distributions may involve various trade-offs. Pre-computed values, such as an alias table for discrete distributions, or for univariate distributions, can speed up sampling considerably. How much information should be pre-computed can depend on the number of values we plan to draw from a distribution. Also, some random number generators can have certain properties that various algorithms may want to exploit.

      The Random module defines a customizable framework for obtaining random values that can address these issues. Each invocation of rand generates a sampler which can be customized with the above trade-offs in mind, by adding methods to Sampler, which in turn can dispatch on the random number generator, the object that characterizes the distribution, and a suggestion for the number of repetitions. Currently, for the latter, Val{1} (for a single sample) and Val{Inf} (for an arbitrary number) are used, with Random.Repetition an alias for both.

      The object returned by Sampler is then used to generate the random values. When implementing the random generation interface for a value X that can be sampled from, the implementor should define the method

      1. rand(rng, sampler)

      Samplers can be arbitrary values that implement rand(rng, sampler), but for most applications the following predefined samplers may be sufficient:

      1. SamplerType{T}() can be used for implementing samplers that draw from type T (e.g. rand(Int)). This is the default returned by Sampler for types.

      2. SamplerTrivial(self) is a simple wrapper for self, which can be accessed with []. This is the recommended sampler when no pre-computed information is needed (e.g. rand(1:3)), and is the default returned by Sampler for values.

      3. SamplerSimple(self, data) also contains the additional data field, which can be used to store arbitrary pre-computed values, which should be computed in a custom method of Sampler.

      We provide examples for each of these. We assume here that the choice of algorithm is independent of the RNG, so we use AbstractRNG in our signatures.

      Random.Sampler — Type.

      1. Sampler(rng, x, repetition = Val(Inf))

      Return a sampler object that can be used to generate random values from rng for .

      When sp = Sampler(rng, x, repetition), rand(rng, sp) will be used to draw random values, and should be defined accordingly.

      repetition can be Val(1) or Val(Inf), and should be used as a suggestion for deciding the amount of precomputation, if applicable.

      and Random.SamplerTrivial are default fallbacks for types and values, respectively. can be used to store pre-computed values without defining extra types for only this purpose.

      source

      — Type.

      1. SamplerType{T}()

      A sampler for types, containing no other information. The default fallback for Sampler when called with types.

      source

      — Type.

      1. SamplerTrivial(x)

      Create a sampler that just wraps the given value x. This is the default fall-back for values. The eltype of this sampler is equal to eltype(x).

      The recommended use case is sampling from values without precomputed data.

      source

      — Type.

      1. SamplerSimple(x, data)

      Create a sampler that wraps the given value x and the data. The eltype of this sampler is equal to eltype(x).

      The recommended use case is sampling from values with precomputed data.

      source

      Decoupling pre-computation from actually generating the values is part of the API, and is also available to the user. As an example, assume that rand(rng, 1:20) has to be called repeatedly in a loop: the way to take advantage of this decoupling is as follows:

      1. rng = MersenneTwister()
      2. sp = Random.Sampler(rng, 1:20) # or Random.Sampler(MersenneTwister, 1:20)
      3. for x in X
      4.     n = rand(rng, sp) # similar to n = rand(rng, 1:20)
      5.     # use n
      6. end

      This is the mechanism that is also used in the standard library, e.g. by the default implementation of random array generation (like in rand(1:20, 10)).

      Generating values from a type

      Given a type T, it’s currently assumed that if rand(T) is defined, an object of type T will be produced. SamplerType is the default sampler for types. In order to define random generation of values of type T, the rand(rng::AbstractRNG, ::Random.SamplerType{T}) method should be defined, and should return values what rand(rng, T) is expected to return.

      Let’s take the following example: we implement a Die type, with a variable number n of sides, numbered from 1 to n. We want rand(Die) to produce a Die with a random number of up to 20 sides (and at least 4):

      1. struct Die
      2.     nsides::Int # number of sides
      3. end
      5. Random.rand(rng::AbstractRNG, ::Random.SamplerType{Die}) = Die(rand(rng, 4:20))
      7. # output

      Scalar and array methods for Die now work as expected:

      1. julia> rand(Die)
      2. Die(18)
      4. julia> rand(MersenneTwister(0), Die)
      5. Die(4)
      7. julia> rand(Die, 3)
      8. 3-element Array{Die,1}:
      9.  Die(6)
      10.  Die(11)
      11.  Die(5)
      13. julia> a = Vector{Die}(undef, 3); rand!(a)
      14. 3-element Array{Die,1}:
      15.  Die(18)
      16.  Die(6)
      17.  Die(8)

      A simple sampler without pre-computed data

      Here we define a sampler for a collection. If no pre-computed data is required, it can be implemented with a SamplerTrivial sampler, which is in fact the default fallback for values.

      In order to define random generation out of objects of type S, the following method should be defined: rand(rng::AbstractRNG, sp::Random.SamplerTrivial{S}). Here, sp simply wraps an object of type S, which can be accessed via sp[]. Continuing the Die example, we want now to define rand(d::Die) to produce an Int corresponding to one of d‘s sides:

      1. julia> Random.rand(rng::AbstractRNG, d::Random.SamplerTrivial{Die}) = rand(rng, 1:d[].nsides);
      3. julia> rand(Die(4))
      4. 3
      6. julia> rand(Die(4), 3)
      7. 3-element Array{Any,1}:
      8.  3
      9.  4
      10.  2

      Given a collection type S, it’s currently assumed that if rand(::S) is defined, an object of type eltype(S) will be produced. In the last example, a Vector{Any} is produced; the reason is that eltype(Die) == Any. The remedy is to define Base.eltype(::Type{Die}) = Int.

      Generating values for an AbstractFloat type

      AbstractFloat types are special-cased, because by default random values are not produced in the whole type domain, but rather in [0,1). The following method should be implemented for T <: AbstractFloat: Random.rand(::AbstractRNG, ::Random.SamplerTrivial{Random.CloseOpen01{T}})

      An optimized sampler with pre-computed data

      Consider a discrete distribution, where numbers 1:n are drawn with given probabilities that sum to one. When many values are needed from this distribution, the fastest method is using an . We don’t provide the algorithm for building such a table here, but suppose it is available in make_alias_table(probabilities) instead, and draw_number(rng, alias_table) can be used to draw a random number from it.

      Suppose that the distribution is described by

      1. struct DiscreteDistribution{V <: AbstractVector}
      2.     probabilities::V
      3. end

      and that we always want to build an a alias table, regardless of the number of values needed (we learn how to customize this below). The methods

      1. Random.eltype(::Type{<:DiscreteDistribution}) = Int
      3. function Random.Sampler(::AbstractRng, distribution::DiscreteDistribution, ::Repetition)
      4.     SamplerSimple(disribution, make_alias_table(distribution.probabilities))
      5. end

      should be defined to return a sampler with pre-computed data, then

      1. function rand(rng::AbstractRNG, sp::SamplerSimple{<:DiscreteDistribution})
      2.     draw_number(rng, sp.data)
      3. end

      will be used to draw the values.

      Custom sampler types

      The SamplerSimple type is sufficient for most use cases with precomputed data. However, in order to demonstrate how to use custom sampler types, here we implement something similar to SamplerSimple.

      Going back to our Die example: rand(::Die) uses random generation from a range, so there is an opportunity for this optimization. We call our custom sampler SamplerDie.

      1. import Random: Sampler, rand
      3. struct SamplerDie <: Sampler{Int} # generates values of type Int
      4.     die::Die
      5.     sp::Sampler{Int} # this is an abstract type, so this could be improved
      6. end
      8. Sampler(RNG::Type{<:AbstractRNG}, die::Die, r::Random.Repetition) =
      9.     SamplerDie(die, Sampler(RNG, 1:die.nsides, r))
      10. # the `r` parameter will be explained later on
      12. rand(rng::AbstractRNG, sp::SamplerDie) = rand(rng, sp.sp)

      It’s now possible to get a sampler with sp = Sampler(rng, die), and use sp instead of die in any rand call involving rng. In the simplistic example above, die doesn’t need to be stored in SamplerDie but this is often the case in practice.

      Of course, this pattern is so frequent that the helper type used above, namely Random.SamplerSimple, is available, saving us the definition of SamplerDie: we could have implemented our decoupling with:

      1. Sampler(RNG::Type{<:AbstractRNG}, die::Die, r::Random.Repetition) =
      2.     SamplerSimple(die, Sampler(RNG, 1:die.nsides, r))
      4. rand(rng::AbstractRNG, sp::SamplerSimple{Die}) = rand(rng, sp.data)

      Here, sp.data refers to the second parameter in the call to the SamplerSimple constructor (in this case equal to Sampler(rng, 1:die.nsides, r)), while the Die object can be accessed via sp[].

      Like SamplerDie, any custom sampler must be a subtype of Sampler{T} where T is the type of the generated values. Note that SamplerSimple(x, data) isa Sampler{eltype(x)}, so this constrains what the first argument to SamplerSimple can be (it’s recommended to use SamplerSimple like in the Die example, where x is simply forwarded while defining a Sampler method). Similarly, SamplerTrivial(x) isa Sampler{eltype(x)}.

      Another helper type is currently available for other cases, Random.SamplerTag, but is considered as internal API, and can break at any time without proper deprecations.

      Using distinct algorithms for scalar or array generation

      In some cases, whether one wants to generate only a handful of values or a large number of values will have an impact on the choice of algorithm. This is handled with the third parameter of the Sampler constructor. Let’s assume we defined two helper types for Die, say SamplerDie1 which should be used to generate only few random values, and SamplerDieMany for many values. We can use those types as follows:

      1. Sampler(RNG::Type{<:AbstractRNG}, die::Die, ::Val{1}) = SamplerDie1(...)
      2. Sampler(RNG::Type{<:AbstractRNG}, die::Die, ::Val{Inf}) = SamplerDieMany(...)

      Of course, rand must also be defined on those types (i.e. rand(::AbstractRNG, ::SamplerDie1) and rand(::AbstractRNG, ::SamplerDieMany)). Note that, as usual, SamplerTrivial and SamplerSimple can be used if custom types are not necessary.

      Note: Sampler(rng, x) is simply a shorthand for Sampler(rng, x, Val(Inf)), and Random.Repetition is an alias for Union{Val{1}, Val{Inf}}.

      Creating new generators

      The API is not clearly defined yet, but as a rule of thumb:

      1. any rand method producing “basic” types (isbitstype integer and floating types in Base) should be defined for this specific RNG, if they are needed;
      2. other documented rand methods accepting an AbstractRNG should work out of the box, (provided the methods from 1) what are relied on are implemented), but can of course be specialized for this RNG if there is room for optimization.

      Concerning 1), a rand method may happen to work automatically, but it’s not officially supported and may break without warnings in a subsequent release.

      To define a new rand method for an hypothetical MyRNG generator, and a value specification s (e.g. s == Int, or s == 1:10) of type S==typeof(s) or S==Type{s} if s is a type, the same two methods as we saw before must be defined:

      1. rand(rng::MyRNG, sp::SamplerS)

      It can happen that Sampler(rng::AbstractRNG, ::S, ::Repetition) is already defined in the Random module. It would then be possible to skip step 1) in practice (if one wants to specialize generation for this particular RNG type), but the corresponding SamplerS type is considered as internal detail, and may be changed without warning.

      Specializing array generation

      In some cases, for a given RNG type, generating an array of random values can be more efficient with a specialized method than by merely using the decoupling technique explained before. This is for example the case for MersenneTwister, which natively writes random values in an array.