Julia 1.0 - Random Numbers

रैंडम नंबर




julia

रैंडम नंबर

जूलिया में रैंडम नंबर जेनरेशन MersenneTwister ऑब्जेक्ट्स के जरिए MersenneTwister Twister लाइब्रेरी का इस्तेमाल करती है। जूलिया के पास एक वैश्विक आरएनजी है, जिसका उपयोग डिफ़ॉल्ट रूप से किया जाता है। अन्य RNG प्रकारों को AbstractRNG प्रकार विरासत में प्राप्त किया जा सकता है; वे तो यादृच्छिक संख्या के कई धाराओं के लिए इस्तेमाल किया जा सकता है। MersenneTwister अलावा, जूलिया भी RandomDevice RNG प्रकार प्रदान करता है, जो कि एन्ट्रापी प्रदान किए गए OS पर एक आवरण है।

यादृच्छिक पीढ़ी से संबंधित अधिकांश कार्य एक वैकल्पिक AbstractRNG ऑब्जेक्ट को पहले तर्क के रूप में स्वीकार करते हैं, जो कि यदि उपलब्ध नहीं कराया जाता है तो वैश्विक एक को चूकता है। इसके अलावा, उनमें से कुछ वैकल्पिक आयाम विनिर्देशों को स्वीकार करते हैं dims... (जो कि एक टपल के रूप में दिया जा सकता है) यादृच्छिक मूल्यों के सरणियों को उत्पन्न करने के लिए।

MersenneTwister या RandomDevice RNG निम्नलिखित प्रकारों की समान रूप से यादृच्छिक संख्या उत्पन्न कर सकती है: Float16 , Float32 , Float64 , BigFloat , Bool , Int8 , UInt8 , Int16 , UInt16 , Int32 , UInt32 , Int64 , UInt64 , Int128 , UInt128 , UInt128 जटिल उन प्रकार के)। रैंडम फ्लोटिंग पॉइंट नंबर $ [0, 1) $ में समान रूप से उत्पन्न होते हैं। जैसा कि BigInt अनबाउंड पूर्णांक का प्रतिनिधित्व करता है, अंतराल को निर्दिष्ट किया जाना चाहिए (जैसे rand(big.(1:6)) )।

इसके अतिरिक्त, कुछ AbstractFloat और Complex प्रकारों के लिए सामान्य और घातीय वितरण कार्यान्वित किए जाते हैं, विवरणों के लिए randexp और randexp देखें।

यादृच्छिक पीढ़ी के कार्य

Base.rand फंक्शन

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

S द्वारा निर्दिष्ट मूल्यों के सेट से एक यादृच्छिक तत्व या यादृच्छिक तत्वों की सरणी चुनें; S हो सकता है

  • एक अनुक्रमणिका संग्रह (उदाहरण के लिए 1:n या ['x','y','z'] ),
  • एक AbstractDict या AbstractSet ऑब्जेक्ट,
  • एक स्ट्रिंग (पात्रों का संग्रह माना जाता है), या
  • एक प्रकार: मान लेने के लिए सेट तब typemin(S):typemax(S) बराबर होता है typemin(S):typemax(S) पूर्णांक के लिए typemin(S):typemax(S) (यह typemin(S):typemax(S) लागू नहीं होता है), और फ्लोटिंग पॉइंट संख्या के लिए $ [0, 1) $ के लिए;

Float64 S डिफॉल्ट Float64 (सिवाय जब dims पूर्णांक का एक टपल हो, तो उस स्थिति में S को निर्दिष्ट किया जाना चाहिए)।

उदाहरण

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

julia> rand(MersenneTwister(0), Dict(1=>2, 3=>4))
1=>2
ध्यान दें

rand(rng, s::Union{AbstractDict,AbstractSet}) की जटिलता s की लंबाई में रैखिक है, जब तक कि निरंतर जटिलता के साथ एक अनुकूलित विधि उपलब्ध नहीं है, जो कि BitSet , Set और BitSet लिए मामला है। कुछ कॉल से अधिक के लिए, rand(rng, collect(s)) उपयोग करें, या तो rand(rng, Dict(s)) या rand(rng, Set(s)) को उपयुक्त के रूप में उपयोग करें।

