Vectors कॉन्सेप्ट में हमने कहा था कि "ऐरे Julia भाषा के केंद्र में हैं" और वेक्टर एक-आयामी होता है।
इसे देखते हुए हम उम्मीद कर सकते हैं कि यह भाषा वेक्टर के साथ कुछ करने के कई बहुमुखी और शक्तिशाली तरीके देती है, इसका मतलब जो भी हो।
वेक्टर इनपुट लेने वाले फंक्शन
कुछ बहुत सरल फंक्शन एक वेक्टर इनपुट लेते हैं और एक स्केलर आउटपुट लौटाते हैं।
v = [2, 3, 4]
length(v) # => 3
sum(v) # => 9
अंकगणित
मान लीजिए आपके पास एक संख्यात्मक वेक्टर है और आप हर वैल्यू में से 0.5 घटाना चाहते हैं।
julia> v = [1.2, 1.5, 1.7]
3-element Vector{Float64}:
1.2
1.5
1.7
julia> v - 0.5
ERROR: MethodError: no method matching -(::Vector{Float64}, ::Float64)
यह काम नहीं करता, तो क्या किसी दूसरे वेक्टर को घटाया जाए?
julia> v - [0.5, 0.5, 0.5]
3-element Vector{Float64}:
0.7
1.0
1.2
यह सफल तो होता है, लेकिन जैसे-जैसे वेक्टर लंबे होते जाते हैं, यह काफी थकाऊ और मेमोरी खाने वाला हो जाता है।
अच्छी बात यह है कि Julia के पास एक "जादुई" बिंदु है जो इस समस्या को बहुत आसानी से हल कर देता है: आपको बस v .- 0.5 लिखना है।
अगला भाग बताता है कि ऐसा क्यों है।
ब्रॉडकास्टिंग
तो, v - 0.5 काम नहीं करता लेकिन v .- 0.5 सफल होता है, और हमें समझना है कि यह बिंदु क्या कर रहा है।
दो चीज़ें, जो मिलकर मनचाहा परिणाम देती हैं।
1. हर एलिमेंट पर लागू करना
सबसे पहले, किसी भी इन्फिक्स ऑपरेटर से पहले बिंदु लगाने का मतलब है "इस क्रिया को हर एलिमेंट पर अलग-अलग लागू कीजिए"।
इसी तरह, फंक्शन के नाम के बाद बिंदु लगाने से वह "वेक्टराइज़" हो जाता है, भले ही वह फंक्शन स्केलर इनपुट के लिए लिखा गया हो।
julia> sqrt.([1, 4, 9])
3-element Vector{Float64}:
1.0
2.0
3.0
2. सिंगलटन विस्तार
पिछले उदाहरण में हमने देखा कि हम बराबर लंबाई के वेक्टर घटा सकते हैं, हालाँकि यह समझ लीजिए कि .- ऑपरेटर - से ज़्यादा सुरक्षित है, क्योंकि यह हर एलिमेंट पर लागू करने का इरादा साफ कर देता है।
julia> v .- [0.5, 0.5, 0.5]
3-element Vector{Float64}:
0.7
1.0
1.2
अलग-अलग लंबाई के वेक्टर का क्या?
julia> v .- [0.5, 0.5]
ERROR: DimensionMismatch: arrays could not be broadcast to a common size
julia> v .- [0.5,]
3-element Vector{Float64}:
0.7
1.0
1.2
आम तौर पर असमान लंबाइयाँ एक एरर होती हैं, सिवाय उस स्थिति के जब किसी एक की लंबाई 1 हो (तकनीकी रूप से, एक "सिंगलटन" डाइमेंशन)।
[0.5,] जैसे सिंगलटन या सिर्फ 0.5 दोहराव के ज़रिए अपने-आप ज़रूरी लंबाई तक फैला दिए जाते हैं।
broadcasting का मूल यही है।
इंडेक्सिंग
इंडेक्स संख्या से वेक्टर के एलिमेंट चुनने की बात पिछले कॉन्सेप्ट में हो चुकी है।
a = collect('A':'Z') # => 26-element Vector{Char}
# index with an integer
a[2] # => 'B'
# index with a range
a[12:2:18] # => ['L', 'N', 'P, 'R']
# index with another vector
a[ [1, 3, 5] ] # => ['A', 'C', 'E']
लॉजिकल इंडेक्सिंग
ऐसे एलिमेंट भी चुने जा सकते हैं जो कोई लॉजिकल एक्सप्रेशन पूरा करते हों (तकनीकी रूप से, एक "प्रेडिकेट")।
इसके लिए आम तौर पर ब्रॉडकास्टिंग की ज़रूरत पड़ती है।
julia> a[a .< 'D']
3-element Vector{Char}:
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)
'B': ASCII/Unicode U+0042 (category Lu: Letter, uppercase)
'C': ASCII/Unicode U+0043 (category Lu: Letter, uppercase)
ज़्यादा जटिल एक्सप्रेशन में बिंदु बढ़ते चले जाते हैं (लेकिन वे छोटे होते हैं और टाइप करना आसान है)।
julia> a[a .< 'D' .|| a .> 'W']
6-element Vector{Char}:
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)
'B': ASCII/Unicode U+0042 (category Lu: Letter, uppercase)
'C': ASCII/Unicode U+0043 (category Lu: Letter, uppercase)
'X': ASCII/Unicode U+0058 (category Lu: Letter, uppercase)
'Y': ASCII/Unicode U+0059 (category Lu: Letter, uppercase)
'Z': ASCII/Unicode U+005A (category Lu: Letter, uppercase)
याद दिला दें कि "वेक्टर" असल में कोई भी उपयुक्त क्रमबद्ध इटरेबल हो सकता है, जैसे कोई रेंज:
julia> n = 3:10
3:10
julia> n[isodd.(n)]
4-element Vector{Int64}:
3
5
7
9
सीखने का अभ्यास
