Julia Language
Arrays

Syntax

• [1,2,3]
• [1 2 3]
• [1 2 3; 4 5 6; 7 8 9]
• Array (Typ, Dimensionen ...)
• one (typ, dims ...)
• Nullen (Typ, Dims ...)
• trues (typ, dims ...)
• Falses (Typ, Dims ...)
• schieben! (A, x)
• Pop! (A)
• nicht verschieben! (A, x)
• Schicht! (A)

Parameter

Manueller Aufbau eines einfachen Arrays

Man kann ein Julia-Array von Hand mit der eckigen Klammer-Syntax initialisieren:

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

Die erste Zeile nach dem Befehl zeigt die Größe des von Ihnen erstellten Arrays. Es zeigt auch die Art seiner Elemente und ihre Dimensionalität (in diesem Fall Int64 bzw. 1 ). Für ein zweidimensionales Array können Sie Leerzeichen und Semikolon verwenden:

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

Um ein nicht initialisiertes Array zu erstellen, können Sie die Array(type, dims...) -Methode verwenden:

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

Die Funktionen zeros , ones , trues , falses weisen Methoden auf, die sich genau gleich verhalten, aber Arrays erzeugen, die mit 0.0 , 1.0 , True oder False falses sind.

Array-Typen

In Julia haben Arrays Typen, die durch zwei Variablen parametrisiert werden: einen Typ T und eine Dimensionalität D ( Array{T, D} ). Für ein 1-dimensionales Array von Ganzzahlen lautet der Typ:

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

Wenn das Array eine 2-dimensionale Matrix ist, ist D gleich 2:

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

Der Elementtyp kann auch abstrakt sein:

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 ist Any (ein abstrakter Typ) der Typ des resultierenden Arrays.

Festlegen von Typen beim Erstellen von Arrays

Wenn wir ein Array auf die oben beschriebene Weise erstellen, versucht Julia, den richtigen Typ zu ermitteln, den wir möglicherweise benötigen. In den ersten Beispielen oben haben wir Eingaben eingegeben, die wie Ganzzahlen aussahen, und so war Julia standardmäßig der Standardtyp Int64 . Manchmal möchten wir jedoch genauer sein. Im folgenden Beispiel geben wir an, dass der Typ statt Int8 :

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

Wir können den Typ sogar als etwas wie Float64 , selbst wenn wir die Eingaben auf eine Weise schreiben, die ansonsten standardmäßig als ganze Zahlen interpretiert werden könnte (z. B. 1 statt 1.0 ). z.B

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

Arrays von Arrays - Eigenschaften und Aufbau

In Julia können Sie ein Array haben, das andere Array-Typobjekte enthält. Beachten Sie die folgenden Beispiele für das Initialisieren verschiedener Arten von 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

Betrachten Sie zum Beispiel die Unterschiede zwischen C und 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) erzeugt ein Objekt vom Typ Array{Float64,1} . Da die einzigen Elemente für die Elemente von C sind, dass sie Arrays mit Elementen vom Typ Float64 sind, passt dies in die Definition von C Für D wir jedoch angegeben, dass die Elemente zweidimensionale Arrays sein müssen. Da rand(3) kein zweidimensionales Array erzeugt, können wir es daher nicht verwenden, um einem bestimmten Element von D einen Wert zuzuweisen

Spezifizieren Sie spezifische Abmessungen von Arrays innerhalb eines Arrays

Obwohl wir angeben können, dass ein Array Elemente vom Typ Array aufnehmen soll, und wir können angeben, dass diese Elemente z. B. zweidimensionale Arrays sein sollen, können wir die Dimensionen dieser Elemente nicht direkt angeben. Wir können beispielsweise nicht direkt angeben, dass ein Array 10 Arrays enthalten soll, von denen jedes 5,5 ist. Wir können dies anhand der Syntax für die Array() Funktion sehen, die zum Erstellen eines Arrays verwendet wird:

Array {T} (Dims)

Konstruiert ein nicht initialisiertes dichtes Array mit dem Elementtyp T. dims kann ein Tupel oder eine Reihe von ganzzahligen Argumenten sein. Das Syntax-Array (T, dims) ist ebenfalls verfügbar, aber veraltet.

Der Typ eines Arrays in Julia umfasst die Anzahl der Dimensionen, nicht jedoch die Größe dieser Dimensionen. Daher gibt es in dieser Syntax keinen Platz, um die genauen Abmessungen anzugeben. Ein ähnlicher Effekt könnte jedoch mit einem Array-Verständnis erzielt werden:

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

Hinweis: Diese Dokumentation spiegelt die folgende SO-Antwort wider

Initialisieren Sie ein leeres Array

Wir können das [] , um ein leeres Array in Julia zu erstellen. Das einfachste Beispiel wäre:

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

Arrays vom Typ Any funktionieren im Allgemeinen nicht so gut wie Arrays mit einem angegebenen Typ. So können wir zum Beispiel verwenden:

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}

Die Quelle des letzten Beispiels finden Sie unter Ein leeres Array von Tupeln in Julia initialisieren .

Vektoren

Vektoren sind eindimensionale Arrays und unterstützen meistens die gleiche Schnittstelle wie ihre mehrdimensionalen Gegenstücke. Vektoren unterstützen jedoch auch zusätzliche Operationen.

Beachten Sie zunächst, dass Vector{T} wobei T ein Typ ist, mit Array{T,1} identisch ist.

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

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

Man liest Array{Int64,1} als "eindimensionales Array von Int64 ".

Im Gegensatz zu mehrdimensionalen Arrays kann die Größe von Vektoren geändert werden. Elemente können vor oder hinter dem Vektor hinzugefügt oder entfernt werden. Diese Vorgänge sind alle konstant amortisiert .

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

Wie üblich, jede dieser Funktionen push! pop! , nicht unshift! und shift! endet mit einem Ausrufezeichen, um anzuzeigen, dass sie ihre Argumente mutieren. Die Funktionen push! und nicht unshift! das Array zurückgeben, während pop! und shift! das entfernte Element zurückgeben

Verkettung

Es ist oft nützlich, Matrizen aus kleineren Matrizen zu erstellen.

Horizontale Verkettung

Matrizen (und Vektoren, die als Spaltenvektoren behandelt werden) können mit der hcat Funktion horizontal verkettet werden.

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

Es ist eine bequeme Syntax verfügbar, die die eckige Klammer und Leerzeichen verwendet:

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

Diese Notation kann der Notation für Blockmatrizen, die in der linearen Algebra verwendet werden, sehr ähnlich sein:

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

Beachten Sie, dass Sie eine einzelne Matrix nicht horizontal mit der [] -Syntax verketten können, da dies einen Ein-Element-Vektor von Matrizen erzeugen würde:

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

Vertikale Verkettung

Vertikale Verkettung ist wie horizontale Verkettung, jedoch in vertikaler Richtung. Die Funktion für die vertikale Verkettung ist 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

Alternativ kann die Notation mit eckigen Klammern auch mit Semikolons verwendet werden ; als Trennzeichen:

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

Vektoren können auch vertikal verkettet werden. Das Ergebnis ist ein 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

Horizontale und vertikale Verkettung können kombiniert werden:

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