source

Random.rand! समारोह

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

सरणी A को यादृच्छिक मानों से आबाद करें। यदि S निर्दिष्ट है ( S एक प्रकार या एक संग्रह हो सकता है, विवरण के लिए सीएफ। rand ), मान S से यादृच्छिक रूप से उठाए जाते हैं। यह copyto!(A, rand(rng, S, size(A))) बराबर है copyto!(A, rand(rng, S, size(A))) लेकिन एक नई सारणी आवंटित किए बिना।

उदाहरण

julia> rng = MersenneTwister(1234);

julia> rand!(rng, zeros(5))
5-element Array{Float64,1}:
 0.5908446386657102
 0.7667970365022592
 0.5662374165061859
 0.4600853424625171
 0.7940257103317943
source

Random.bitrand फंक्शन

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

यादृच्छिक बूलियन मानों का एक BitArray उत्पन्न करें।

उदाहरण

julia> rng = MersenneTwister(1234);

julia> bitrand(rng, 10)
10-element BitArray{1}:
 false
  true
  true
  true
  true
 false
  true
 false
 false
  true
source

Base.randn समारोह

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

औसत 0 और मानक विचलन के साथ टाइप T के सामान्य रूप से वितरित यादृच्छिक संख्या उत्पन्न करें। वैकल्पिक रूप से सामान्य रूप से वितरित यादृच्छिक संख्याओं की एक सरणी उत्पन्न करें। Base मॉड्यूल वर्तमान में Float16 , Float32 , और Float64 (डिफ़ॉल्ट), और उनके Complex Float16 लिए एक कार्यान्वयन प्रदान करता है। जब प्रकार तर्क जटिल होता है, तो मानों को गोलाकार सममित जटिल सामान्य वितरण से तैयार किया जाता है।

उदाहरण

julia> rng = MersenneTwister(1234);

julia> randn(rng, ComplexF64)
0.6133070881429037 - 0.6376291670853887im

julia> randn(rng, ComplexF32, (2, 3))
2×3 Array{Complex{Float32},2}:
 -0.349649-0.638457im  0.376756-0.192146im  -0.396334-0.0136413im
  0.611224+1.56403im   0.355204-0.365563im  0.0905552+1.31012im
source

Random.randn! समारोह

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

सरणी A को सामान्य रूप से वितरित (मतलब 0, मानक विचलन 1) यादृच्छिक संख्याओं के साथ भरें। rand फ़ंक्शन भी देखें।

उदाहरण

julia> rng = MersenneTwister(1234);

julia> randn!(rng, zeros(5))
5-element Array{Float64,1}:
  0.8673472019512456
 -0.9017438158568171
 -0.4944787535042339
 -0.9029142938652416
  0.8644013132535154
source

Random.randexp फंक्शन

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

पैमाने 1 के साथ घातांक वितरण के अनुसार टाइप T की एक यादृच्छिक संख्या उत्पन्न करें। वैकल्पिक रूप से ऐसे यादृच्छिक संख्याओं की एक सरणी उत्पन्न करें। Base मॉड्यूल वर्तमान में Float16 , Float32 और Float64 (डिफ़ॉल्ट) प्रकारों के लिए एक कार्यान्वयन प्रदान करता है।

उदाहरण

julia> rng = MersenneTwister(1234);

julia> randexp(rng, Float32)
2.4835055f0

julia> randexp(rng, 3, 3)
3×3 Array{Float64,2}:
 1.5167    1.30652   0.344435
 0.604436  2.78029   0.418516
 0.695867  0.693292  0.643644
source

Random.randexp! समारोह

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

घातांक वितरण (स्केल 1 के साथ) के बाद यादृच्छिक संख्या के साथ सरणी A भरें।

उदाहरण

julia> rng = MersenneTwister(1234);

julia> randexp!(rng, zeros(5))
5-element Array{Float64,1}:
 2.4835053723904896
 1.516703605376473
 0.6044364871025417
 0.6958665886385867
 1.3065196315496677
source

Random.randstring फ़ंक्शन

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

