무작위

무작위 수 생성을 위한 지원. rand, randn, AbstractRNG, MersenneTwister, 및 RandomDevice를 제공합니다.

rand([rng=default_rng()], [S], [dims...])

S로 지정된 값 집합에서 무작위 요소 또는 무작위 요소 배열을 선택합니다. S는 다음과 같을 수 있습니다.

• 인덱스 가능한 컬렉션(예: 1:9 또는 ('x', "y", :z))

• AbstractDict 또는 AbstractSet 객체

• 문자열(문자 집합으로 간주됨), 또는

• 지정된 값 집합에 해당하는 아래 목록의 유형

  • 구체적인 정수 유형은 typemin(S):typemax(S)에서 샘플링합니다(지원되지 않는 BigInt 제외).
  • 구체적인 부동 소수점 유형은 [0, 1)에서 샘플링합니다.
  • 구체적인 복소수 유형 Complex{T}는 T가 샘플링 가능한 유형인 경우, T에 해당하는 값 집합에서 실수 및 허수 성분을 독립적으로 가져오지만, T가 샘플링 불가능한 경우 지원되지 않습니다.
  • 모든 <:AbstractChar 유형은 유효한 유니코드 스칼라 집합에서 샘플링합니다.
  • 사용자 정의 유형 및 값 집합; 구현 지침은 Random API에 연결하기를 참조하십시오.
  • 알려진 크기의 튜플 유형이며 S의 각 매개변수가 샘플링 가능한 유형인 경우; S 유형의 값을 반환합니다. Tuple{Vararg{T}}(크기가 불명확한 튜플 유형) 및 Tuple{1:2}(값으로 매개변수화된 튜플 유형)는 지원되지 않습니다.
  • Pair 유형, 예: Pair{X, Y}로 rand가 X 및 Y에 대해 정의된 경우, 무작위 쌍이 생성됩니다.

S의 기본값은 Float64입니다. 선택적 rng 외에 하나의 인수만 전달되고 Tuple인 경우, 값 집합(S)의 컬렉션으로 해석되며 dims로 해석되지 않습니다.

정규 분포 숫자에 대해서는 randn를, 제자리에서의 동등한 함수에 대해서는 rand! 및 randn!를 참조하십시오.

예제

julia> rand(Int, 2)
2-element Array{Int64,1}:
 1339893410598768192
 1575814717733606317

julia> using Random

julia> rand(Xoshiro(0), Dict(1=>2, 3=>4))
3 => 4

julia> rand((2, 3))
3

julia> rand(Float64, (2, 3))
2×3 Array{Float64,2}:
 0.999717  0.0143835  0.540787
 0.696556  0.783855   0.938235

rand!([rng=default_rng()], A, [S=eltype(A)])

배열 A를 무작위 값으로 채웁니다. S가 지정된 경우(S는 타입 또는 컬렉션일 수 있으며, 자세한 내용은 rand를 참조하십시오), 값은 S에서 무작위로 선택됩니다. 이는 copyto!(A, rand(rng, S, size(A)))와 동일하지만 새로운 배열을 할당하지 않습니다.

예제

julia> rand!(Xoshiro(123), zeros(5))
5-element Vector{Float64}:
 0.521213795535383
 0.5868067574533484
 0.8908786980927811
 0.19090669902576285
 0.5256623915420473

bitrand([rng=default_rng()], [dims...])

무작위 부울 값의 BitArray를 생성합니다.

예제

julia> bitrand(Xoshiro(123), 10)
10-element BitVector:
 0
 1
 0
 1
 0
 1
 0
 0
 1
 1

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

평균 0과 표준 편차 1을 가진 T 유형의 정규 분포 난수를 생성합니다. 선택적 dims 인수를 사용하여 이러한 숫자의 크기가 dims인 배열을 생성합니다. Julia의 표준 라이브러리는 rand를 구현하는 모든 부동 소수점 유형에 대해 randn을 지원합니다. 예를 들어, Base 유형인 Float16, Float32, Float64 (기본값) 및 BigFloat와 그들의 Complex 대응형이 있습니다.

