Julia Language
Tablice

Składnia

• [1,2,3]
• [1 2 3]
• [1 2 3; 4 5 6; 7 8 9]
• Tablica (typ, przyciemnienie ...)
• te (typ, przyciemnienia ...)
• zera (typ, przyciemnienia ...)
• trues (typ, ściemnienia ...)
• falses (typ, przyciemnienia ...)
• push! (A, x)
• pop! (A)
• unshift! (A, x)
• shift! (A)

Parametry

Ręczna konstrukcja prostej tablicy

Można ręcznie zainicjować tablicę Julii, używając składni nawiasów kwadratowych:

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

Pierwszy wiersz po poleceniu pokazuje rozmiar utworzonej tablicy. Pokazuje także rodzaj jego elementów i ich wymiarowość (w tym przypadku Int64 i 1 , odpowiednio). W przypadku tablicy dwuwymiarowej można użyć spacji i średnika:

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

Aby utworzyć niezainicjowaną tablicę, możesz użyć metody Array(type, dims...) :

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

Funkcje zeros , ones , trues , falses mają metody, które zachowują się dokładnie tak samo, ale tworzą tablice pełne odpowiednio 0.0 , 1.0 , True lub False .

Typy tablic

W Julii tablice mają typy sparametryzowane przez dwie zmienne: typ T i wymiarowość D ( Array{T, D} ). W przypadku jednowymiarowej tablicy liczb całkowitych typ to:

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

Jeśli macierz jest macierzą dwuwymiarową, D równa się 2:

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

Typ elementu może być również typem abstrakcyjnym:

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

Tutaj Any (typ abstrakcyjny) to typ wynikowej tablicy.

Określanie typów podczas tworzenia tablic

Kiedy tworzymy tablicę w sposób opisany powyżej, Julia dołoży wszelkich starań, aby wywnioskować właściwy typ, jaki możemy chcieć. We wstępnych przykładach powyżej wprowadziliśmy dane wejściowe, które wyglądały jak liczby całkowite, więc Julia domyślnie wprowadziła domyślny typ Int64 . Czasami jednak możemy chcieć być bardziej konkretni. W poniższym przykładzie określamy, że chcemy, aby typ był Int8 :

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

Możemy nawet określić typ jako coś takiego jak Float64 , nawet jeśli napiszemy dane wejściowe w sposób, który w przeciwnym razie mógłby być interpretowany jako liczba całkowita (np. Zapis 1 zamiast 1.0 ). na przykład

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

Tablice tablic - właściwości i konstrukcja

W Julii możesz mieć macierz, która przechowuje inne obiekty typu macierzowego. Rozważ następujące przykłady inicjowania różnych typów tablic:

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

Rozważmy na przykład różnice między C i 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) tworzy obiekt typu Array{Float64,1} . Ponieważ jedyną specyfikacją dla elementów C jest to, że są to tablice z elementami typu Float64, mieści się to w definicji C Ale dla D określono, że elementy muszą być tablicami dwuwymiarowymi. Zatem, ponieważ rand(3) nie tworzy tablicy dwuwymiarowej, nie możemy jej użyć do przypisania wartości do określonego elementu D

Określ określone wymiary tablic w obrębie tablicy

Chociaż możemy określić, że tablica będzie przechowywać elementy typu Array, i możemy określić, że np. Te elementy powinny być tablicami dwuwymiarowymi, nie możemy bezpośrednio określić wymiarów tych elementów. Np. Nie możemy bezpośrednio określić, że chcemy mieć tablicę zawierającą 10 tablic, z których każda ma wartość 5,5. Widzimy to ze składni funkcji Array() użytej do skonstruowania Array:

Array {T} (ściemnia)

konstruuje niezainicjowaną gęstą tablicę z elementem typu T. dims może być krotką lub szeregiem liczb całkowitych. Składnia Array (T, dims) jest również dostępna, ale przestarzała.

Typ tablicy w Julii obejmuje liczbę wymiarów, ale nie rozmiar tych wymiarów. Dlatego w tej składni nie ma miejsca na precyzyjne określenie wymiarów. Niemniej jednak podobny efekt można uzyskać, używając zrozumienia tablicy:

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

Uwaga: ta dokumentacja odzwierciedla następującą odpowiedź SO

Zainicjuj pustą tablicę

Możemy użyć [] aby stworzyć pustą macierz w Julii. Najprostszym przykładem byłoby:

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

Tablice typu Any zazwyczaj nie będą działały tak dobrze, jak tablice określonego typu. Możemy na przykład użyć:

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}

Zobacz Inicjowanie pustej tablicy krotek w Julii, aby zapoznać się ze źródłem ostatniego przykładu.

Wektory

Wektory są jednowymiarowymi tablicami i obsługują głównie ten sam interfejs, co ich wielowymiarowe odpowiedniki. Jednak wektory obsługują również dodatkowe operacje.

Najpierw zauważ, że Vector{T} gdzie T jest jakimś typem, oznacza to samo, co Array{T,1} .

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

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

Odczytuje się Array{Int64,1} jako „jednowymiarową tablicę Int64 ”.

W przeciwieństwie do tablic wielowymiarowych można zmieniać rozmiar wektorów. Elementy można dodawać lub usuwać z przodu lub z tyłu wektora. Wszystkie te operacje są stale amortyzowane .

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

Zgodnie z konwencją każda z tych funkcji działa push! pop! , unshift! i shift! kończy się wykrzyknikiem, wskazując, że mutują argumentację. Funkcje push! i unshift! zwraca tablicę, podczas gdy pop! i shift! zwróć usunięty element.

Powiązanie

Często przydatne jest budowanie matryc z mniejszych matryc.

Konkatenacja pozioma

Macierze (i wektory, które są traktowane jako wektory kolumnowe) mogą być konkatenowane w poziomie za pomocą funkcji 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

Dostępna jest wygodna składnia wykorzystująca notację w nawiasach kwadratowych i spacje:

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

Ta notacja może ściśle pasować do notacji dla matryc blokowych używanych w algebrze liniowej:

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

Zauważ, że nie można konkatenować w poziomie pojedynczej macierzy przy użyciu składni [] , ponieważ zamiast tego utworzyłby wektor jednoelementowy macierzy:

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

Łączenie pionowe

Połączenie pionowe jest podobne do połączenia poziomego, ale w kierunku pionowym. Funkcją pionowej konkatenacji jest 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

Alternatywnie, nawiasy kwadratowe mogą być używane z średnikami ; jako separator:

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

Wektory można również łączyć w pionie; wynikiem jest wektor:

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

Konkatenację poziomą i pionową można łączyć:

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