लंबाई के len की एक यादृच्छिक स्ट्रिंग बनाएं, वर्णों से वर्णों से मिलकर, जो ऊपरी और निचले-मामले के अक्षरों और अंक 0-9 के सेट के लिए चूक करते हैं। वैकल्पिक rng तर्क यादृच्छिक संख्या जनरेटर को निर्दिष्ट करता है, यादृच्छिक संख्याएँ देखें।

उदाहरण

julia> Random.seed!(0); randstring()
"0IPrGg0J"

julia> randstring(MersenneTwister(0), 'a':'z', 6)
"aszvqk"

julia> randstring("ACGT")
"TATCGGTC"
ध्यान दें

chars का कोई भी संग्रह हो सकता है, प्रकार Char या UInt8 (अधिक कुशल), बशर्ते कि rand बेतरतीब ढंग से पात्रों को चुन सकता है।

source

क्रम, क्रमपरिवर्तन और फेरबदल

Random.randsubseq फ़ंक्शन

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

दिए गए सरणी A के एक यादृच्छिक क्रम से मिलकर एक वेक्टर लौटें, जहां स्वतंत्र संभाव्यता p साथ A का प्रत्येक तत्व शामिल है (क्रम में)। (जटिलता p*length(A) में रैखिक है, इसलिए यह फ़ंक्शन कुशल है भले ही p छोटा हो और A बड़ा हो।) तकनीकी रूप से, इस प्रक्रिया को A "बर्नौली नमूने" के रूप में जाना जाता है।

उदाहरण

julia> rng = MersenneTwister(1234);

julia> randsubseq(rng, collect(1:8), 0.3)
2-element Array{Int64,1}:
 7
 8
source

Random.randsubseq! समारोह

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

randsubseq तरह, लेकिन परिणाम S में संग्रहीत किए जाते हैं (जो आवश्यकतानुसार randsubseq होता है)।

उदाहरण

julia> rng = MersenneTwister(1234);

julia> S = Int64[];

julia> randsubseq!(rng, S, collect(1:8), 0.3);

julia> S
2-element Array{Int64,1}:
 7
 8
source

Random.randperm फंक्शन

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

लंबाई n एक यादृच्छिक क्रमांकन का निर्माण करें। वैकल्पिक rng तर्क एक यादृच्छिक संख्या जनरेटर निर्दिष्ट करता है ( यादृच्छिक संख्या देखें)। बेतरतीब ढंग से मनमाने ढंग से वेक्टर की अनुमति देने के लिए, shuffle या shuffle! देखें shuffle!

उदाहरण

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

Random.randperm! समारोह

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

लंबाई length(A) एक यादृच्छिक क्रमचय में निर्माण। वैकल्पिक rng तर्क एक यादृच्छिक संख्या जनरेटर निर्दिष्ट करता है ( यादृच्छिक संख्या देखें)। बेतरतीब ढंग से मनमाने ढंग से वेक्टर की अनुमति देने के लिए, shuffle या shuffle! देखें shuffle!

उदाहरण

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

Random.randcycle समारोह

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

लंबाई n एक यादृच्छिक चक्रीय क्रमांकन का निर्माण करें। वैकल्पिक rng तर्क यादृच्छिक संख्या जनरेटर को निर्दिष्ट करता है, यादृच्छिक संख्याएँ देखें।

उदाहरण

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

Random.randcycle! समारोह

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

लंबाई length(A) एक यादृच्छिक चक्रीय क्रमचय में निर्माण। वैकल्पिक rng तर्क यादृच्छिक संख्या जनरेटर को निर्दिष्ट करता है, यादृच्छिक संख्याएँ देखें।

उदाहरण

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

Random.shuffle समारोह

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

v की बेतरतीब ढंग से अनुमत प्रति लौटाएं। वैकल्पिक rng तर्क एक यादृच्छिक संख्या जनरेटर निर्दिष्ट करता है ( यादृच्छिक संख्या देखें)। v -इन-प्लेस की अनुमति देने के लिए, shuffle! देखें shuffle! । बेतरतीब ढंग से अनुमत सूचकांकों को प्राप्त करने के लिए, रैंडम देखें

उदाहरण

julia> rng = MersenneTwister(1234);

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

Random.shuffle! समारोह

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

