Felder in R: der Datentyp array

Felder sind in R die Verallgemeinerung von Matrizen. In einer Matrix werden die Komponenten zweidimensional angeordnet (Zeilen und Spalten), in einem Feld sind beliebige Dimensionen zugelassen. Erzeugt werden Felder meist, indem ein Vektor mit Hilfe des Dimensionsvektors mehrdimensional angeordnet wird, oder mit der Funktion outer(). Weitere Gemeinsamkeiten und Unterschiede zu Matrizen werden diskutiert.

Einordnung des Artikels

Einführung

In den vorhergehenden Kapiteln wurden Matrizen ausführlich besprochen (Matrizen in R: der Datentyp matrix und Matrizen in R: Anwendungen). Sie entstehen dadurch, dass die Elemente eines Vektors zweidimensional angeordnet werden. In R ist die Verallgemeinerung einer Matrix das Feld (array). Wie bei einem Vektor müssen in einem Feld alle Elemente einen identischen Datentyp besitzen, allerdings können die Elemente in beliebig vielen Dimensionen angeordnet werden. Diese Anordnung lässt sich durch den Dimensionsvektor beschreiben (der im Fall einer Matrix die Zeilen- und Spaltenanzahl angibt).

Das Paradebeispiel für ein Feld ist die Zufallsvariable Sn, die die Augensumme beim n-maligen, unabhängigen Werfen eines Würfels beschreibt. Für n = 2 kann man S2 durch die Matrix beschreiben, siehe Abbildung 1.

Abbildung 1: Augensumme beim zweimaligen Werfen eines Würfels.Abbildung 1: Augensumme beim zweimaligen Werfen eines Würfels.

Will man dies für n = 3 weiterführen, muss man eine dritte Dimension hinzufügen, es entsteht ein Gitter, das als Würfel angeordnet ist. Für n > 3 versagt dann die geometrische Vorstellung. Es entstehen Gitter in einem n-dimensionalen Würfel, genauer aus dem n-fachen Kreuzprodukt der Mengen {1, 2, 3, 4, 5, 6}. In R wird das Gitter durch den Dimensionsvektor beschrieben und das zugehörige Feld wird mit Hilfe des äußeren Produktes outer() erzeugt. Das Beispiel wird unten ausführlich vorgestellt.

Man wird dabei sehen, dass für Felder – im Vergleich zu Matrizen – keine neuen Konzepte eingeführt werden. Man sollte den systematischen Zusammenhang besser so lesen: nahezu alle Konzepte, die bei den Matrizen vorgestellt wurden, sind eigentlich für Felder definiert und Matrizen sind Spezialfälle von Feldern, nämlich zweidimensionale Felder.

Beispiel: Augensumme beim n-maligen Werfen eines Würfels

Das folgende Skript zeigt nochmals, wie die Matrix S2 erzeugt wird, die die Augensumme beim zweimaligen, unabhängigen Werfen eines Würfels beschreibt:

v <- (1:6)
S2 <- outer(X = v, Y = v, FUN = "+")

v           # 1 2 3 4 5 6
S2
     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    2    3    4    5    6    7
[2,]    3    4    5    6    7    8
[3,]    4    5    6    7    8    9
[4,]    5    6    7    8    9   10
[5,]    6    7    8    9   10   11
[6,]    7    8    9   10   11   12

dim(S2)   # 6 6

In Zeile 14 wird der Dimensionsvektor von S2 ausgegeben, er beschreibt wie viele Zeilen und Spalten die Matrix S2 hat.

Um die Augensumme S3 beim dreimaligen, unabhängigen Werfen eines Würfels zu beschreiben, wird das äußere Produkt von S2 mit dem Vektor v gebildet:

# v und S2 wie oben
S3 <- outer(X = S2, Y = v, FUN = "+")

dim(S3)   # 6 6 6
S3

Der Dimensionsvektor von S3 besteht jetzt aus drei Komponenten (jeweils gleich 6, siehe Zeile 4), die Ausgabe von S3 ist sehr umfangreich, da insgesamt 6 Matrizen gezeigt werden, nämlich jeweils die entstehende Matrix, wenn die dritte Komponente gleich 1,2, ..., 6 gesetzt wird:

, , 1

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    3    4    5    6    7    8
[2,]    4    5    6    7    8    9
[3,]    5    6    7    8    9   10
[4,]    6    7    8    9   10   11
[5,]    7    8    9   10   11   12
[6,]    8    9   10   11   12   13

, , 2

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    4    5    6    7    8    9
[2,]    5    6    7    8    9   10
[3,]    6    7    8    9   10   11
[4,]    7    8    9   10   11   12
[5,]    8    9   10   11   12   13
[6,]    9   10   11   12   13   14

, , 3

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    5    6    7    8    9   10
[2,]    6    7    8    9   10   11
[3,]    7    8    9   10   11   12
[4,]    8    9   10   11   12   13
[5,]    9   10   11   12   13   14
[6,]   10   11   12   13   14   15

, , 4

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    6    7    8    9   10   11
[2,]    7    8    9   10   11   12
[3,]    8    9   10   11   12   13
[4,]    9   10   11   12   13   14
[5,]   10   11   12   13   14   15
[6,]   11   12   13   14   15   16

, , 5

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    7    8    9   10   11   12
[2,]    8    9   10   11   12   13
[3,]    9   10   11   12   13   14
[4,]   10   11   12   13   14   15
[5,]   11   12   13   14   15   16
[6,]   12   13   14   15   16   17

, , 6

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    8    9   10   11   12   13
[2,]    9   10   11   12   13   14
[3,]   10   11   12   13   14   15
[4,]   11   12   13   14   15   16
[5,]   12   13   14   15   16   17
[6,]   13   14   15   16   17   18

Man sieht hier, dass die Ausgabe von Feldern umfangreich und unübersichtlich werden kann. Man sollte sich daher überlegen, ob man nicht – gerade zum Testen von Programmen, in denen Felder vorkommen, – besser geeignete Ausgaben finden kann.

Erzeugen von Feldern

Die Funktion array()

Im Kapitel Matrizen in R: der Datentyp matrix wurde im Abschnitt Erzeugen von Matrizen ausführlich die Funktion matrix() vorgestellt:

matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL)

Wenn man weiß, dass ein Feld die mehrdimensionale Verallgemeinerung einer Matrix ist, ist auch sofort verständlich, welche Bedeutung die Eingabewerte der entsprechenden Funktion array() für Felder haben:

array(data = NA, dim = length(data), dimnames = NULL)

Da Zeilen und Spalten nur in einer zweidimensionalen Anordnung der Elemente sinnvoll sind, fehlen die Argumente nrow und ncol in der Funktion array(); stattdessen muss der Dimensionsvektor dim gesetzt werden, der die Anordnung der Elemente in den beliebig vielen Dimensionen des Feldes festlegt.

Im Folgenden werden einige Beispiele gezeigt, die den Einsatz der Funktion array() erläutern. Zudem werden dabei einige Spitzfindigkeiten im Zusammenhang zwischen Vektoren, Matrizen und Feldern aufgezeigt; welcher Datentyp vorliegt kann stets mit den is-dot-Funktionen abgefragt werden:

is.vector(x)
is.matrix(x)
is.array(x)

Um das Ergebnis gleich vorwegzunehmen: Die Spitzfindigkeiten entstehen nur dadurch, ob der Dimensionsvektor (das Attribut dim) gesetzt ist oder nicht und es gelten die folgenden Regeln.

  • Ein Vektor, bei dem das Attribut dim nicht gesetzt ist, ist ein Vektor, aber kein Feld.
  • Wird bei einem Vektor das Attribut dim gesetzt, so ist er kein Vektor mehr, aber ein Feld.
  • Ein Feld mit einem zweidimensionalen Dimensionsvektor (das Attribut dim hat die Länge 2) ist zugleich eine Matrix.
  • Weder ein Vektor (egal, ob dim gesetzt ist oder nicht) noch ein Feld mit mehr als zwei Dimensionen sind zugleich eine Matrix.

Das Attribut dimnames ist wie bei Vektoren und Matrizen ein optionales Attribut und wird hier nicht nochmals besprochen.

Es folgen einige Beispiele, die den Gebrauch der Funktion array() erläutern und gleichzeitig die oben genannten Spitzfindigkeiten erklären:

v <- (1:27)
v
# [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

is.vector(v)
# [1] TRUE
is.matrix(v)
# [1] FALSE
is.array(v)
# [1] FALSE

dim(v)
# NULL

# 1-dim Feld:

a1 <- array(data = v)
a1
# [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

is.vector(a1)
# [1] FALSE
is.matrix(a1)
# [1] FALSE
is.array(a1)
# [1] TRUE

dim(a1)
# [1] 27

# 2-dim Feld:

a2 <- array(data = v, dim = c(2, 14))
a2
# [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12] [,13] [,14]
# [1,]    1    3    5    7    9   11   13   15   17    19    21    23    25    27
# [2,]    2    4    6    8   10   12   14   16   18    20    22    24    26     1

is.vector(a2)
# [1] FALSE
is.matrix(a2)
# [1] TRUE
is.array(a2)
# [1] TRUE

dim(a2)
# [1]  2 14

# 3-dim Feld:

a3 <- array(data = v, dim = c(3, 3, 3))
a3
# , , 1
# 
# [,1] [,2] [,3]
# [1,]    1    4    7
# [2,]    2    5    8
# [3,]    3    6    9
# 
# , , 2
# 
# [,1] [,2] [,3]
# [1,]   10   13   16
# [2,]   11   14   17
# [3,]   12   15   18
# 
# , , 3
# 
# [,1] [,2] [,3]
# [1,]   19   22   25
# [2,]   20   23   26
# [3,]   21   24   27

is.vector(a3)
# [1] FALSE
is.matrix(a3)
# [1] FALSE
is.array(a3)
# [1] TRUE

dim(a3)
# [1] 3 3 3

Zur Erklärung:

Zeile 1: Es wird ein Vektor v mit 27 Komponenten definiert.

Zeile 5 bis 10: Die Abfragen mit den is-dot-Funktionen sollten klar sein: v ist ein Vektor, aber keine Matrix und kein Feld.

Zeile 12: Wie bei den Vektoren erklärt wurde, besitzt ein Vektor keinen Dimensionsvektor; das Attribut dim ist gleich NULL.

Zeile 17: Der Vektor v wird verwendet, um mit der Funktion array() ein Feld a1 zu definieren; allerdings wird das Argument dim nicht gesetzt.

Zeile 18 und 19: Die Ausgabe von a1 ist nicht von der Ausgabe von v zu unterscheiden; dies würde dafür sprechen, dass v und a1 identisch sind – sie sind es aber nicht, wie die folgenden Ausgaben zeigen.

Zeile 21 bis 26: a1 ist weder ein Vektor noch eine Matrix, aber ein Feld.

Zeile 28 und 29: Dass a1 kein Vektor sondern ein Feld ist, liegt am Dimensionsvektor; er wurde durch den Aufruf von array() automatisch gesetzt. Da aber keine ausdrücklichen Angaben zum Dimensionsvektor gemacht wurden, hat – das ist das default-Verhalten – der Dimensionsvektor die Länge 1 und die erste Dimension besitzt 27 Komponenten. (Inhaltlich ist somit a1 nicht von v zu unterscheiden, aber dennoch besitzen sie einen unterschiedlichen Datentyp.)

Zeile 33: Das Feld a2 wird wieder mit der Funktion array() erzeugt; jetzt wird aber ausdrücklich der Dimensionsvektor gesetzt, nämlich als Vektor der Länge 2 mit den Einträgen 2 und 14. Damit besteht a2 aber aus insgesamt 28 Komponenten (der Vektor v hat nur 27).

Zeile 34 bis 37: Die Ausgabe von a2 ist nicht von einer Matrix mit 2 Zeilen und 14 Spalten zu unterscheiden. Und man erkennt, wie die 28. Komponente gesetzt wird: sie wird gleich 1 gesetzt (recycling-Mechanismus, der Vektor v wird solange eingesetzt bis alle Komponenten aufgefüllt sind).

Beim Erzeugen von Feldern sollte man daher darauf achten, dass die Länge des zugrundeliegenden Vektors data (hier v mit 27 Komponenten) mit dem Produkt der Komponenten des Dimensionsvektors übereinstimmt (hier 2 · 14 = 28 Komponenten). Gerade bei mehrdimensionalen Feldern ist es schwer nachzuvollziehen, wie der recycling-Mechanismus andernfalls die Komponenten setzt.

