Julia Language
arrays

Syntaxis

• [1,2,3]
• [1 2 3]
• [1 2 3; 4 5 6; 7 8 9]
• Matrix (type, dimmen ...)
• enen (type, dimmen ...)
• nullen (type, dimmen ...)
• trues (type, dimmen ...)
• vals (type, dimmen ...)
• push! (A, x)
• pop! (A)
• unshift! (A, x)
• shift! (A)

parameters

Handmatige constructie van een eenvoudige reeks

Je kunt een Julia-array handmatig initialiseren met behulp van de syntaxis van vierkante haken:

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

De eerste regel na de opdracht toont de grootte van de array die u hebt gemaakt. Het toont ook het type elementen en de dimensionaliteit ervan (in dit geval Int64 en 1 , respectievelijk). Voor een tweedimensionale array kunt u spaties en puntkomma's gebruiken:

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

Om een niet-geïnitialiseerde array te maken, kunt u de methode Array(type, dims...) gebruiken:

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

De functies zeros , ones , trues , falses hebben methoden die zich precies hetzelfde gedragen, maar arrays produceren met respectievelijk 0.0 , 1.0 , True of False .

Matrixtypen

In Julia hebben arrays typen die worden geparametriseerd door twee variabelen: een type T en een dimensionaliteit D ( Array{T, D} ). Voor een 1-dimensionale reeks gehele getallen is het type:

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

Als de matrix een tweedimensionale matrix is, is D gelijk aan 2:

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

Het elementtype kan ook abstract zijn:

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

Hier is Any (een abstract type) het type van de resulterende array.

Typen opgeven bij het maken van arrays

Wanneer we op de hierboven beschreven manier een array maken, doet Julia zijn best om het juiste type af te leiden dat we mogelijk willen. In de eerste voorbeelden hierboven hebben we invoer ingevoerd die eruit zag als gehele getallen, en daarom heeft Julia standaard het standaard Int64 type gebruikt. Soms willen we echter specifieker zijn. In het volgende voorbeeld geven we aan dat we het type Int8 :

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

We zouden het type zelfs kunnen specificeren als iets zoals Float64 , zelfs als we de ingangen op een manier schrijven die anders standaard als gehele getallen kan worden geïnterpreteerd (bijvoorbeeld 1 plaats van 1.0 ). bv

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

Arrays of Arrays - Properties and Construction

In Julia kunt u een array hebben die andere objecten van het arraytype bevat. Overweeg de volgende voorbeelden van het initialiseren van verschillende soorten 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

Beschouw bijvoorbeeld de verschillen tussen C en D hier:

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) produceert een object van het type Array{Float64,1} . Aangezien de enige specificatie voor de elementen van C is dat dit Arrays zijn met elementen van het type Float64, past dit binnen de definitie van C Maar voor D hebben we aangegeven dat de elementen tweedimensionale reeksen moeten zijn. Aangezien rand(3) dus geen tweedimensionale array produceert, kunnen we deze niet gebruiken om een waarde toe te wijzen aan een specifiek element van D

Specificeer specifieke afmetingen van arrays binnen een array

Hoewel we kunnen specificeren dat een array elementen van het type Array zal bevatten, en we kunnen specificeren dat, bijvoorbeeld, die elementen 2-dimensionale arrays moeten zijn, kunnen we de dimensies van die elementen niet direct specificeren. We kunnen bijvoorbeeld niet direct aangeven dat we een array willen met 10 arrays, die elk 5,5 zijn. We kunnen dit zien aan de syntaxis voor de functie Array() wordt gebruikt om een array te construeren:

Array {T} (gedimd)

construeert een niet-geïnitialiseerde dichte array met elementtype T. dims kan een tuple of een reeks integer-argumenten zijn. De syntaxis Array (T, dims) is ook beschikbaar, maar is verouderd.

Het type Array in Julia omvat het aantal dimensies, maar niet de grootte van die dimensies. Er is dus geen plaats in deze syntaxis om de exacte afmetingen op te geven. Niettemin kan een soortgelijk effect worden bereikt met behulp van een Array-begrip:

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

Opmerking: deze documentatie weerspiegelt het volgende SO Answer

Initialiseer een lege array

We kunnen de [] gebruiken om een lege array in Julia te maken. Het eenvoudigste voorbeeld zou zijn:

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

Arrays van het type Any zullen over het algemeen niet zo goed presteren als die met een bepaald type. Zo kunnen we bijvoorbeeld gebruiken:

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}

Zie Een lege array van Tuples initialiseren in Julia voor de bron van het laatste voorbeeld.

vectoren

Vectoren zijn eendimensionale arrays en ondersteunen meestal dezelfde interface als hun multidimensionale tegenhangers. Vectoren ondersteunen echter ook aanvullende bewerkingen.

Merk eerst op dat Vector{T} waarbij T een type is hetzelfde betekent als Array{T,1} .

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

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

Men leest Array{Int64,1} als "eendimensionale array van Int64 ".

In tegenstelling tot multidimensionale arrays, kunnen vectoren worden aangepast. Elementen kunnen aan de voor- of achterkant van de vector worden toegevoegd of verwijderd. Deze operaties zijn allemaal constante geamortiseerde tijd .

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

Zoals gebruikelijk, push! elk van deze functies push! , pop! , niet unshift! en shift! eindigt op een uitroepteken om aan te geven dat ze hun argument muteren. De functies push! en unshift! geeft de array terug, terwijl pop! en shift! retourneer het element verwijderd.

Aaneenschakeling

Het is vaak handig om matrices te maken van kleinere matrices.

Horizontale aaneenschakeling

Matrices (en vectoren, die worden behandeld als kolomvectoren) kunnen horizontaal worden samengevoegd met behulp van de hcat functie.

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

Er is gemakssyntaxis beschikbaar, met behulp van vierkante haakjesnotatie en spaties:

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

Deze notatie kan nauw overeenkomen met de notatie voor blokmatrices die worden gebruikt in lineaire algebra:

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

Merk op dat je een enkele matrix niet horizontaal kunt samenvoegen met behulp van de syntaxis [] , omdat dat in plaats daarvan een vectormatrix met één element zou creëren:

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

Verticale aaneenschakeling

Verticale samenvoeging is als horizontale samenvoeging, maar in verticale richting. De functie voor verticale samenvoeging is 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

Als alternatief kan vierkante haakjesnotatie worden gebruikt met puntkomma's ; als het scheidingsteken:

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

Vectoren kunnen ook verticaal worden samengevoegd; het resultaat is een vector:

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

Horizontale en verticale samenvoeging kunnen worden gecombineerd:

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