shuffle इन-वर्जन संस्करण: बेतरतीब ढंग से v -इन-प्लेस, वैकल्पिक रूप से यादृच्छिक-संख्या जनरेटर rng आपूर्ति।

उदाहरण

julia> rng = MersenneTwister(1234);

julia> shuffle!(rng, Vector(1:16))
16-element Array{Int64,1}:
  2
 15
  5
 14
  1
  9
 10
  6
 11
  3
 16
  7
  4
 12
  8
 13
source

जनरेटर (निर्माण और बीजारोपण)

Random.seed! समारोह

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

यादृच्छिक संख्या जनरेटर को rng : rng एक seed प्रदान किए जाने पर और केवल तभी संख्याओं का प्रतिलिपि प्रस्तुत करने योग्य अनुक्रम देगा। कुछ RNG RandomDevice तरह एक बीज को स्वीकार नहीं करते हैं। seed! बाद seed! , rng एक ही बीज के साथ आरंभीकृत नव निर्मित वस्तु के बराबर है।

उदाहरण

julia> Random.seed!(1234);

julia> x1 = rand(2)
2-element Array{Float64,1}:
 0.590845
 0.766797

julia> Random.seed!(1234);

julia> x2 = rand(2)
2-element Array{Float64,1}:
 0.590845
 0.766797

julia> x1 == x2
true

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

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

julia> rand(Random.seed!(rng), Bool) # not reproducible
true

julia> rand(Random.seed!(rng), Bool)
false

julia> rand(MersenneTwister(), Bool) # not reproducible either
true
source

Random.MersenneTwister प्रकार

MersenneTwister(seed)
MersenneTwister()

एक MersenneTwister RNG ऑब्जेक्ट बनाएँ। विभिन्न RNG वस्तुओं के अपने बीज हो सकते हैं, जो यादृच्छिक संख्याओं की विभिन्न धाराओं को उत्पन्न करने के लिए उपयोगी हो सकते हैं। seed एक गैर-नकारात्मक पूर्णांक या UInt32 पूर्णांक का एक वेक्टर हो सकता है। यदि कोई बीज प्रदान नहीं किया जाता है, तो एक यादृच्छिक रूप से उत्पन्न एक बनाया जाता है (सिस्टम से एन्ट्रॉपी का उपयोग करके)। seed! देखें seed! पहले से मौजूद MersenneTwister ऑब्जेक्ट को फिर से शुरू करने के लिए फ़ंक्शन।

उदाहरण

julia> rng = MersenneTwister(1234);

julia> x1 = rand(rng, 2)
2-element Array{Float64,1}:
 0.5908446386657102
 0.7667970365022592

julia> rng = MersenneTwister(1234);

julia> x2 = rand(rng, 2)
2-element Array{Float64,1}:
 0.5908446386657102
 0.7667970365022592

julia> x1 == x2
true
source

Random.RandomDevice

RandomDevice()

एक RandomDevice RNG ऑब्जेक्ट बनाएँ। इस तरह की दो वस्तुएँ हमेशा यादृच्छिक संख्याओं की विभिन्न धाराएँ उत्पन्न करेंगी। एन्ट्रापी ऑपरेटिंग सिस्टम से प्राप्त की जाती है।

source

Random एपीआई में हुकिंग

Random फ़ंक्शंस को विस्तारित करने के लिए दो ज्यादातर ऑर्थोगोनल तरीके हैं:

  1. कस्टम प्रकार के यादृच्छिक मान उत्पन्न करना
  2. नए जनरेटर बनाना

1 के लिए एपीआई) काफी कार्यात्मक है, लेकिन अपेक्षाकृत हाल ही में है इसलिए इसे Random मॉड्यूल के बाद के रिलीज में विकसित करना पड़ सकता है। उदाहरण के लिए, आमतौर पर एक rand विधि को लागू करने के लिए पर्याप्त है ताकि अन्य सभी सामान्य तरीके स्वचालित रूप से काम कर सकें।

2 के लिए एपीआई) अभी भी अल्पविकसित है, और सामान्य प्रकार के उत्पन्न मूल्यों का समर्थन करने के लिए, कार्यान्वयनकर्ता से कड़ाई से अधिक काम करने की आवश्यकता हो सकती है।

