Julia Language
arrayer

Syntax

• [1,2,3]
• [1 2 3]
• [1 2 3; 4 5 6; 7 8 9]
• Array (typ, dims ...)
• de (typ, dimmar ...)
• nollor (typ, dimmar ...)
• vapen (typ, dimmar ...)
• förfalskningar (typ, dimmar ...)
• tryck! (A, x)
• pop! (A)
• unshift! (A, x)
• skifta! (A)

parametrar

Manuell konstruktion av en enkel matris

Man kan initiera en Julia-matris för hand med hjälp av syntaxen med fyrkantiga parenteser:

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

Den första raden efter kommandot visar storleken på den matris som du skapade. Den visar också typen av dess element och dess dimensionalitet (i det här fallet Int64 och 1 , repektivt). För en tvådimensionell matris kan du använda mellanslag och halvkolon:

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

För att skapa en oinitialiserad matris kan du använda metoden Array(type, dims...) :

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

Funktionerna zeros , ones , trues , falses har metoder som beter sig på exakt samma sätt, men producerar arrayer fulla av 0.0 , 1.0 , True eller False , respektive.

Arraytyper

I Julia har Arrays typer parametriserade av två variabler: en typ T och en dimensionalitet D ( Array{T, D} ). För en 1-dimensionell matris med heltal är typen:

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

Om matrisen är en tvådimensionell matris, är D lika med 2:

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

Elementtypen kan också vara abstrakta typer:

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

Här är vilken som Any (en abstrakt typ) typen av den resulterande matrisen.

Ange typer när du skapar matriser

När vi skapar en matris på det sätt som beskrivs ovan, kommer Julia att göra sitt bästa för att dra slutsatsen om den rätta typen som vi kanske vill ha. I de ursprungliga exemplen ovan skrev vi inmatningar som såg ut som heltal, och Julia förvandlade därför som standard Int64 typ. Ibland kan vi dock vara mer specifika. I följande exempel anger vi att vi vill att typen ska vara Int8 :

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

Vi kan till och med specificera typen som något som Float64 , även om vi skriver ingångarna på ett sätt som annars kan tolkas som heltal som standard (t.ex. att skriva 1 istället för 1.0 ). t.ex

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

Arrays of Arrays - Egenskaper och konstruktion

I Julia kan du ha en array som innehåller andra array-typobjekt. Tänk på följande exempel på initialisering av olika typer av matriser:

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

Tänk till exempel skillnaderna mellan C och D här:

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) producerar ett objekt av typen Array{Float64,1} . Eftersom den enda specifikationen för elementen i C är att de är Arrays med element av typen Float64, passar detta in i definitionen av C Men för D specificerade vi att elementen måste vara tvådimensionella arrayer. Eftersom rand(3) inte producerar en tvådimensionell matris kan vi inte använda den för att tilldela ett värde till ett specifikt element i D

Ange specifika dimensioner för matriser inom en array

Även om vi kan specificera att en array kommer att innehålla element som är av typen Array, och vi kan specificera att t.ex. dessa element ska vara tvådimensionella arrayer, kan vi inte direkt ange dimensioner för dessa element. Vi kan t.ex. inte direkt specificera att vi vill ha en array som innehåller 10 arrayer, var och en av dem är 5,5. Vi kan se detta från syntaxen för Array() -funktionen som används för att konstruera en Array:

Array {T} (DIMS)

konstruerar en oinitialiserad tät matris med elementtyp T. dims kan vara en tupel eller en serie heltalargument. Syntaxen Array (T, dims) är också tillgänglig, men avskrivs.

Typen av en array i Julia omfattar antalet dimensioner men inte storleken på dessa dimensioner. Det finns således ingen plats i denna syntax för att specificera de exakta dimensionerna. Ändå kan en liknande effekt uppnås med hjälp av en Array-förståelse:

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

Obs: denna dokumentation speglar följande SO-svar

Initiera en tom matris

Vi kan använda [] att skapa en tom matris i Julia. Det enklaste exemplet skulle vara:

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

Matriser av typ Any kommer i allmänhet inte att fungera lika bra som de med en specifik typ. Således kan vi till exempel använda:

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}

Se Initiera ett tomt array av tuples i Julia för källa till sista exemplet.

vektorer

Vektorer är endimensionella matriser och stöder mestadels samma gränssnitt som deras multidimensionella motsvarigheter. Men vektorer stöder också ytterligare operationer.

Tänk först på att Vector{T} där T är någon typ betyder detsamma som Array{T,1} .

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

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

Man läser Array{Int64,1} som "en-dimensionell matris av Int64 ".

Till skillnad från flerdimensionella matriser kan vektorer ändras i storlek. Element kan läggas till eller tas bort från framsidan eller baksidan av vektorn. Dessa operationer är alla konstant amorterad tid .

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

Som är konventionen, push! var och en av dessa funktioner push! , pop! , unshift! och shift! slutar med ett utropstecken för att indikera att de muterar deras argument. Funktionerna push! och unshift! returnera matrisen, medan pop! och shift! returnera elementet bort.

sammanlänkning

Det är ofta användbart att bygga matriser ur mindre matriser.

Horisontell sammankoppling

Matriser (och vektorer, som behandlas som kolonnvektorer) kan sammanfogas horisontellt med hcat funktionen.

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

Det finns tillgänglighetssyntax med fyrkantig notering och mellanslag:

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

Denna notering kan nära matcha notationen för blockmatriser som används i linjär 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

Observera att du inte kan horisontellt sammanfoga en enda matris med [] -syntaxen, eftersom det istället skulle skapa en en-elementvektor av matriser:

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

Vertikal sammankoppling

Vertikal sammankoppling är som horisontell sammankoppling, men i vertikal riktning. Funktionen för vertikal sammankoppling är 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

Alternativt kan kvadratisk konsolnotation användas med semikolon ; som avgränsare:

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

Vektorer kan också vara vertikalt sammansatta; resultatet är en vektor:

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

Horisontell och vertikal sammankoppling kan kombineras:

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