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.
Noch keine Stimmen abgegeben
Noch keine Kommentare

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