(T가 복소수일 때, 값은 분산 1의 원형 대칭 복소 정규 분포에서 추출되며, 이는 실수 및 허수 부분이 평균 0과 분산 1/2를 가진 독립적인 정규 분포를 갖는 것에 해당합니다).

제자리에서 작동하기 위해 randn!도 참조하십시오.

예제

단일 난수 생성 (기본 Float64 유형 사용):

julia> randn()
-0.942481877315864

정규 난수 행렬 생성 (기본 Float64 유형 사용):

julia> randn(2,3)
2×3 Matrix{Float64}:
  1.18786   -0.678616   1.49463
 -0.342792  -0.134299  -1.45005

사용자 정의 시드를 사용하여 난수 생성기 rng를 설정하고 이를 사용하여 난수 Float32 또는 ComplexF32 난수 행렬을 생성하는 예:

julia> using Random

julia> rng = Xoshiro(123);

julia> randn(rng, Float32)
-0.6457307f0

julia> randn(rng, ComplexF32, (2, 3))
2×3 Matrix{ComplexF32}:
  -1.03467-1.14806im  0.693657+0.056538im   0.291442+0.419454im
 -0.153912+0.34807im    1.0954-0.948661im  -0.543347-0.0538589im

randn!([rng=default_rng()], A::AbstractArray) -> A

배열 A를 정규 분포(평균 0, 표준 편차 1)를 따르는 난수로 채웁니다. rand 함수도 참조하세요.

예제

julia> randn!(Xoshiro(123), zeros(5))
5-element Vector{Float64}:
 -0.6457306721039767
 -1.4632513788889214
 -1.6236037455860806
 -0.21766510678354617
  0.4922456865251828

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

1의 스케일을 가진 지수 분포에 따라 타입 T의 난수를 생성합니다. 선택적으로 이러한 난수의 배열을 생성할 수 있습니다. Base 모듈은 현재 Float16, Float32, 및 Float64 (기본값) 타입에 대한 구현을 제공합니다.

예제

julia> rng = Xoshiro(123);

julia> randexp(rng, Float32)
1.1757717f0

julia> randexp(rng, 3, 3)
3×3 Matrix{Float64}:
 1.37766  0.456653  0.236418
 3.40007  0.229917  0.0684921
 0.48096  0.577481  0.71835

randexp!([rng=default_rng()], A::AbstractArray) -> A

배열 A를 스케일 1인 지수 분포를 따르는 랜덤 숫자로 채웁니다.

예시

julia> randexp!(Xoshiro(123), zeros(5))
5-element Vector{Float64}:
 1.1757716836348473
 1.758884569451514
 1.0083623637301151
 0.3510644315565272
 0.6348266443720407

randstring([rng=default_rng()], [chars], [len=8])

길이 len의 임의 문자열을 생성하며, chars의 문자로 구성됩니다. chars는 기본적으로 대문자 및 소문자와 숫자 0-9의 집합으로 설정됩니다. 선택적 rng 인자는 난수 생성기를 지정합니다. Random Numbers를 참조하세요.

예제

julia> Random.seed!(3); randstring()
"Lxz5hUwn"

julia> randstring(Xoshiro(3), 'a':'z', 6)
"iyzcsm"

julia> randstring("ACGT")
"TGCTCCTC"

!!! 주의 chars는 Char 또는 UInt8 타입의 문자 컬렉션일 수 있으며 (더 효율적), rand가 그로부터 임의로 문자를 선택할 수 있어야 합니다.

randsubseq([rng=default_rng(),] A, p) -> Vector

주어진 배열 A의 무작위 부분 수열로 구성된 벡터를 반환합니다. 여기서 A의 각 요소는 독립 확률 p로 포함됩니다(순서대로). (복잡도는 p*length(A)에 선형적이므로, 이 함수는 p가 작고 A가 클 때도 효율적입니다.) 기술적으로 이 과정은 A의 "베르누이 샘플링"으로 알려져 있습니다.