कस्टम प्रकार के यादृच्छिक मान उत्पन्न करना

दो श्रेणियां हैं: एक प्रकार से मान उत्पन्न करना (जैसे rand(Int) ), या एक संग्रह से (जैसे rand(1:3) )। सरल मामलों को पहले समझाया जाता है, और अधिक उन्नत उपयोग बाद में प्रस्तुत किया जाता है। हम यह मानते हैं कि एल्गोरिथ्म का विकल्प RNG से स्वतंत्र है, इसलिए हम अपने हस्ताक्षरों में AbstractRNG का उपयोग करते हैं।

एक प्रकार से मान उत्पन्न करना

एक प्रकार T को देखते हुए, वर्तमान में यह माना जाता है कि अगर rand(T) को परिभाषित किया जाता है, तो टाइप T का एक ऑब्जेक्ट तैयार किया जाएगा। टाइप T के मानों की यादृच्छिक पीढ़ी को परिभाषित करने के लिए, निम्न विधि को परिभाषित किया जा सकता है: rand(rng::AbstractRNG, ::Random.SamplerType{T}) (यह क्या rand(rng, T) वापस लौटना चाहिए rand(rng, T) )।

आइए निम्नलिखित उदाहरण लेते हैं: हम एक Die टाइप लागू करते हैं, जिसमें पक्षों की संख्या n , 1 से n । हम चाहते हैं कि rand(Die) 20 से ऊपर (और कम से कम 4) की एक यादृच्छिक संख्या के साथ एक मरने का उत्पादन करें:

struct Die
    nsides::Int # number of sides
end

Random.rand(rng::AbstractRNG, ::Random.SamplerType{Die}) = Die(rand(rng, 4:20))

# output

Die लिए स्केलर और सरणी विधियाँ अब उम्मीद के मुताबिक काम करती हैं:

julia> rand(Die)
Die(18)

julia> rand(MersenneTwister(0), Die)
Die(4)

julia> rand(Die, 3)
3-element Array{Die,1}:
 Die(6)
 Die(11)
 Die(5)

julia> a = Vector{Die}(undef, 3); rand!(a)
3-element Array{Die,1}:
 Die(18)
 Die(6)
 Die(8)

संग्रह से मान उत्पन्न करना

एक संग्रह प्रकार S को देखते हुए, वर्तमान में यह माना जाता है कि यदि rand(::S) को परिभाषित किया गया है, तो टाइप eltype(S) की एक वस्तु का उत्पादन किया जाएगा। प्रकार S की वस्तुओं में से यादृच्छिक पीढ़ी को परिभाषित करने के लिए, निम्नलिखित विधि को परिभाषित किया जा सकता है: rand(rng::AbstractRNG, sp::Random.SamplerTrivial{S}) । यहाँ, sp केवल S ऑब्जेक्ट को लपेटता है, जिसे sp[] माध्यम से एक्सेस किया जा सकता है। Die उदाहरण को जारी रखते हुए, हम चाहते हैं कि अब rand(d::Die) को परिभाषित करें ताकि d के पक्षों में से एक के लिए एक Int का उत्पादन किया जा सके:

julia> Random.rand(rng::AbstractRNG, d::Random.SamplerTrivial{Die}) = rand(rng, 1:d[].nsides);

julia> rand(Die(4))
3

julia> rand(Die(4), 3)
3-element Array{Any,1}:
 3
 4
 2

अंतिम उदाहरण में, एक Vector{Any} निर्मित होता है; इसका कारण यह है कि eltype(Die) == Any । उपाय Base.eltype(::Type{Die}) = Int को परिभाषित Base.eltype(::Type{Die}) = Int

एक AbstractFloat प्रकार के लिए मान उत्पन्न करना

AbstractFloat प्रकार विशेष-आवरण हैं, क्योंकि डिफ़ॉल्ट रूप से यादृच्छिक मान पूरे प्रकार डोमेन में उत्पन्न नहीं होते हैं, बल्कि [0,1)T <: AbstractFloat लिए निम्न विधि लागू की जानी चाहिए T <: AbstractFloat : Random.rand(::AbstractRNG, ::Random.SamplerTrivial{Random.CloseOpen01{T}})

