कई प्रोग्राम को असली दुनिया की घटनाओं का अनुकरण करने के लिए (दिखने में) रैंडम वैल्यू की ज़रूरत होती है।
आम और परिचित उदाहरणों में शामिल हैं:
- सिक्का उछालना:
('H', 'T') में से एक रैंडम वैल्यू।
- पासा फेंकना: 1 से 6 के बीच एक रैंडम पूर्णांक।
- ताश की गड्डी फेंटना: पत्तों के ऐरे का एक रैंडम क्रम।
कंप्यूटर से वास्तव में रैंडम वैल्यू बनाना आश्चर्यजनक रूप से कठिन तकनीकी चुनौती है, इसलिए हो सकता है कि आप इन नतीजों को "स्यूडोरैंडम" कहते हुए देखें।
ज़रूरी: यह कॉन्सेप्ट क्रिप्टोग्राफिक रूप से सुरक्षित रैंडम संख्याओं को शामिल नहीं करता, जो कहीं ज़्यादा कठिन चुनौती हैं।
लेकिन Julia की स्टैंडर्ड लाइब्रेरी के Random मॉड्यूल जैसी अच्छी तरह बनी लाइब्रेरी तेज़ और लचीली होती हैं, और ये मॉडलिंग, अनुकरण तथा गेम्स के ज़्यादातर कामों के लिए काफ़ी अच्छे नतीजे देती हैं।
Julia रैंडम कार्यक्षमता को कई जगहों पर बाँटता है:
-
Base में बस कुछ बुनियादी लेकिन बहुत काम के फंक्शन, जो हमेशा उपलब्ध रहते हैं।
-
Random मॉड्यूल में और भी ज़्यादा विकल्प।
- और भी विशेष कार्यक्षमता उन पैकेजों में, जिन्हें इस्तेमाल से पहले इंस्टॉल करना पड़ता है (और जो Exercism में उपलब्ध नहीं हैं)।
Random स्टैंडर्ड लाइब्रेरी का हिस्सा है और ज़्यादा संभावना है कि यह पहले से इंस्टॉल हो, लेकिन इसकी सामग्री को नेमस्पेस में लाने के लिए आपको अपने प्रोग्राम के ऊपर using Random जोड़ना होगा।
rand() फंक्शन
यह फंक्शन क्या करता है, यह इस पर निर्भर करता है कि आप इसे कौन से आर्गुमेंट देते हैं।
इसमें बहुत सारे विकल्प हैं।
बिना किसी आर्गुमेंट के, यह 0 (सम्मिलित) से 1 के बीच एक दशमलव संख्या बनाता है।
यह एक uniform डिस्ट्रिब्यूशन है जिसमें सभी वैल्यू की संभावना बराबर होती है, जैसा कि नीचे "डिस्ट्रिब्यूशन के साथ काम करना" वाले हिस्से में बताया गया है।
सिर्फ एक पूर्णांक आर्गुमेंट उसी लंबाई का एक वेक्टर बनाता है।
julia> rand()
0.10261774967264703
julia> rand(5)
5-element Vector{Float64}:
0.24134501977563894
0.5664193284851202
0.9804412082089355
0.6229551330613335
0.47589221741904664
किसी और रेंज के लिए, बस नतीजे को ठीक से खिसकाइए और स्केल कीजिए।
नीचे दिया गया उदाहरण घटाव के लिए ब्रॉडकास्टिंग का इस्तेमाल करता है, जिसके बारे में वेक्टर ऑपरेशंस कॉन्सेप्ट में बताया गया है।
.- इस गणित को बस वेक्टर के हर एलिमेंट पर लागू करता है।
# numbers between -1.0 and +1.0
julia> (rand(5) .- 0.5) * 2
5-element Vector{Float64}:
-0.5303906759076336
0.9635682226775855
-0.048823697086981754
0.465842804648374
0.9880834344780736
अगर आर्गुमेंट के तौर पर सिर्फ एक टाइप दिया जाए, तो rand सीमा के रूप में typemin और typemax का इस्तेमाल करेगा।
शायद आप यह नहीं चाहते!
रैंडम पूर्णांकों के लिए, हम एक रेंज दे सकते हैं, और चाहें तो यह भी कि कितनी वैल्यू बनानी हैं।
julia> rand(Int64)
-9159538335234594326 # not very useful
julia> rand(1:10, 5)
5-element Vector{Int64}:
1
1
1
4
7
ऊपर दिए गए rand(1:10, 5) उदाहरण में ध्यान दीजिए कि (संयोग से) वैल्यू दोहराई जा रही हैं, क्योंकि हर चुनाव स्वतंत्र है।
इसे "रीप्लेसमेंट के साथ सैंपलिंग" कहते हैं, जिस पर नीचे और विस्तार से बात की गई है।
रेंज में दशमलव वैल्यू के लिए, आमतौर पर आपको स्टेप साइज़ बताना होगा।
वरना स्टेप डिफ़ॉल्ट रूप से 1.0 हो जाएगा, जो शायद ही कभी काम आता है।
julia> rand(2.4:0.01:3.2, 4)
4-element Vector{Float64}:
3.19
2.53
3.14
3.13
या फिर, एक ऐरे या टपल दीजिए, और rand एक रैंडम एंट्री लौटाएगा:
julia> rand([4, 9, 16, 25])
16
# coin flip
julia> rand(['H', 'T'])
'H': ASCII/Unicode U+0048 (category Lu: Letter, uppercase)
# mixed types in tuple
julia> rand( (1, 3.2, "name"), 2 )
2-element Vector{Any}:
1
"name"
रीप्लेसमेंट के साथ या बिना सैंपलिंग
सोचिए कि हमारे पास एक थैला है जिसमें 3 लाल गेंदें और 4 हरी गेंदें हैं, और हम थैले से रैंडम रूप से एक गेंद निकालते हैं।
दूसरी गेंद निकालने के लिए दो तरीके हैं:
- पहली गेंद को थैले में वापस डालिए और दूसरी निकालने से पहले सब कुछ अच्छी तरह हिला दीजिए।
अब गेंदों की संख्या पहले जैसी ही (7) है, और लाल और हरी का अनुपात भी वही रहता है।
- दूसरी निकालने से पहले पहली गेंद मेज़ पर रख दीजिए।
अब थैले में सिर्फ 6 गेंदें हैं, और लाल:हरी का अनुपात पहली गेंद के रंग पर निर्भर करता है।
पहली स्थिति रीप्लेसमेंट के साथ है, दूसरी उसके बिना, और दोनों अलग-अलग नतीजे देती हैं।
Julia में रीप्लेसमेंट के बिना सैंपलिंग का अनुकरण करने के लिए कुछ विकल्प हैं।
सबसे आसान (और Exercism के अंदर इकलौता) तरीका यह है कि Random.shuffle() का इस्तेमाल करके एंट्रियों को रैंडम क्रम में रखिए, फिर पहले n एलिमेंट ले लीजिए।
यह छोटी समस्याओं के लिए तो ठीक है, लेकिन बड़े संग्रहों पर शायद अच्छी तरह काम न करे: shuffle को पूरा ऐरे बनाना पड़ता है, भले ही आप उसका सिर्फ एक छोटा हिस्सा चाहते हों।
रीप्लेसमेंट के साथ सैंपलिंग "ठीक से" करने के लिए, StatsBase.jl पैकेज इंस्टॉल कीजिए।
यह पूरे विकल्पों के साथ sample() फंक्शन देता है।
हम उचित रूप से उम्मीद कर सकते हैं कि आने वाले किसी रिलीज़ में ऐसी ही कार्यक्षमता Random में जोड़ दी जाएगी, ताकि यह स्टैंडर्ड लाइब्रेरी का हिस्सा बन जाए (इस दस्तावेज़ के कोड नमूने Julia 1.11 के साथ जाँचे गए थे)।
डिस्ट्रिब्यूशन के साथ काम करना
अब तक हमने उन मामलों पर ध्यान दिया है जिनमें सभी परिणामों की संभावना बराबर होती है।
उदाहरण के लिए, rand(1:100) 1 से 100 तक के किसी भी पूर्णांक को बराबर संभावना से देता है।
असली दुनिया की कई स्थितियाँ इससे कहीं कम आसान होती हैं।
इसीलिए सांख्यिकीविदों ने "असली दुनिया" के नतीजों को गणितीय ढंग से बताने के लिए कई तरह के distributions बनाए हैं।
यूनिफॉर्म डिस्ट्रिब्यूशन
ऊपर बताया गया rand() फंक्शन तब इस्तेमाल होता है जब सभी संभावनाएँ बराबर हों।
इसे uniform डिस्ट्रिब्यूशन कहते हैं।
गॉसियन डिस्ट्रिब्यूशन
इसे "नॉर्मल" डिस्ट्रिब्यूशन या "घंटी के आकार की" वक्र भी कहते हैं, और यह मापी गई वैल्यू में आने वाली अशुद्धि बताने का बहुत आम तरीका है।
उदाहरण के लिए, मान लीजिए कि जिस कारखाने में आप काम करते हैं, उसने अभी-अभी 10,000 बोल्ट खरीदे हैं, जो एक जैसे होने चाहिए।
आप कारखाने के रोबोट को इन्हें संभालने के लिए तैयार करना चाहते हैं, तो आप 100 बोल्ट का एक नमूना तौलते हैं और पाते हैं कि उनका औसत (या mean) वज़न 4.731g है।
इसका यह मतलब होना बेहद कम संभव है कि इन सबका वज़न ठीक 4.731g हो।
हो सकता है कि आप पाएँ कि वैल्यू 4.627 से 4.794g तक फैली हैं, लेकिन 4.731g के आसपास केंद्रित हैं।
यह Gaussian distribution है, जिसमें संभावनाएँ औसत पर सबसे ज़्यादा होती हैं और दोनों तरफ सममित रूप से घटती जाती हैं (इसीलिए "घंटी के आकार की")।
इसका सॉफ्टवेयर में अनुकरण करने के लिए, हमें वक्र की चौड़ाई बताने का कोई तरीका चाहिए (आमतौर पर, महँगे बोल्ट सस्ते बोल्टों के मुकाबले औसत के आसपास ज़्यादा कसकर केंद्रित होंगे!).
परंपरा से, यह standard deviation से किया जाता है: तेज़ और संकरे वक्र के लिए छोटी वैल्यू, और नीचे और चौड़े वक्र के लिए बड़ी।
गणितज्ञों को ग्रीक अक्षर पसंद हैं, इसलिए हम औसत दिखाने के लिए μ (म्यू) और स्टैंडर्ड डेविएशन दिखाने के लिए σ (सिग्मा) इस्तेमाल करते हैं।
इसलिए, अगर आप पढ़ें कि "95% वैल्यू μ के 2σ के अंदर हैं" या "हिग्स बोसॉन 5-सिग्मा विश्वास के साथ पाया गया है", तो ऐसी बातों का संबंध स्टैंडर्ड डेविएशन से होता है।
इस बारे में और बातें Statistics कॉन्सेप्ट में होंगी।
randn() फंक्शन
"random normal" का छोटा रूप, यह rand() के दशमलव वाले रूप जैसा ही है, बस फर्क यह है कि वैल्यू 0 औसत और 1 स्टैंडर्ड डेविएशन वाले गॉसियन के रूप में बँटी होती हैं।
फिर से, आप शायद randn के मूल आउटपुट को स्टैंडर्ड डेविएशन के लिए स्केल करना चाहें, और औसत के लिए उसे खिसकाना चाहें।
नीचे दिया गया उदाहरण इसे 30 औसत और 5 स्टैंडर्ड डेविएशन में बदलता है।
julia> raw = randn(5)
5-element Vector{Float64}:
3.0762588867281475
1.5101100620253902
-0.5914858221637778
0.684175554069735
-0.8416433926114673
julia> raw * 5 .+ 30
5-element Vector{Float64}:
45.38129443364074
37.55055031012695
27.04257088918111
33.420877770348675
25.791783036942665
आउटपुट को देखकर यह बताना मुश्किल है कि मूल आउटपुट यूनिफॉर्म डिस्ट्रिब्यूशन की तुलना में शून्य के ज़्यादा करीब केंद्रित होता है।
अगर आपको इसमें शक है, तो 1000 या उससे ज़्यादा बनाइए और उन्हें प्लॉट करके इसे और स्पष्ट कर दीजिए।
Random मॉड्यूल
इस मॉड्यूल में अगले स्तर की कार्यक्षमता है, जिसे Julia की डिफॉल्ट कॉन्फिगरेशन का आकार कम रखने के लिए Base से बाहर रखा गया है।
Random, Base के rand और randn में उनके बदलाव करने वाले रूप rand! और randn! भी जोड़ता है।
एक काम की चीज़ randstring है, जो दी गई लंबाई की एक स्ट्रिंग बनाता है।
डिफॉल्ट रूप से यह बड़े और छोटे अक्षरों के साथ 0 से 9 तक के अंक इस्तेमाल करता है, लेकिन और विकल्प भी बताए जा सकते हैं।
julia> using Random
julia> randstring(20)
"BoJnIxrS33pJiWggXZQV"
इसके अलावा, दी गई लंबाई का रैंडम BitArray बनाने के लिए एक bitrand फंक्शन है।
julia> bitrand(5)
julia> bitrand(5)
5-element BitVector:
1
1
0
0
1
शफल और परम्युटेशन
किसी Vector की एंट्रियों को रैंडम रूप से शफल करने के लिए हमारे पास shuffle है; और इनपुट वेक्टर को उसी जगह बदलने के लिए shuffle! भी।
julia> v = ['A', '1', '2', 'J', 'Q', 'K'];
julia> shuffle(v)
6-element Vector{Char}:
'K': ASCII/Unicode U+004B (category Lu: Letter, uppercase)
'1': ASCII/Unicode U+0031 (category Nd: Number, decimal digit)
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)
'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)
'2': ASCII/Unicode U+0032 (category Nd: Number, decimal digit)
'Q': ASCII/Unicode U+0051 (category Lu: Letter, uppercase)
# shuffles are random:
julia> shuffle(v)
6-element Vector{Char}:
'2': ASCII/Unicode U+0032 (category Nd: Number, decimal digit)
'K': ASCII/Unicode U+004B (category Lu: Letter, uppercase)
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)
'Q': ASCII/Unicode U+0051 (category Lu: Letter, uppercase)
'J': ASCII/Unicode U+004A (category Lu: Letter, uppercase)
'1': ASCII/Unicode U+0031 (category Nd: Number, decimal digit)
कभी-कभी शफल किए गए इंडेक्स रखना ज़्यादा काम आता है।
इसके लिए randperm(n) इस्तेमाल कीजिए, जहाँ n अनुक्रम की लंबाई है।
julia> randperm(6)
6-element Vector{Int64}:
6
2
4
1
3
5
वास्तव में, ऊपर दिया गया उदाहरण shuffle(1:6) जैसे ही नतीजे देता है।
सीखने का अभ्यास