예제

julia> randsubseq(Xoshiro(123), 1:8, 0.3)
2-element Vector{Int64}:
 4
 7

randsubseq!([rng=default_rng(),] S, A, p)

randsubseq와 유사하지만, 결과는 S에 저장됩니다(필요에 따라 크기가 조정됨).

예제

julia> S = Int64[];

julia> randsubseq!(Xoshiro(123), S, 1:8, 0.3)
2-element Vector{Int64}:
 4
 7

julia> S
2-element Vector{Int64}:
 4
 7

randperm([rng=default_rng(),] n::Integer)

길이 n의 무작위 순열을 생성합니다. 선택적 rng 인자는 무작위 수 생성기를 지정합니다(자세한 내용은 무작위 수 참조). 결과의 요소 유형은 n의 유형과 동일합니다.

임의의 벡터를 무작위로 섞으려면 shuffle 또는 shuffle!를 참조하세요.

예제

julia> randperm(Xoshiro(123), 4)
4-element Vector{Int64}:
 1
 4
 2
 3

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

A에서 길이 length(A)의 무작위 순열을 생성합니다. 선택적 rng 인자는 난수 생성기를 지정합니다(자세한 내용은 Random Numbers 참조). 임의의 벡터를 무작위로 섞으려면 shuffle 또는 shuffle!를 참조하세요.

예제

julia> randperm!(Xoshiro(123), Vector{Int}(undef, 4))
4-element Vector{Int64}:
 1
 4
 2
 3

randcycle([rng=default_rng(),] n::Integer)

길이 n의 무작위 순환 순열을 생성합니다. 선택적 rng 인자는 난수 생성기를 지정하며, 무작위 수를 참조하십시오. 결과의 요소 유형은 n의 유형과 동일합니다.

여기서 "순환 순열"은 모든 요소가 단일 사이클 내에 존재함을 의미합니다. n > 0인 경우, 가능한 순환 순열의 수는 $(n-1)!$이며, 이는 균일하게 샘플링됩니다. n == 0인 경우, randcycle은 빈 벡터를 반환합니다.

randcycle!는 이 함수의 제자리 변형입니다.

예제

julia> randcycle(Xoshiro(123), 6)
6-element Vector{Int64}:
 5
 4
 2
 6
 3
 1

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

A에서 길이 n = length(A)의 무작위 순환 순열을 생성합니다. 선택적 rng 인자는 난수 생성기를 지정하며, Random Numbers를 참조하십시오.

여기서 "순환 순열"은 모든 요소가 단일 사이클 내에 존재함을 의미합니다. 만약 A가 비어 있지 않다면(n > 0), 가능한 순환 순열의 수는 $(n-1)!$이며, 이는 균일하게 샘플링됩니다. 만약 A가 비어 있다면, randcycle!는 이를 변경하지 않습니다.

randcycle는 새로운 벡터를 할당하는 이 함수의 변형입니다.

예시

julia> randcycle!(Xoshiro(123), Vector{Int}(undef, 6))
6-element Vector{Int64}:
 5
 4
 2
 6
 3
 1

shuffle([rng=default_rng(),] v::AbstractArray)

v의 무작위로 섞인 복사본을 반환합니다. 선택적 rng 인자는 난수 생성기를 지정합니다(자세한 내용은 난수 참조). v를 제자리에서 섞으려면 shuffle!를 참조하세요. 무작위로 섞인 인덱스를 얻으려면 randperm를 참조하세요.

예제

julia> shuffle(Xoshiro(123), Vector(1:10))
10-element Vector{Int64}:
  5
  4
  2
  3
  6
 10
  8
  1
  9
  7

shuffle!([rng=default_rng(),] v::AbstractArray)

제자리에서 버전 shuffle: 선택적으로 난수 생성기 rng를 제공하여 v를 제자리에서 무작위로 섞습니다.

예제

julia> shuffle!(Xoshiro(123), Vector(1:10))
10-element Vector{Int64}:
  5
  4
  2
  3
  6
 10
  8
  1
  9
  7