Zeile 39 bis 44: An den Abfragen mit den is-dot-Funktionen erkennt man, dass a2 kein Vektor ist. Aber a2 ist eine Matrix und ein zweidimensionales Feld; diese beiden Datentypen sind nicht zu unterscheiden.

Zeile 46: Auch der Dimensionsvektor ist der einer Matrix.

Zeile 51: Der Vektor v wird verwendet, um ein drei-dimensionales Feld a3 zu erzeugen. Der Dimensionsvektor hat dreimal die 3 als Eintrag, das heißt man kann sich a3 als würfelförmiges Gitter mit 3 Gitterpunkten in jeder Raumrichtung vorstellen.

Zeile 52 bis 72: Die Ausgabe von a3 vermag aber schwer den Würfel zu vermitteln: Es werden drei Matrizen ausgegeben, die dadurch entstehen, dass aus der würfelförmigen Anordnung drei Ebenen herausgeschnitten werden. Wie man an den Indizes erkennen kann, liegen die Ebenen in der Richtung der ersten und zweiten Komponente.

Zeile 74 bis 79: Die is-dot-Funktionen zeigen, dass a3 weder ein Vektor noch eine Matrix, sondern ein Feld ist.

Zeile 81: Der Dimensionsvektor hat die Länge 3 mit jeweils 3 als Eintrag.

Das äußere Produkt outer()

Die Funktion outer() wurde schon an zwei Stellen erläutert und verwendet:

  • um Matrizen zu erzeugen (im Kapitel Matrizen in R: der Datentyp matrix im Abschnitt Das äußere Produkt outer()),
  • im einführenden Beispiel oben zur Berechnung der Augensumme beim n-maligen Würfeln.

Die Funktion outer() besitzt drei Eingabewerte:

outer(X, Y, FUN = "+")

Dabei sind X und Y Felder oder Vektoren, von denen das Kreuzprodukt gebildet wird, und FUN ist die Funktion, mit der die Elemente von X und Y verknüpft werden (die default-Funktion ist die Addition). Mit dem Kreuzprodukt von X und Y ist gemeint, dass alle möglichen Kombinationen der Elemente von X und Y gebildet werden. (Man kann sich das Kreuzprodukt besonders leicht am obigen Beispiel des wiederholten Würfelns veranschaulichen.)

Der Rückgabewert ist ein Feld A, dessen Dimensionsvektor aus den Dimensionsvektoren von X und Y zusammengesetzt ist: dim(A) == c(dim(X), dim(Y)) . Die Elemente von A werden aus den Elementen von X und Y berechnet, indem darauf die Funktion FUN angewendet wird: Ist x ein Index von X und y ein Index von Y, so ist A[c(x, y)] == FUN(X[x], Y[y]) .

Im Beispiel zur Berechnung der Augensumme S3 beim 3-maligen Würfeln wurde das äußere Produkt von S2 mit v <- (1:6) gebildet, wobei als FUN die Addition verwendet wird. Um zum Beispiel S3[6, 6, 6] zu berechnen, muss S2[6, 6] + v[6] berechnet werden (und man erhält 18).

Zugriff auf die Elemente eines Feldes

Der Zugriff auf die Komponenten einer Matrix wurde im Kapitel Matrizen in R: der Datentyp matrix im Abschnitt Zugriff auf die Elemente einer Matrix ausführlich erklärt. Bei Feldern kommt lediglich neu hinzu, dass es beliebig viele Dimensionen gibt. Die Länge des Dimensionsvektors gibt an, wieviele Indizes es gibt und seine Komponenten legen fest, welche Indizes gültig sind.

Im folgenden Skript wird ein Feld mit dem Dimensionsvektor (2, 3, 4) erzeugt und es wird auf verschiedene Elemente zugegriffen:

a3 <- array(data = (1:24), dim = c(2, 3, 4))

# Zugriff auf gültigen Index:
a3[2, 3, 4]
# [1] 24

# Zugriff auf ungültigen Index:
a3[2, 3, 5]
# Error in a3[2, 3, 5] : subscript out of bounds