कॉल के बीच कैश्ड संगणना के साथ अनुकूलन पीढ़ी

जब बार-बार रैंडम वैल्यूज (एक ही rand पैरामीटर के साथ) उत्पन्न करते हैं, तो यह कुछ प्रकारों के लिए होता है कि एक गणना का परिणाम प्रत्येक कॉल के लिए उपयोग किया जाता है। इस मामले में, गणना को वास्तव में मूल्यों को उत्पन्न करने से अलग किया जा सकता है। उदाहरण के लिए यह मामला है। AbstractArray लिए डिफ़ॉल्ट कार्यान्वयन। मान लें कि rand(rng, 1:20) को बार-बार लूप में बुलाया जाना है: इस rand(rng, 1:20) का लाभ उठाने का तरीका इस प्रकार है:

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

यह तंत्र निश्चित रूप से यादृच्छिक सरणी पीढ़ी (जैसे rand(1:20, 10) ) के डिफ़ॉल्ट कार्यान्वयन द्वारा उपयोग किया जाता है। कस्टम प्रकार के लिए इस डिकॉउलिंग को लागू करने के लिए, एक सहायक प्रकार का उपयोग किया जा सकता है। हमारे Die उदाहरण पर वापस जाएं: rand(::Die) एक सीमा से यादृच्छिक पीढ़ी का उपयोग करता है, इसलिए इस अनुकूलन के लिए एक अवसर है:

import Random: Sampler, rand

struct SamplerDie <: Sampler{Int} # generates values of type Int
    die::Die
    sp::Sampler{Int} # this is an abstract type, so this could be improved
end

Sampler(RNG::Type{<:AbstractRNG}, die::Die, r::Random.Repetition) =
    SamplerDie(die, Sampler(RNG, 1:die.nsides, r))
# the `r` parameter will be explained later on

rand(rng::AbstractRNG, sp::SamplerDie) = rand(rng, sp.sp)

अब sp = Sampler(rng, die) साथ एक नमूना लेना संभव है, और rng संबंधित किसी भी rand कॉल में die बजाय sp उपयोग करें। ऊपर दिए गए सरलीकृत उदाहरण में, die को SamplerDie में संग्रहीत करने की आवश्यकता नहीं है, लेकिन व्यवहार में अक्सर ऐसा होता है।

यह पैटर्न इतना अक्सर होता है कि एक सहायक प्रकार जिसका नाम Random.SamplerSimple उपलब्ध है, हमें SamplerDie की परिभाषा SamplerDie : हम अपने SamplerDie को लागू कर सकते थे:

Sampler(RNG::Type{<:AbstractRNG}, die::Die, r::Random.Repetition) =
    SamplerSimple(die, Sampler(RNG, 1:die.nsides, r))

rand(rng::AbstractRNG, sp::SamplerSimple{Die}) = rand(rng, sp.data)

यहां, sp.data , sp.data के कॉल में दूसरे पैरामीटर को संदर्भित करता है (इस मामले में Sampler(rng, 1:die.nsides, r) बराबर), जबकि Die ऑब्जेक्ट को sp[] माध्यम से एक्सेस किया जा सकता है।

एक अन्य सहायक प्रकार वर्तमान में अन्य मामलों के लिए उपलब्ध है, Random.SamplerTag , लेकिन इसे आंतरिक API के रूप में माना जाता है, और बिना किसी उचित समय के किसी भी समय टूट सकता है।

स्केलर या सरणी पीढ़ी के लिए अलग एल्गोरिदम का उपयोग करना

कुछ मामलों में, चाहे वह केवल कुछ मुट्ठी भर मूल्यों को उत्पन्न करना चाहता हो या बड़ी संख्या में मूल्यों का एल्गोरिदम की पसंद पर प्रभाव पड़ेगा। यह Sampler कंस्ट्रक्टर के तीसरे पैरामीटर के साथ संभाला जाता है। मान लेते हैं कि हमने Die लिए दो सहायक प्रकार परिभाषित किए हैं, SamplerDie1 कहते हैं जिसका उपयोग केवल कुछ यादृच्छिक मान उत्पन्न करने के लिए किया जाना चाहिए, और कई मानों के लिए SamplerDieMany । हम उन प्रकारों का उपयोग इस प्रकार कर सकते हैं:

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

