वेक्टर में

वेक्टर के बारे में

Julia का एक मुख्य उद्देश्य है संख्यात्मक डेटा पर तेज़ी से और कुशलता से गणना कर पाना। और वह भी बहुत सारे संख्यात्मक डेटा पर।

आम तौर पर यह डेटा ऐरे (या उससे जुड़े किसी टाइप) में संग्रहीत रहता है, इसलिए यह कहना उचित है कि ऐरे Julia भाषा के केंद्र में हैं।

ऐरे किसी भी आकार के हो सकते हैं (केवल आपके हार्डवेयर की मेमोरी की सीमा तक) और उनमें कितने भी आयाम हो सकते हैं।

कुछ ऐरे टाइप के विशेष नाम होते हैं (जो लीनियर अलजेब्रा से लिए गए हैं)। 1-आयामी ऐरे को Vector कहा जाता है और 2-आयामी ऐरे को Matrix। Julia में दोनों Array के सबटाइप हैं।

यह परिचयात्मक कॉन्सेप्ट Vector की बुनियादी बातों पर केंद्रित है। ऊँचे आयामों वाले ऐरे आगे सिलेबस में शामिल किए जाएँगे।

Vector बनाना

Julia में Vector वैल्यू का एक क्रमबद्ध अनुक्रम होता है, जिसे इंडेक्स संख्या से एक्सेस किया जा सकता है।

Vector बनाने का सबसे आसान तरीका है वैल्यू को चौकोर ब्रैकेट में लिखना:

julia> num_vec = [1, 4, 9]
3-element Vector{Int64}:
 1
 4
 9

julia> str_vec = ["arrays", "are", "important"]
3-element Vector{String}:
 "arrays"
 "are"
 "important"

Vector का टाइप हर एलिमेंट के टाइप से मेल खाता है।

तकनीकी रूप से यह एक कॉलम वेक्टर है, लेकिन अगर आप लीनियर अलजेब्रा से परिचित नहीं हैं तो अभी इसे छोड़ दीजिए। बहुआयामी ऐरे कॉन्सेप्ट के बाद यह और स्पष्ट लगेगा।

तो क्या Vector के सभी एलिमेंट एक ही टाइप के होने चाहिए?

एक तरह से हाँ, और अगर आपको सबसे अच्छा प्रदर्शन चाहिए तो इसी का लक्ष्य रखने की सलाह दी जाती है। लेकिन ज़रूरत पड़ने पर Julia Any टाइप का उपयोग करके इस सीमा को पार कर सकती है:

julia> mixed_vector = [1, "str", 'c']
3-element Vector{Any}:
 1
  "str"
  'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)

खाली Vector बनाते समय Julia डिफॉल्ट रूप से एलिमेंट टाइप Any लेती है, लेकिन खाली ऐरे पर मनचाहा एलिमेंट टाइप लिखकर इसे और विशिष्ट रूप से परिभाषित किया जा सकता है।

julia> empty_vec = []
Any[]

julia> empty_int_vec = Int64[]
Int64[]

पहले से भरे Vector

बहुत आम है कि शुरुआत सभी वैल्यू 0 या सभी वैल्यू 1 वाले वेक्टर से की जाए। इनके लिए ऐसे फंक्शन हैं जिनके नाम (आश्चर्य की बात नहीं) zeros() और ones() हैं, जो पैरामीटर के रूप में वेक्टर का आकार लेते हैं। डिफॉल्ट टाइप Float64 होता है, लेकिन ज़रूरत हो तो दूसरे संख्यात्मक टाइप भी बताए जा सकते हैं।

इसी तरह, fill() फंक्शन दो चीज़ें लेता है: एक वैल्यू जिसे दोहराना है, और वेक्टर का मनचाहा आकार।

julia> zeros(3)
3-element Vector{Float64}:
 0.0
 0.0
 0.0

julia> ones(3)
3-element Vector{Float64}:
 1.0
 1.0
 1.0

julia> ones(Int64, 3)
3-element Vector{Int64}:
 1
 1
 1