Random.default_rng() -> rng

기본 전역 난수 생성기(RNG)를 반환합니다. 이는 명시적인 RNG가 제공되지 않을 때 rand 관련 함수에서 사용됩니다.

Random 모듈이 로드되면 기본 RNG는 무작위로 시드가 설정됩니다. Random.seed!()를 통해: 이는 새로운 줄리아 세션이 시작될 때마다 rand()의 첫 번째 호출이 다른 결과를 생성함을 의미합니다. 단, 먼저 seed!(seed)가 호출되지 않는 한 그렇습니다.

스레드 안전합니다: 서로 다른 스레드는 default_rng()에서 rand 관련 함수를 안전하게 동시에 호출할 수 있습니다. 예: rand(default_rng()).

seed!([rng=default_rng()], seed) -> rng
seed!([rng=default_rng()]) -> rng

난수 생성기를 다시 시드합니다: rng는 seed가 제공될 때만 재현 가능한 숫자 시퀀스를 제공합니다. 일부 RNG는 RandomDevice와 같이 시드를 허용하지 않습니다. seed! 호출 후, rng는 동일한 시드로 초기화된 새로 생성된 객체와 동등합니다. 허용되는 시드의 유형은 rng의 유형에 따라 다르지만, 일반적으로 정수 시드는 작동해야 합니다.

rng가 지정되지 않으면 공유 작업 로컬 생성기의 상태를 시드하는 것으로 기본 설정됩니다.

예제

julia> Random.seed!(1234);

julia> x1 = rand(2)
2-element Vector{Float64}:
 0.32597672886359486
 0.5490511363155669

julia> Random.seed!(1234);

julia> x2 = rand(2)
2-element Vector{Float64}:
 0.32597672886359486
 0.5490511363155669

julia> x1 == x2
true

julia> rng = Xoshiro(1234); rand(rng, 2) == x1
true

julia> Xoshiro(1) == Random.seed!(rng, 1)
true

julia> rand(Random.seed!(rng), Bool) # 재현 불가능
true

julia> rand(Random.seed!(rng), Bool) # 재현 불가능
false

julia> rand(Xoshiro(), Bool) # 재현 불가능
true

AbstractRNG

MersenneTwister 및 RandomDevice와 같은 난수 생성기의 슈퍼타입입니다.

TaskLocalRNG

TaskLocalRNG는 스레드가 아닌 작업에 로컬한 상태를 가지고 있습니다. 작업 생성 시 부모 작업의 상태에서 시드가 설정되지만, 부모의 RNG 상태는 진행되지 않습니다.

장점으로는 TaskLocalRNG가 매우 빠르며, 스케줄러 결정과 무관하게 재현 가능한 다중 스레드 시뮬레이션을 허용합니다(경쟁 조건을 제외하고). 작업 생성에 대한 결정에 스레드 수가 사용되지 않는 한, 시뮬레이션 결과는 사용 가능한 스레드/CPU 수와도 독립적입니다. 난수 스트림은 하드웨어의 세부 사항에 의존하지 않아야 하며, 엔디안 및 가능성 있는 워드 크기까지 포함됩니다.

current_task()에서 반환된 작업이 아닌 다른 작업의 RNG를 사용하거나 시드하는 것은 정의되지 않은 동작입니다: 대부분의 경우 작동하지만, 때때로 조용히 실패할 수 있습니다.

seed!로 TaskLocalRNG()를 시드할 때, 전달된 시드는(있는 경우) 어떤 정수도 될 수 있습니다.

Xoshiro(seed::Union{Integer, AbstractString})
Xoshiro()

Xoshiro256++는 David Blackman과 Sebastiano Vigna가 "Scrambled Linear Pseudorandom Number Generators", ACM Trans. Math. Softw., 2021에서 설명한 빠른 의사 난수 생성기입니다. 참조 구현은 https://prng.di.unimi.it 에서 사용할 수 있습니다.