# Zugriff auf a3[2, 3, 3] und a3[2, 3, 4]:
a3[2, 3, c(3, 4)]
# [1] 18 24

# Zugriff auf einen Vektor
a3[2, 3, ]
# [1]  6 12 18 24

# Zugriff auf eine Matrix
a3[2, , ]
# [,1] [,2] [,3] [,4]
# [1,]    2    8   14   20
# [2,]    4   10   16   22
# [3,]    6   12   18   24

Die letzten beiden Beispiele des Skripts zeigen, dass

  • ein freigelassener Index einen Vektor definiert,
  • zwei freigelassene Indizes eine Matrix definieren.

Komplexere Zugriffe wurden ebenfalls bei den Matrizen besprochen und können analog auf Felder übertragen werden.

Diagnose-Funktionen für Felder

Die Diagnose-Funktionen für Felder sind einfach nur die entsprechenden Verallgemeinerungen der Diagnose-Funktionen für Vektoren und Matrizen; eigentlich gibt es hier nichts Neues zu erklären.

Die Funktion print()

Die Ausgabe eines Feldes kann wie bei allen R-Objekten durch die Angabe des Objektes oder durch den Aufruf der print()-Funktion erfolgen; Letzteres hat wie immer den Vorteil, dass man weitere Argumente setzen kann.

An den Beispielen oben war schon zu erkennen:

  • Die Ausgabe eines eindimensionalen Feldes ist die eines Vektors.
  • Die Ausgabe eines zweidimensionalen Feldes ist die einer Matrix.
  • Die Ausgabe eines Feldes mit mehr als zwei Dimensionen, kann sehr umfangreich werden.

Die Funktion length()

Ein Feld wird wie eine Matrix intern durch einen Vektor abgespeichert. Der Dimensionsvektor definiert dabei, wie der Vektor zum Feld angeordnet wird. Bei der Ausgabe der Länge eines Feldes wird dann die Länge des zugrundeliegenden Vektors angezeigt.

Die Funktion str()

Die Funktion str() gibt wie bei Matrizen folgende Informationen in einer Zeile an:

  • den Speichermodus,
  • in eckigen Klammern den Bereich der Indizes; an der Anzahl der Bereiche liest man die Dimension des Feldes ab.
  • Die Werte des zugrundeliegenden Vektors, die eventuell abgeschnitten wird.

Es folgen die Beispiele zum zwei- und dreimaligen Würfeln:

v <- (1:6)
S2 <- outer(v, v, FUN = "+")
S3 <- outer(S2, v, FUN = "+")

str(S2)
# int [1:6, 1:6] 2 3 4 5 6 7 3 4 5 6 ...

str(S3)
# int [1:6, 1:6, 1:6] 3 4 5 6 7 8 4 5 6 7 ...

Oben wurde schon gesagt, dass Vektoren und eindimensionale Felder zu unterscheiden, obwohl sie nahezu identisch aufgebaut sind: der Unterschied besteht darin, dass ein Vektor keinen Dimensionsvektor besitzt, aber in einem eindimensionalen Feld ein Dimensionsvektor der Länge 1 gesetzt ist. Die Funktion str() zeigt den Unterschied zwischen Vektor und eindimensionalem Feld an, wie an folgendem Beispiel zu sehen ist:

# Vektor:
v <- (1:27)
v
# [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

str(v)
# int [1:27] 1 2 3 4 5 6 7 8 9 10 ...

# eindimensionales Feld:
a1 <- array(data = v)
a1
# [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

str(a1)
# int [1:27(1d)] 1 2 3 4 5 6 7 8 9 10 ...

In den eckigen Klammern ist beim eindimensionalen Feld zu erkennen, dass der Dimensionsvektor gesetzt ist.

Typumwandlungen

Die Typumwandlungen zwischen Vektoren, Matrizen und Feldern geschehen mit den Funktionen:

as.vector(x)
as.matrix(x)
as.array(x)

