Arrays in R

Ein Array ist eine Datenstruktur, die mehrdimensionale Daten aufnehmen kann. In R sind Arrays Objekte, die Daten in zwei oder mehr Dimensionen speichern. Beispielsweise können quadratische Matrizen zwei Zeilen und zwei Spalten haben, und die Dimension kann auf fünf erweitert werden. Arrays speichern nur Werte eines einheitlichen Datentyps. Die Daten können mehrdimensional sein, mit Zeilen, Spalten und ggf. weiteren Dimensionen.

Erstellen eines Arrays

Die Funktion array() erstellt ein Array. Als Argumente übergibst du einen Vektor mit Zahlen sowie die Dimensionen ("dim").

Schauen wir uns ein Beispiel an, in dem zwei Vektoren mit den Namen "array1" und "array2" erzeugt werden.

vector1 =  c (5, 10, 15,20)
vector2 =  c (25, 30, 35, 40, 45, 50,55,60)

Diese beiden Vektoren kannst du als Eingabe für ein Array mit der Dimension 4 × 4 verwenden, sodass drei Matrizen bzw. Ebenen entstehen.

final = array (c (array1, array2),dim =c(4,4,3))
print (final)

Die Ausgabe des obigen Codes sieht so aus:

, , 1

     [,1] [,2] [,3] [,4]
[1,]    5   25   45    5
[2,]   10   30   50   10
[3,]   15   35   55   15
[4,]   20   40   60   20

, , 2

     [,1] [,2] [,3] [,4]
[1,]   25   45    5   25
[2,]   30   50   10   30
[3,]   35   55   15   35
[4,]   40   60   20   40

, , 3

     [,1] [,2] [,3] [,4]
[1,]   45    5   25   45
[2,]   50   10   30   50
[3,]   55   15   35   55
[4,]   60   20   40   60

Benennen wir unser Array nun mit "Arr1" und "Arr2" über "matrix.names" um. Außerdem ändern wir die Zeilennamen in ("row1", "row2") und die Spaltennamen in ("column1", "column2", "column3"). Die Dimension der Matrix ist 2 Zeilen × 3 Spalten.

array1 =  c (9 , 18 )
array2 = c (27,36)
r.names = c ("column1","column2","column3")
c.names = c ("row1","row2")
m.names = c ("Arr1", "Arr2")

final = array (c (array1,array2), dim=c (2,3,2), dimnames=list (c.names, r.names, m.names))
print(final)

Die Ausgabe des obigen Codes zeigt zwei Zeilen und drei Spalten. Außerdem werden Werte in den Spalten wiederholt, sobald die Eingabevektoren aufgebraucht sind:

, , Arr1

     column1 column2 column3
row1       9      27       9
row2      18      36      18

, , Arr2

     column1 column2 column3
row1      27       9      27
row2      36      18      36

Indizierung in einem Array

Ein Array besteht aus Elementen in mehreren Dimensionen. Jedes Element kann für Operationen adressiert werden. Die Indizierung erfolgt mit '[]'. In array-ähnlichen Matrizen mit Zeilen und Spalten nutzt du das Schema: mat[row, column]

Betrachten wir ein Beispiel, in dem das Array einen Vektoreingang von 1 bis 9 enthält. Es gibt genau drei Zeilen und drei Spalten mit den Werten 1 bis 9. 'c.names' sind die neuen Spaltennamen als Vektor ('c1', 'c2', 'c3') und 'r.names' sind die neuen Zeilennamen ('r1', 'r2', 'r3').

a1=  c (1,2,3,4)
a2= c (5,6,7,8,9)
r.names = c ("c1","c2","c3")
c.names = c ("r1","r2","r3")
m.names = c ("first")

arr = array (c (a1,a2), dim=c (3,3,1), dimnames=list (c.names, r.names, m.names))
print(arr)

, , first

   c1 c2 c3
r1  1  4  7
r2  2  5  8
r3  3  6  9

Die Ausgabe des obigen Codes lautet:

 , , first

   c1 c2 c3
r1  1  4  7
r2  2  5  8
r3  3  6  9 

Wie du siehst, wurden die Werte 1 bis 9 in einer 3 × 3-Struktur (Zeilen × Spalten) angeordnet, und Zeilen- sowie Spaltennamen wurden vergeben.

Schauen wir uns an, wie sich Elemente aus dem Array extrahieren lassen.

1. Extrahiere die Zahl '7' aus dem Array 'arr'.

arr[1,3,1]

7

Die Ausgabe ist 7. In 'arr[1,3,1]' bedeutet das: Zeile 1, Spalte 3, und 1 steht für die erste Ebene des Arrays 'arr'.

1. Um die 1 zu erhalten, verwende 'arr[1,1,1]': Zeile 1, Spalte 1, Ebene 1.

arr[1,1,1]

1

Die Ausgabe ist 1.

1. Um mehrere Werte auf einmal abzurufen, gibst du den gewünschten Bereich an.

arr[1:2,1:2,1]