높은 속도 외에도 Xoshiro는 메모리 사용량이 적어 오랜 시간 동안 여러 다른 난수 상태를 유지해야 하는 애플리케이션에 적합합니다.

Julia의 Xoshiro 구현은 대량 생성 모드를 가지고 있습니다. 이 모드는 부모로부터 새로운 가상 PRNG를 시드하고 SIMD를 사용하여 병렬로 생성합니다(즉, 대량 스트림은 여러 개의 교차된 xoshiro 인스턴스로 구성됩니다). 가상 PRNG는 대량 요청이 처리되면 폐기되며(힙 할당을 유발하지 않아야 함) 됩니다.

시드가 제공되지 않으면 시스템의 엔트로피를 사용하여 무작위로 생성된 시드가 생성됩니다. 이미 존재하는 Xoshiro 객체의 시드를 다시 설정하려면 seed! 함수를 참조하십시오.

예제

julia> using Random

julia> rng = Xoshiro(1234);

julia> x1 = rand(rng, 2)
2-element Vector{Float64}:
 0.32597672886359486
 0.5490511363155669

julia> rng = Xoshiro(1234);

julia> x2 = rand(rng, 2)
2-element Vector{Float64}:
 0.32597672886359486
 0.5490511363155669

julia> x1 == x2
true

MersenneTwister(seed)
MersenneTwister()

MersenneTwister RNG 객체를 생성합니다. 서로 다른 RNG 객체는 고유한 시드를 가질 수 있으며, 이는 서로 다른 난수 스트림을 생성하는 데 유용할 수 있습니다. seed는 정수, 문자열 또는 UInt32 정수의 벡터일 수 있습니다. 시드가 제공되지 않으면 무작위로 생성된 시드가 생성됩니다(시스템의 엔트로피를 사용하여). 이미 존재하는 MersenneTwister 객체의 시드를 다시 설정하려면 seed! 함수를 참조하십시오.

예제

julia> rng = MersenneTwister(123);

julia> x1 = rand(rng, 2)
2-element Vector{Float64}:
 0.37453777969575874
 0.8735343642013971

julia> x2 = rand(MersenneTwister(123), 2)
2-element Vector{Float64}:
 0.37453777969575874
 0.8735343642013971

julia> x1 == x2
true

RandomDevice()

RandomDevice RNG 객체를 생성합니다. 이러한 두 객체는 항상 서로 다른 난수 스트림을 생성합니다. 엔트로피는 운영 체제에서 얻습니다.

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

rng에서 x의 무작위 값을 생성하는 데 사용할 수 있는 샘플러 객체를 반환합니다.

sp = Sampler(rng, x, repetition)일 때, rand(rng, sp)는 무작위 값을 추출하는 데 사용되며, 그에 따라 정의되어야 합니다.

repetition은 Val(1) 또는 Val(Inf)일 수 있으며, 해당하는 경우 사전 계산의 양을 결정하는 제안으로 사용되어야 합니다.

Random.SamplerType 및 Random.SamplerTrivial는 각각 타입 및 값에 대한 기본 대체입니다. Random.SamplerSimple는 이 목적만을 위해 추가 타입을 정의하지 않고도 사전 계산된 값을 저장하는 데 사용할 수 있습니다.

SamplerType{T}()

타입을 위한 샘플러로, 다른 정보는 포함되어 있지 않습니다. 타입으로 호출될 때 Sampler의 기본 대체입니다.

SamplerTrivial(x)

주어진 값 x를 단순히 감싸는 샘플러를 생성합니다. 이는 값에 대한 기본 대체입니다. 이 샘플러의 eltype은 eltype(x)와 같습니다.

권장 사용 사례는 미리 계산된 데이터 없이 값에서 샘플링하는 것입니다.

SamplerSimple(x, data)

주어진 값 x와 data를 감싸는 샘플러를 생성합니다. 이 샘플러의 eltype은 eltype(x)와 같습니다.

권장 사용 사례는 미리 계산된 데이터로부터 값을 샘플링하는 것입니다.