und bedürfen kaum einer ausführlichen Erklärung. Folgende Aussagen sollten genügen:

  • Ein Vektor und ein eindimensionales Feld unterscheiden sich nur im Dimensionsvektor (siehe Erklärung oben zur Funktion str()). Bei der Umwandlung eines Vektors in ein eindimensionales Feld wird daher nur der Dimensionsvektor gesetzt; umgekehrt wird er gleich NULL gesetzt.
  • Wird ein Vektor x in eine Matrix verwandelt, erhält man einen Spalten-Vektor (also eine Spalte und die Anzahl der Zeilen stimmt mit der Anzahl der Komponenten von x überein).
  • Ein zweidimensionales Feld und eine Matrix sind identisch; bei der Umwandlung passiert nichts und sie ist daher überflüssig.
  • Wird ein Feld der Dimension zwei oder höher in einen Vektor verwandelt, erhält man den zugrundeliegenden Vektor und der Dimensionsvektor ist gleich NULL gesetzt (Beispiel siehe unten).
v <- (1:6)
S2 <- outer(v, v, FUN = "+")

v2 <- as.vector(S2)
v2
# [1]  2  3  4  5  6  7  3  4  5  6  7  8  4  5  6  7  8  9  5  6  7  8  9 10  6  7  8  9 10 11  7  8  9 10 11 12

str(v2)
# int [1:36] 2 3 4 5 6 7 3 4 5 6 ...

Die Verallgemeinerung der transponierten Matrix: die Funktion aperm()

Bei den Matrizen wurde erklärt, dass mit Hilfe der Funktion t() die transponierte Matrix einer gegebenen Matrix berechnet werden kann. Auf der Ebene der Indizes einer Matrix bedeutet transponierte Matrix, dass Zeilen- und Spalten-Index vertauscht werden. Auf der Ebene des Dimensionsvektors bedeutet dies: seine beiden Komponenten werden vertauscht.

Das folgende Beispiel demonstriert dies:

# Matrix mit 2 Zeilen und 3 Spalten:

a2 <- array(data = (1:6), dim = c(2,3))
a2
# [,1] [,2] [,3]
# [1,]    1    3    5
# [2,]    2    4    6

dim(a2)
# [1] 2 3

# transponierte Matrix von a2:

a2.t <- t(a2)
a2.t
# [,1] [,2]
# [1,]    1    2
# [2,]    3    4
# [3,]    5    6

dim(a2.t)
# [1] 3 2

Die Vertauschung der Indizes einer Matrix ist – abstrakt gesehen – die einzig mögliche Permutation der Zahlen 1 und 2 (abgesehen von der Identität, bei der (1, 2) auf (1, 2) abgebildet wird). Da ein Feld im Allgemeinen n Dimensionen hat, kann man die Indizes (1, 2, ..., n) auf mehrere Arten vertauschen: es gibt jetzt n! Permutationen. Und so wie man die Permutation (1, 2) → (2, 1) als Vertauschung von Zeilen und Spalten bei einer Matrix interpretieren kann, entspricht eine Permutation von (1, 2, ..., n) einer Vertauschung der entsprechenden Dimensionen eines Feldes.

Diese Vertauschung der Dimensionen wird durch die Funktion aperm() ausgeführt – die man in diesem Sinne als Verallgemeinerung von t() für beliebige Felder auffassen kann.

aperm(a, perm)

Dazu besitzt aperm() die beiden Eingabewerte:

  • a: das Feld, dessen Indizes vertauscht werden sollen,
  • perm: die Permutation der Indizes, die ausgeführt werden soll.

Das folgende Beispiel zeigt, wie man die transponierte Matrix aus dem Beispiel oben mit Hilfe der Funktion aperm() berechnet:

# a2 wie oben:
a2 <- array(data = (1:6), dim = c(2, 3))

a2.t <- aperm(a = a2, perm = c(2, 1))
a2.t
# [,1] [,2]
# [1,]    1    2
# [2,]    3    4
# [3,]    5    6

dim(a2.t)
# [1] 3 2

Im folgenden Beispiel wird bei einem drei-dimensionalen Feld der Dimensionsvektor permutiert, einmal mit der Permutation (1, 2, 3) → (3, 2, 1) und einmal mit der Permutation (1, 2, 3) → (2, 3, 1):

# 3-dim Feld:

a3 <- array(data = (1:24), dim = c(2, 3, 4))

dim(a3)
# [1] 2 3 4

# Permutation (1, 2, 3) -> (3, 2, 1):