Der obige Code liefert folgende Ausgabe: Es werden 2 Zeilen und 2 Spalten aus der ersten Ebene des Arrays 'arr' extrahiert:

    c1    c2
r1    1    4
r2    2    5 

1. Du kannst die gesamte Ebene des Arrays 'arr' mit folgender Syntax abrufen: 'arr[ , ,1]'. Leere Bereiche vor den Kommas stehen für alle Zeilen bzw. Spalten. Die 1 gibt die zu entnehmende Ebene an.

arr[ , ,1]

Die Ausgabe enthält alle Elemente:

    c1    c2    c3
r1    1    4    7
r2    2    5    8
r3    3    6    9 

1. Die komplette zweite Zeile erhältst du mit arr[2, ,1]. Das Leerzeichen steht für alle Spalten, 1 für die erste Ebene.

arr[2,,1]

c1

2

c2

5

c3

8

Die Ausgabe zeigt zudem die Bezeichnungen c1, c2, c3.

c1 2
c2 5
c3 8

1. Die komplette zweite Spalte erhältst du mit arr[,2,1]. Das Leerzeichen steht für alle Zeilen, 2 für die zweite Spalte und 1 für die erste Ebene.

mat[ ,2,1]

r1

4

r2

5

r3

6

Die Ausgabe zeigt zudem die Bezeichnungen r1, r2, r3.

r1 4
r2 5
r3 6

Matrizen erstellen und addieren

Erstelle zwei Matrizen namens mat1 und mat2 aus 'arr[ , ,1]'. Dabei werden alle Zeilen und Spalten der ersten Ebene von 'arr' kopiert.

mat1 = arr[,,1]
mat2 = arr[,,1]

   c1 c2 c3
r1  2  8 14
r2  4 10 16
r3  6 12 18 

Addiere die beiden Matrizen 'mat1' und 'mat2' und speichere das Ergebnis in final. Gib das Ergebnis anschließend aus.

final <- mat1+mat2
print(final)

Die folgende Ausgabe zeigt, dass die entsprechenden Elemente von mat1 und mat2 paarweise addiert wurden.

   c1 c2 c3
r1  2  8 14
r2  4 10 16
r3  6 12 18 

apply()

'apply()' gehört zur R-Familie von Funktionen, die das Schreiben von Code einfacher und effizienter machen. Im folgenden Beispiel berechnen wir damit die Summe zweier Matrizen.

Die Syntax von apply():
apply(x, margin, function)

Die Argumente bedeuten:
x: Ein Array oder zweidimensionale Daten wie Matrizen.
margin: Gibt an, worauf die Funktion angewendet wird: c(1) für Zeilen, c(2) für Spalten, c(1,2) für beides.
function: Die in R eingebaute oder benutzerdefinierte Funktion, die auf die Daten angewendet wird.

Erstelle nun einen Vektor 'array1' der Länge drei und 'array2' der Länge sechs mit folgendem Code.

array1 = c(5,10,15)
array2 = c(15,20,25,30,35,40)

Unten siehst du, wie array() die beiden Vektoren 'array1' und 'array2' akzeptiert, ein Array mit 3 Zeilen, 3 Spalten und 2 Ebenen erstellt und es in 'my.Array' speichert.

my.Array <- array(c(array1,array2),dim = c(3,3,2))
print(my.Array)

, , 1

     [,1] [,2] [,3]
[1,]    5   15   30
[2,]   10   20   35
[3,]   15   25   40

, , 2

     [,1] [,2] [,3]
[1,]    5   15   30
[2,]   10   20   35
[3,]   15   25   40

Die Ausgabe zeigt zwei Matrizen im 3 × 3-Format (Zeilen × Spalten).

, , 1

     [,1] [,2] [,3]
[1,]    5   15   30
[2,]   10   20   35
[3,]   15   25   40

, , 2

     [,1] [,2] [,3]
[1,]    5   15   30
[2,]   10   20   35
[3,]   15   25   40

Mit 'apply()' berechnen wir nun die Spaltensummen über beide Matrizen.

final <- apply(my.Array, c(2), sum)
print(final)

[1]  60 120 210

Hierbei steht c(2) für die Spalten. Die Elemente in 'my.Array' werden spaltenweise aufsummiert, was zur folgenden Ausgabe führt.

60 120 210

Zum Schluss berechnen wir die Zeilensummen.

final <- apply(my.Array, c(1), sum)
print(final)

[1] 100 130 160

Hier steht c(1) für die Zeilen. Die Elemente in 'my.Array' werden zeilenweise aufsummiert, was die folgende Ausgabe ergibt.

100 130 160

Glückwunsch

Glückwunsch, du hast das Ende dieses Tutorials erreicht!

Du hast R-Arrays kennengelernt: deren Erstellung, das Indizieren mit Beispielen sowie das Erstellen und Addieren von Matrizen und den Einsatz der apply()-Funktion.

Wenn du mehr über R lernen möchtest, starte mit DataCamps Introduction to R-Kurs.

Referenzen:
R-Arrays
R Array Function and Create Array in R