बेशक, rand को उन प्रकारों पर भी परिभाषित किया जाना चाहिए (यानी rand(::AbstractRNG, ::SamplerDie1) और rand(::AbstractRNG, ::SamplerDieMany) )।

ध्यान दें: Sampler(rng, x) Sampler(rng, x, Val(Inf)) Random.Repetition Sampler(rng, x, Val(Inf)) लिए एक Random.Repetition है, और Random.Repetition Union{Val{1}, Val{Inf}} लिए एक उपनाम है।

नए जनरेटर बनाना

एपीआई स्पष्ट रूप से अभी तक परिभाषित नहीं है, लेकिन अंगूठे के एक नियम के रूप में:

  1. "मूल" प्रकार ( isbitstype पूर्णांक और फ्लोटिंग प्रकार) का निर्माण करने वाली किसी भी rand विधि को इस विशिष्ट isbitstype लिए परिभाषित किया जाना चाहिए, यदि वे आवश्यक हैं;
  2. एक AbstractRNG को स्वीकार करने वाले अन्य प्रलेखित rand विधियों को बॉक्स से बाहर काम करना चाहिए, (1 से विधियां प्रदान की जाती हैं) जो लागू होते हैं, उन पर लागू होते हैं), लेकिन निश्चित रूप से इस RNG के लिए विशेष किया जा सकता है यदि अनुकूलन के लिए जगह है।

1) के बारे में, एक rand विधि स्वचालित रूप से काम करने के लिए हो सकती है, लेकिन यह आधिकारिक तौर पर समर्थित नहीं है और बाद के रिलीज में चेतावनी के बिना टूट सकती है।

एक काल्पनिक MyRNG जनरेटर के लिए एक नई rand विधि को परिभाषित करने के लिए, और एक मान विनिर्देशन s (जैसे s == Int , या s == 1:10 ) टाइप S==typeof(s) या S==Type{s} यदि s एक प्रकार है, वही दो विधियाँ जो हमने देखी थीं, जिन्हें परिभाषित किया जाना चाहिए:

  1. Sampler(::Type{MyRNG}, ::S, ::Repetition) , जो किसी वस्तु के प्रकार को लौटाता है, SamplerS
  2. rand(rng::MyRNG, sp::SamplerS)

ऐसा हो सकता है कि Sampler(rng::AbstractRNG, ::S, ::Repetition) पहले से ही Random मॉड्यूल में परिभाषित है। तब व्यवहार में चरण 1 को छोड़ना संभव होगा (यदि कोई इस विशेष RNG प्रकार के लिए पीढ़ी को विशेषज्ञता देना चाहता है), लेकिन संबंधित SamplerS प्रकार को आंतरिक विवरण के रूप में माना जाता है, और चेतावनी के बिना बदला जा सकता है।

सरणी पीढ़ी के विशेषज्ञ

कुछ मामलों में, किसी दिए गए RNG प्रकार के लिए, यादृच्छिक मूल्यों की एक सरणी उत्पन्न करना एक विशेष विधि के साथ अधिक कुशल हो सकता है, केवल पहले बताई गई डिकॉउलिंग तकनीक का उपयोग करके। यह उदाहरण के लिए MersenneTwister लिए मामला है, जो मूल रूप से एक सरणी में यादृच्छिक मान लिखते हैं।

MyRNG और विनिर्देशन s लिए इस विशेषज्ञता को लागू करने के लिए, टाइप S तत्वों का निर्माण करते हुए, निम्न विधि हो सकती है: rand!(rng::MyRNG, a::AbstractArray{S}, ::SamplerS) : rand!(rng::MyRNG, a::AbstractArray{S}, ::SamplerS) , जहां SamplerS है Sampler(MyRNG, s, Val(Inf)) द्वारा लौटाए गए नमूने के प्रकार। AbstractArray बजाय, कार्यक्षमता को केवल उप-प्रकार के लिए लागू करना संभव है, जैसे Array{S}rand की गैर-उत्परिवर्तन सरणी विधि स्वचालित रूप से आंतरिक रूप से इस विशेषज्ञता को बुलाएगी।