Julia Language
Arrays

वाक्य - विन्यास

• [1,2,3]
• [१ २ ३]
• [१ २ ३; 4 5 6; 7 ९]
• सरणी (प्रकार, मंद ...)
• वाले (प्रकार, dims ...)
• शून्य (प्रकार, dims ...)
• ट्रूज़ (टाइप, डीम्स ...)
• फ़ल्स (प्रकार, मंद ...)
• धक्का! (ए, एक्स)
• पॉप! (ए)
• अनशिफ्ट! (ए, एक्स)
• शिफ्ट! (ए)

पैरामीटर

एक साधारण सरणी का मैनुअल निर्माण

वर्ग-कोष्ठक सिंटैक्स का उपयोग करके, हाथ से जूलिया सरणी को आरंभीकृत कर सकते हैं:

julia> x = [1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

कमांड के बाद की पहली पंक्ति आपके द्वारा बनाए गए सरणी के आकार को दिखाती है। यह इसके तत्वों के प्रकार और इसकी गतिशीलता को भी दर्शाता है (उदाहरण के लिए Int64 और 1 , इस मामले में)। द्वि-आयामी सरणी के लिए, आप रिक्त स्थान और अर्ध-कोलन का उपयोग कर सकते हैं:

julia> x = [1 2 3; 4 5 6]
2x3 Array{Int64,2}:
 1  2  3
 4  5  6

एक असिंचित सरणी बनाने के लिए, आप Array(type, dims...) विधि का उपयोग कर सकते हैं:

julia> Array(Int64, 3, 3)
3x3 Array{Int64,2}:
 0  0  0
 0  0  0
 0  0  0

कार्यों zeros , ones , trues , falses तरीकों कि ठीक उसी तरह से व्यवहार करते हैं, लेकिन उत्पादन सरणियों से भरा है 0.0 , 1.0 , True या False , क्रमशः।

सरणी प्रकार

जूलिया में, अर्रेज़ के प्रकार दो प्रकार के होते हैं: एक प्रकार T और एक आयामी D ( Array{T, D} )। पूर्णांक के 1-आयामी सरणी के लिए, प्रकार है:

julia> x = [1, 2, 3];
julia> typeof(x)
Array{Int64, 1}

यदि सरणी 2-आयामी मैट्रिक्स है, तो D 2 के बराबर है:

julia> x = [1 2 3; 4 5 6; 7 8 9]
julia> typeof(x)
Array{Int64, 2}

तत्व प्रकार भी सार प्रकार हो सकते हैं:

julia> x = [1 2 3; 4 5 "6"; 7 8 9]
3x3 Array{Any,2}:
 1  2  3   
 4  5 "6"
 7  8  9

यहाँ Any (एक अमूर्त प्रकार) परिणामी सरणी का प्रकार है।

Arrays बनाते समय निर्दिष्ट प्रकार

जब हम ऊपर वर्णित तरीके से एक ऐरे बनाते हैं, तो जूलिया उचित प्रकार का अनुमान लगाने की पूरी कोशिश करेगी जो हम चाहते हैं। ऊपर के शुरुआती उदाहरणों में, हमने ऐसे इनपुट दर्ज किए जो पूर्णांक की तरह दिखते थे, और इसलिए जूलिया डिफ़ॉल्ट Int64 प्रकार में डिफ़ॉल्ट हो गया। हालांकि, कई बार हम अधिक विशिष्ट होना चाहते हैं। निम्नलिखित उदाहरण में, हम निर्दिष्ट करते हैं कि हम चाहते हैं कि टाइप Int8 बजाय Int8 :

x1 = Int8[1 2 3; 4 5 6; 7 8 9]
typeof(x1)  ## Array{Int8,2}

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

x2 = Float64[1 2 3; 4 5 6; 7 8 9]

Arrays के Arrays - गुण और निर्माण

जूलिया में, आपके पास एक एरे हो सकता है जो अन्य ऐरे प्रकार की वस्तुओं को रखता है। विभिन्न प्रकार के एरे को शुरू करने के निम्नलिखित उदाहरणों पर विचार करें:

A = Array{Float64}(10,10)  # A single Array, dimensions 10 by 10, of Float64 type objects

B = Array{Array}(10,10,10)  # A 10 by 10 by 10 Array.  Each element is an Array of unspecified type and dimension.

C = Array{Array{Float64}}(10)  ## A length 10, one-dimensional Array.  Each element is an Array of Float64 type objects but unspecified dimensions

D = Array{Array{Float64, 2}}(10)  ## A length 10, one-dimensional Array.  Each element of is an 2 dimensional array of Float 64 objects

उदाहरण के लिए, यहाँ C और D के बीच के अंतर पर विचार करें:

julia> C[1] = rand(3)
3-element Array{Float64,1}:
 0.604771
 0.985604
 0.166444

julia> D[1] = rand(3)
ERROR: MethodError: 

rand(3) प्रकार की एक वस्तु पैदा करता है Array{Float64,1} । चूंकि C के तत्वों के लिए एकमात्र विनिर्देश यह है कि वे फ्लोट64 के तत्वों के साथ एरे हैं, यह C की परिभाषा के भीतर फिट बैठता C । लेकिन, D हमने निर्दिष्ट किया कि तत्वों को 2 आयामी Arrays होना चाहिए। इस प्रकार, चूंकि rand(3) एक 2 आयामी सरणी का उत्पादन नहीं करता है, हम इसका उपयोग D एक विशिष्ट तत्व के लिए मान प्रदान करने के लिए नहीं कर सकते हैं

एक सरणी के भीतर ऐरे के विशिष्ट आयाम निर्दिष्ट करें

यद्यपि हम यह निर्दिष्ट कर सकते हैं कि एक ऐरे ऐसे तत्वों को धारण करेगा, जो टाइप एरे के हैं, और हम यह निर्दिष्ट कर सकते हैं, जैसे कि उन तत्वों को 2-आयामी एरे होना चाहिए, हम सीधे उन तत्वों के डिमैनों को निर्दिष्ट नहीं कर सकते हैं। उदाहरण के लिए, हम सीधे यह नहीं बता सकते हैं कि हम एक एरियर चाहते हैं जिसमें 10 एरेज़ हैं, जिनमें से प्रत्येक 5,5 है। हम Array() के निर्माण के लिए उपयोग किए गए Array() फ़ंक्शन के सिंटैक्स से इसे देख सकते हैं:

सरणी {टी} (मंद)

तत्व प्रकार टी। डिम के साथ एक असमानकृत घने सरणी का निर्माण टपल या पूर्णांक तर्कों की एक श्रृंखला हो सकती है। वाक्य-विन्यास सरणी (T, dims) भी उपलब्ध है, लेकिन पदावनत।

जूलिया में एक ऐरे का प्रकार आयामों की संख्या को शामिल करता है, लेकिन उन आयामों के आकार को नहीं। इस प्रकार, सटीक आयामों को निर्दिष्ट करने के लिए इस सिंटैक्स में कोई जगह नहीं है। फिर भी, एक समान प्रभाव एक सरणी समझ का उपयोग करके प्राप्त किया जा सकता है:

E = [Array{Float64}(5,5) for idx in 1:10]

नोट: यह प्रलेखन निम्नलिखित एसओ उत्तर को दर्शाता है

एक खाली ऐरे को प्रारंभ करें

हम जूलिया में एक खाली ऐरे बनाने के लिए [] का उपयोग कर सकते हैं। सबसे सरल उदाहरण होगा:

A = [] # 0-element Array{Any,1}

प्रकार की सरणियाँ Any आमतौर पर एक निर्दिष्ट प्रकार के साथ प्रदर्शन नहीं करेगा। इस प्रकार, उदाहरण के लिए, हम उपयोग कर सकते हैं:

B = Float64[]  ## 0-element Array{Float64,1}
C = Array{Float64}[]  ## 0-element Array{Array{Float64,N},1}
D = Tuple{Int, Int}[] ## 0-element Array{Tuple{Int64,Int64},1}

अंतिम उदाहरण के स्रोत के लिए जूलिया में ट्यूपल्स के एक खाली ऐरे को प्रारंभिक देखें।

वैक्टर

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

सबसे पहले, ध्यान दें कि Vector{T} जहां T कुछ प्रकार का है, Array{T,1} ।

julia> Vector{Int}
Array{Int64,1}

julia> Vector{Float64}
Array{Float64,1}

एक Array{Int64,1} को " Int64 एक आयामी सरणी" के रूप में पढ़ता है।

बहु-आयामी सरणियों के विपरीत, वैक्टर का आकार बदला जा सकता है। तत्वों को वेक्टर के सामने या पीछे से जोड़ा या हटाया जा सकता है। ये ऑपरेशन सभी निरंतर परिशोधित समय हैं ।

julia> A = [1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> push!(A, 4)
4-element Array{Int64,1}:
 1
 2
 3
 4

julia> A
4-element Array{Int64,1}:
 1
 2
 3
 4

julia> pop!(A)
4

julia> A
3-element Array{Int64,1}:
 1
 2
 3

julia> unshift!(A, 0)
4-element Array{Int64,1}:
 0
 1
 2
 3

julia> A
4-element Array{Int64,1}:
 0
 1
 2
 3

julia> shift!(A)
0

julia> A
3-element Array{Int64,1}:
 1
 2
 3

सम्मेलन के रूप में, इन कार्यों में से प्रत्येक push! , pop! , unshift! , और shift! एक विस्मयादिबोधक चिह्न में यह इंगित करने के लिए समाप्त होता है कि वे अपने तर्क को म्यूट कर रहे हैं। कार्य push! और unshift! सरणी लौटाएं, जबकि pop! और shift! हटाए गए तत्व को वापस करें।

कड़ी

अक्सर छोटे मैट्रिसेस से मैट्रिसेस का निर्माण करना उपयोगी होता है।

क्षैतिज समास

मेट्रिस (और वैक्टर, जिन्हें कॉलम वैक्टर के रूप में माना जाता है) को hcat फ़ंक्शन का उपयोग करके क्षैतिज रूप से समतल किया जा सकता है।

julia> hcat([1 2; 3 4], [5 6 7; 8 9 10], [11, 12])
2×6 Array{Int64,2}:
 1  2  5  6   7  11
 3  4  8  9  10  12

चौकोर ब्रैकेट अंकन और रिक्त स्थान का उपयोग करके सुविधा सिंटैक्स उपलब्ध है:

julia> [[1 2; 3 4] [5 6 7; 8 9 10] [11, 12]]
2×6 Array{Int64,2}:
 1  2  5  6   7  11
 3  4  8  9  10  12

यह संकेतन रेखीय बीजगणित में प्रयुक्त ब्लॉक मेट्रिक्स के लिए संकेतन से निकटता से मेल खा सकता है:

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> B = [5 6; 7 8]
2×2 Array{Int64,2}:
 5  6
 7  8

julia> [A B]
2×4 Array{Int64,2}:
 1  2  5  6
 3  4  7  8

ध्यान दें कि आप [] सिंटैक्स का उपयोग करके एक भी मैट्रिक्स को क्षैतिज रूप से समतल नहीं कर सकते हैं, क्योंकि इससे मैट्रीस के एक-तत्व वेक्टर का निर्माण होगा:

julia> [A]
1-element Array{Array{Int64,2},1}:
 [1 2; 3 4]

कार्यक्षेत्र समास

ऊर्ध्वाधर संघनन क्षैतिज संघात की तरह है, लेकिन ऊर्ध्वाधर दिशा में। ऊर्ध्वाधर vcat लिए कार्य vcat ।

julia> vcat([1 2; 3 4], [5 6; 7 8; 9 10], [11 12])
6×2 Array{Int64,2}:
  1   2
  3   4
  5   6
  7   8
  9  10
 11  12

वैकल्पिक रूप से, वर्ग ब्रैकेट संकेतन का उपयोग अर्धविराम के साथ किया जा सकता है ; परिसीमनकर्ता के रूप में:

julia> [[1 2; 3 4]; [5 6; 7 8; 9 10]; [11 12]]
6×2 Array{Int64,2}:
  1   2
  3   4
  5   6
  7   8
  9  10
 11  12

क्षेत्रों को लंबवत रूप से समतल किया जा सकता है; परिणाम एक वेक्टर है:

julia> A = [1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> B = [4, 5]
2-element Array{Int64,1}:
 4
 5

julia> [A; B]
5-element Array{Int64,1}:
 1
 2
 3
 4
 5

क्षैतिज और ऊर्ध्वाधर संयोजन को जोड़ा जा सकता है:

julia> A = [1 2
            3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> B = [5 6 7]
1×3 Array{Int64,2}:
 5  6  7

julia> C = [8, 9]
2-element Array{Int64,1}:
 8
 9

julia> [A C; B]
3×3 Array{Int64,2}:
 1  2  8
 3  4  9
 5  6  7