Listing 20
julia> [1,2,3] 3-element Array{Int32,1}: 1 2 3 julia> ["x", 1] 2-element Array{Any,1}: "x" 1 julia> [7, 8, 9][1] 7
An der Ausgabe sehen Sie, dass der Datentyp Array parametrisch ist. Der Inhalt der geschweiften Klammer gibt darüber Auskunft, dass dieses Array nur Elemente vom Typ Int32 enthält und eindimensional ist.
In den Zeilen 6 bis 9 von Listing 20 hat das Array den Typ Any, da es keinen anderen Datentyp gibt, der die Typen String und Int32 zusammenfasst. Es versteht sich fast von selbst: Wenn es um das flotte Bearbeiten großer Datenmengen geht, sollten Sie nach Möglichkeit mit homogenen Arrays und Typen fester Länge arbeiten.
Sie sprechen Elemente wie in vielen anderen Programmiersprachen über einen Index an, den Sie in eckigen Klammern schreiben. Der gewichtige Unterschied: Bei Julia besitzt das erste Element den Index 1 (Listing 20, Zeile 10).
Initialisieren
Listing 21 zeigt einige Varianten zum Initialisieren von Arrays. Die Zeilen 1 und 5 erzeugen Arrays per Listen-Abstraktion. Für die String-Darstellung eindimensionaler Arrays funktioniert println() gut, bei mehreren Dimensionen fallen die Ergebnisse von display() aber oft leserlicher aus.
Listing 21
arr = [x for x in 1:3];
println(arr)
#> [1, 2, 3]
arr = [10* x + y for x in 1:3, y in 1:3];
display(arr)
#> 3×3 Array{Int32,2}:
#> 11 12 13
#> 21 22 23
#> 31 32 33
zeros(3)
#> [0.0, 0.0, 0.0]
ones(3)
#> [1.0, 1.0, 1.0]
zeros(Int32, 3)
#> [0, 0, 0]
zeros(UInt8, 2, 2, 2)
#> 2×2×2 Array{UInt8,3}:
#> [:, :, 1] =
#> 0x00 0x00
#> 0x00 0x00
#>
#> [:, :, 2] =
#> 0x00 0x00
#> 0x00 0x00
rand()
#> 0.395879...
rand(Bool)
#> false
rand(UInt8)
#> 0xad
rand(Int8, 2, 2, 2)
#> 2×2×2 Array{Int8,3}:
#> [:, :, 1] =
#> -117 59
#> -84 -101
#>
#>[:, :, 2] =
#> -80 93
#> -64 -19
Die Funktionen zeros() und ones() erzeugen mit Nullen oder Einsen gefüllte Arrays. Mit dem ersten Argument spezifizieren Sie den Typ. Hat das erste Argument keinen Typ, füllt der Interpreter das Array mit Werten vom Typ Float64.
Die nachfolgenden Argumente bestimmen die Anzahl der Dimensionen und deren Umfang. Der Befehl zeros(UInt8, 2, 2, 2) in Zeile 19 liefert ein dreidimensionales Array, bei dem jede Dimension eine Ausdehnung von zwei Elementen vom Typ UInt8 besitzt. Alle Elemente haben den Wert 0, also 0x00. Das Beispiel zeigt, wie Julia Arrays mit Dimensionen größer 2 per display() darstellt, nämlich scheibchenweise.
Die Funktion rand() (ab Zeile 29) liefert ohne Argument eine Zufallszahl zwischen 0 und 1 vom Typ Float64. Wie bei zeros() und ones() legt ein optionales erstes Argument den Typ des Rückgabewerts fest. Bei numerischen Typen, die keine Fließkommazahlen darstellen, wählt rand() aus dem kompletten Wertebereich des jeweiligen Typs aus. Sprich: rand(Int8) gibt Werte zwischen -128 und 127 zurück.
Auch für rand() gilt: Nachfolgende ganzzahlige Argumente bestimmen Dimension und Ausdehnung. Das demonstriert Zeile 36 aus Listing 21.
Punkt-Operator
Listing 22 zeigt, wie Sie Funktionen mit einem Argument auf Arrays beliebiger Dimensionalität anwenden: Schreiben Sie statt f(arr) einfach f.(arr) und schon multipliziert in diesem Fall Julia jedes Element des zweidimensionalen Arrays mit 10.
Listing 22
f(x) = x*10
arr = rand(Int8, 2, 2)
#> 2×2 Array{Int8,2}:
#> -21 79
#> 102 40
arr = f.(arr)
#> 2×2 Array{Int32,2}:
#> -210 790
#> 1020 400
Zu guter Letzt zeigt Listing 23 einige Möglichkeiten, auf Elemente von Arrays zuzugreifen und Arrays zu modifizieren. Eine knappe, aber gehaltvolle Übersicht zu Julia im Allgemeinen und Array-Funktionen im Besonderen bietet die Kurzreferenz “The Julia Express” von Bogumil Kaminski [4].
Listing 23
arr = [10*x+y for x in 1:3, y in 1:3]
3×3 Array{Int32,2}:
11 12 13
21 22 23
31 32 33
# Zugriff
arr[1] #> 11
arr[9] #> 33
arr[2, 2] #> 22
# Ausschneiden
arr[1:2, 1:2]
#> 2×2 Array{Int32,2}:
#> 11 12
#> 21 99
# Zuweisung
arr[2, 2] = 99
# Einfügen
arr = [1, 2, 3]
push!(arr, 40)
#> [1, 2, 3, 40]