a3.perm.321 <- aperm(a = a3, perm = c(3, 2, 1))

dim(a3.perm.321)
# [1] 4 3 2

a3.perm.321
# , , 1
# 
# [,1] [,2] [,3]
# [1,]    1    3    5
# [2,]    7    9   11
# [3,]   13   15   17
# [4,]   19   21   23
# 
# , , 2
# 
# [,1] [,2] [,3]
# [1,]    2    4    6
# [2,]    8   10   12
# [3,]   14   16   18
# [4,]   20   22   24

# Permutation (1, 2, 3) -> (2, 3, 1):

a3.perm.231 <- aperm(a = a3, perm = c(2, 3, 1))

dim(a3.perm.231)
# [1] 3 4 2

a3.perm.231
# , , 1
# 
# [,1] [,2] [,3] [,4]
# [1,]    1    7   13   19
# [2,]    3    9   15   21
# [3,]    5   11   17   23
# 
# , , 2
# 
# [,1] [,2] [,3] [,4]
# [1,]    2    8   14   20
# [2,]    4   10   16   22
# [3,]    6   12   18   24

Die Familie der apply()-Funktionen

Den mit apply() verwandten Funktionen ist ein eigenes Kapitel gewidmet; sie erlauben es, deutlich komplexere Operationen mit Feldern auszuführen.

Zusammenfassung

Erzeugen von Feldern

Die folgende Tabelle zeigt Funktionen zum Erzeugen von Feldern:

Funktion Beschreibung
array(data = NA, dim = length(data), dimnames = NULL) Erzeugt aus dem Vektor data ein Feld gemäß dem Dimensionsvektor dim (eventuell mit recycling-Mechanismus); per default wird der Vektor in ein eindimensionales Feld verwandelt. Optional kann das Attribut dimnames gesetzt werden.
outer(X, Y, FUN = "+") Das äußere Produkt der Felder X und Y, deren Elemente gemäß der Funktion FUN verknüpft werden (der default-Wert für FUN ist die Addition). Der Dimensionsvektor des äußeren Produktes ist c(dim(X), dim(Y)) .
X %o% Y Kurzform für outer(), wenn als Funktion FUN die Multiplikation * verwendet wird. (Beachte: in %o% wird das kleine O verwendet, nicht die Null 0.)

Die folgende Tabelle zeigt die Rückgabewerte der Funktionen zum Erzeugen von Feldern:

Funktion Rückgabewert Datentyp
array(data = NA, dim = length(data), dimnames = NULL) Feld, in dem die Komponenten des Vektors data gemäß dem Dimensionsvektor dim angeordnet werden und das Attribut dimnames gesetzt werden kann. Feld
outer(X, Y, FUN = "+") Das äußere Produkt der Felder X und Y, deren Elemente gemäß der Funktion FUN verknüpft werden (der default-Wert für FUN ist die Addition). Der Dimensionsvektor des äußeren Produktes ist c(dim(X), dim(Y)) . Dazu wird das Kreuzprodukt der Felder X und Y gebildet und deren Elemente werden durch die Funktion FUN verknüpft. Feld
X %o% Y Kurzform für outer(X, Y, FUN = "*") Feld

is-dot- und as-dot-Funktionen

Funktion Beschreibung
is.array(x) Testet, ob das Objekt x ein array ist.
as.array(x) Verwandelt das Objekt x in ein array. Dabei wird insbesondere der Dimensionsvektor gesetzt.

Die folgende Tabelle zeigt die Rückgabewerte der Funktionen:

Funktion Rückgabewert Datentyp
is.array(x) TRUE oder FALSE, je nachdem ob das Objekt x ein array ist. (Beachte: FALSE bei einem echten Vektor und TRUE bei einer Matrix) logischer Wert
as.array(x) Verwandelt das Objekt x in ein array. Dabei wird insbesondere der Dimensionsvektor gesetzt. Feld
Alle Kommentare
Durch die Nutzung dieser Website erklären Sie sich mit der Verwendung von Cookies einverstanden. Außerdem werden teilweise auch Cookies von Diensten Dritter gesetzt. Genauere Informationen finden Sie in unserer Datenschutzerklärung sowie im Impressum.