julia> fill(42, 3)
3-element Vector{Int64}:
 42
 42
 42

और भी कई विकल्प हैं: मैनुअल देखिए।

कृपया यह नियम पढ़िए और याद रखिए:

• डिफॉल्ट रूप से Julia में इंडेक्सिंग 1 से शुरू होती है, 0 से नहीं।

जो लोग दूसरी डेटा साइंस भाषाएँ (R, Matlab, Fortran...) इस्तेमाल कर चुके हैं, उनके लिए यह जाना-पहचाना है, लेकिन C जैसी भाषाओं की पृष्ठभूमि वाले कंप्यूटर वैज्ञानिकों को यह चौंकाने वाला लग सकता है।

बाकी सब में इंडेक्स वैसे ही काम करते हैं जैसा आप अंदाज़ा लगाएँगे: बस उन्हें चौकोर ब्रैकेट में लिख दीजिए:

squares = [0, 1, 4, 9, 16]
squares[1]  # 0
squares[3]  # 4
squares[begin]  # 0 ("begin" is synonym for 1)
squares[end]  # 16 ("end" is synonym for length(squares))

end से इंडेक्स करने की सुविधा (जो बहुत उपयोगी है) और begin से करने की सुविधा (जो शायद नहीं है) पर ध्यान दीजिए।

Python प्रोग्रामर शायद ऋणात्मक इंडेक्स के बारे में सोच रहे हों। सोचिए मत: ये Julia में नहीं हैं, और ये BoundsError देंगे, जैसे कि 1 से छोटा या length(squares) से बड़ा कोई भी इंडेक्स देगा।

Vector पर काम

Julia में Vector म्यूटेबल होते हैं: हम अलग-अलग सेल की सामग्री बदल सकते हैं।

julia> vals = [1, 3, 5, 7]
4-element Vector{Int64}:
 1
 3
 5
 7

julia> vals[2] = 4  # reassign the value of this element
4

# Only the value at position 2 changes:
julia> vals
4-element Vector{Int64}:
 1
 4
 5
 7

वेक्टर पर काम करने के लिए कई फंक्शन उपलब्ध हैं, हालाँकि Julia का डॉक्युमेंटेशन उन्हें वेक्टर के बजाय "कलेक्शन" के लिए सामान्य बनाता है।

ध्यान दीजिए कि परंपरा के अनुसार, जो फंक्शन अपने इनपुट को बदलते हैं उनके नाम में ! होता है। कंपाइलर इसे लागू नहीं करता, लेकिन Julia की दुनिया में यह बहुत पक्की परंपरा है।

ये कुछ उपयोगी फंक्शन हैं:

• वेक्टर के अंत में वैल्यू जोड़ने के लिए push!() का उपयोग कीजिए।
• अंतिम वैल्यू हटाने के लिए pop!() का उपयोग कीजिए।
• वेक्टर के शुरू पर काम करने के लिए संबंधित फंक्शन pushfirst!() और popfirst!() हैं।
• किसी भी जगह पर एलिमेंट डालने या हटाने के लिए insert!() और deleteat!() हैं।

julia> vals = [1, 3]
2-element Vector{Int64}:
 1
 3

julia> push!(vals, 5, 6)  # can add multiple values
4-element Vector{Int64}:
 1
 3
 5
 6

julia> pop!(vals)  # mutates vals, return popped value
6

julia> vals
3-element Vector{Int64}:
 1
 3
 5

कॉन्कैटिनेशन

वेक्टर के लिए कॉन्कैटिनेशन काफी आसान है, हालाँकि मैनुअल पर एक नज़र डालने से पता चलता है कि बहुआयामी ऐरे पर विचार करते समय आगे जटिलताएँ छिपी हैं।

append!() फंक्शन इनपुट के रूप में कई वेक्टरों और अकेले एलिमेंट का मेल ले सकता है।

julia> append!([1, 2], [3, 4], [-1, -2], 15)
7-element Vector{Int64}:
  1
  2
  3
  4
 -1
 -2
 15