-
Notifications
You must be signed in to change notification settings - Fork 1
Matrizenrechnung
Wir erstellen Matrizen mit dem Matrix-Befehl von R. Dabei gilt folgende Syntax:
matrix(data=Inhalt der Matrix, nrow=Anzahl Reihen, ncol=Anzal Spalten)
Matrizen können nur Variablen eines Typs enthalten, z.B. Zahlen oder Strings
Ein Beispiel für eine 4x4 Matrix, die lauter Nullen enthät:
matrix(0, 4, 4)## [,1] [,2] [,3] [,4]
## [1,] 0 0 0 0
## [2,] 0 0 0 0
## [3,] 0 0 0 0
## [4,] 0 0 0 0
Hier eine 4x5 Matrix mit den Zahlen von 1 bis 20:
matrix(1:20, 4, 5)## [,1] [,2] [,3] [,4] [,5]
## [1,] 1 5 9 13 17
## [2,] 2 6 10 14 18
## [3,] 3 7 11 15 19
## [4,] 4 8 12 16 20
Wenn die Matrix den Reihen nach und nicht den Spalten nach gefüllt werden soll, benutzen wir den byrow Parameter:
matrix(1:20, 4, 5, byrow = TRUE)## [,1] [,2] [,3] [,4] [,5]
## [1,] 1 2 3 4 5
## [2,] 6 7 8 9 10
## [3,] 11 12 13 14 15
## [4,] 16 17 18 19 20
Die Nullmatrix hat in allen Zellen ausschließlich den Wert 0:
## [,1] [,2] [,3] [,4]
## [1,] 0 0 0 0
## [2,] 0 0 0 0
## [3,] 0 0 0 0
## [4,] 0 0 0 0
Die Einheitsmatrix hat in der Hauptdiagonalen den Wert 1 und in allen anderen Zellen den Wert 0:
## [,1] [,2] [,3] [,4]
## [1,] 1 0 0 0
## [2,] 0 1 0 0
## [3,] 0 0 1 0
## [4,] 0 0 0 1
Die Einheitsmatrix mit n Reihen und Spalten wird auch als
Wir speichern nun eine 3x3 Matrix als Variable ab:
m <- matrix(c(1, 1, 1, 2, 2, 2, 3, 3, 3), 3, 3)Der Zugriff auf unsere Matrix erfolgt nun über den Abruf der Variablen:
m## [,1] [,2] [,3]
## [1,] 1 2 3
## [2,] 1 2 3
## [3,] 1 2 3
Um auf eine spezifische Zeile oder Spalte zuzugreifen muss diese in eckigen Klammern an den Variablennamen angefügt werden. Die Syntax für die Auswahl lautet wie folgt:
Variablenname[Zeile,Spalte]
Im Folgenden wählen wir die erste Zeile unserer Matrix aus:
m[1, ]## [1] 1 2 3
Man beachte hierbei, dass wir das Komma, welches Zeilen- und Spaltenauswahl trennt, trotzdem in die Klammern schreiben, auch wenn wir keine Angabe zu spezifischen Spalten machen. Nur so kann R zwischen eine Zeilen- und einer Spaltenauswahl unterscheiden.
Nun wählen wir die zweite Spalte unserer Matrix aus:
m[, 2]## [1] 2 2 2
Auch hier schreiben wir das Komma und zeigen damit an, dass wir eine spezifische Spalte auswählen wollen. Durch gleichzeitige Angabe von Zeile und Spalte wählen wir eine einzelne Zelle in unserer Matrix aus. Im folgenden Beispiel wählen wir aus der dritten Reihe die Zelle in der ersten Spalte:
m[3, 1]## [1] 1
Es ist auch möglich, mehrere zusammenhängende Zellen auszuwählen. Im folgenden Beispiel wählen wir aus der dritten Reihe die beiden Zellen in der ersten und zweiten Spalte:
m[3, c(1, 2)]## [1] 1 2
Bei falschen Auswahlparametern (Indizes) gibt uns R eine entsprechende Fehlermeldung zurück:
m[5, 1]## Error: Indizierung außerhalb der Grenzen
Wir erzeugen zu unserer zuvor verwendeten Matrix m noch eine zweite Matrix n, die wir für die folgenden Berechnungen nutzen werden:
n <- matrix(c(1, 2, 3, 1, 2, 3, 1, 2, 3), 3, 3)Die neue Matrix beinhaltet dieselben Werte, allerdings nun nach Zeilen und nicht nach Spalten angeordnet (dasselbe könnte man erreichen, in dem man den ursprünglichen Befehl für die Matrix m um den Parameter byrow=TRUE ergänzt):
## [,1] [,2] [,3]
## [1,] 1 1 1
## [2,] 2 2 2
## [3,] 3 3 3
Wir können zwei Matrizen einfach mittels + addieren:
m + n## [,1] [,2] [,3]
## [1,] 2 3 4
## [2,] 3 4 5
## [3,] 4 5 6
Wir nennen die entstehende Matrix in der Folge c. Die einzelnen Zellen c[i,j] dieser Matrix kommen einfach dadurch zustande, dass wir die entsprechenden Zellen m[i,j] und n[i,j] einfach addieren. Ein Beispiel:
c[1,2] beträgt 3. Die Zelle m[i,j] in der ersten Ausgangsmatrix beträgt 2 und n[i,j] in der zweiten Ausgangsmatrix beträgt 1. 2+1 = 3
Wir können nur Matrizen addieren, die die gleichen Dimensionen haben. Beim Versuch unterschiedlich dimensionierte Matrizen zu addieren gibt R eine entsprechende Fehlermeldung aus:
m2 <- matrix(1:15, 5, 3)
n2 <- matrix(1:6, 3, 2)
m2 + n2## Error: nicht passende Arrays
Das gewöhnliche Matrizenprodukt erhalten wir durch den %*% Operator:
m %*% n## [,1] [,2] [,3]
## [1,] 14 14 14
## [2,] 14 14 14
## [3,] 14 14 14
Wir nennen die entstehende Matrix in wieder c. Die einzelnen Zellen c[i,j] dieser Matrix sind beim gewöhlichen Matrizenprodukt definiert als das Skalarprodukt des Zeilenvektors m[i,] aus unserer Matrix m (auf der linken Seite des Operators) und des Spaltenvektors n[,j] aus unserer zweiten Matrix n (auf der rechten Seite unseres Operators). Wir bilden also das Skalarprodukt zweier Vektoren, von denen je einer aus jeder der zu multiplizierenden Matrizen stammt (also Zeile i aus Matrix m und Spalte j aus Matrix n).
Wie berechnet man nun das Skalarprodukt dieser beiden Vektoren?
Das Skalarprodukt zweier n-dimensionaler Vektoren (also von zwei Vektoren mit jeweils n Elementen) wird gebildet, in dem man immer die n-ten Elemente der beiden Vektoren miteinander multipliziert und alle n Produkte, die man dabei erhält, aufsummiert. R bildet das Skalarprodukt zweier Vektoren ebenfalls mit dem %*% Operator:
c(1, 2, 3) %*% c(1, 2, 3)## [,1]
## [1,] 14
Das Ergebnis ist wie beschrieben die Summe der Produkte der n-ten Elemente, also 1*1+2*2+3*3 = 14.
Wenn wir uns unsere beiden Matrizen ansehen, stellen wir fest, dass beim Matrizenprodukt mn für jede Zelle in der Matrix der Spalten- und der Zeilenvektor jeweils (1,2,3) ist (Jede Zeile von m ist (1,2,3) und jede Spalte von n ist (1,2,3)), deshalb ergibt sich für jede Zelle in der Produktmatrix ein Skalarprodukt von 14. Anders verhält es sich, wenn wir die Reihenfolge der Matrizen in unserme Befehl umdrehen, also nicht mehr das mn Produkt, sondern das nm Produkt bilden:
n %*% m## [,1] [,2] [,3]
## [1,] 3 6 9
## [2,] 6 12 18
## [3,] 9 18 27
Hierbei ergeben sich nun unterschiedliche Spalten- und Zeilenvektoren aus den beiden Matrizen, so dass das Skalarprodukt sich für jede Zelle unterscheidet. Unsere Ergebnismatrix nennen wir wieder c. Für c[1,1] sind beispielsweise die Vektoren beide (1,1,1) (Ergebnis: 1+1+1 = 3) und für c[3,3] sind die Vektoren beide (3,3,3) (Ergebnis: 9+9+9 = 27).
Das gewöhnliche Matrixprodukt mn ist nur dann für zwei Matrizen m und n definiert, wenn m genau so viele Spalten hat, wie n Zeilen. Das liegt daran, dass man das Skalarprodukt von zwei Vektoren nur dann bilden kann, wenn diese Vektoren dieselbe Anzahl an Elementen beinhalten.
Die Anzahl der Zeilen in m und die Anzahl der Spalten in n kann jedoch beliebig variieren. Wir können also z.B. ein Matrixprodukt aus einer 5x3 und einer 3x2 Matrix bilden:
m2 <- matrix(1:15, 5, 3)
n2 <- matrix(1:6, 3, 2)
m2 %*% n2## [,1] [,2]
## [1,] 46 100
## [2,] 52 115
## [3,] 58 130
## [4,] 64 145
## [5,] 70 160
Umgekehrt können wir nicht das Produkt in umgekehrter Reihenfolge bilden, da dann die Spaltenzahl der ersten Matrix nicht der Reihenzahl der zweiten Matrix entspricht:
n2 %*% m2## Error: nicht passende Argumente
Einfache Merkregel, wenn man die Matrizen in der Form 5x3 * 3x2 aufschreibt:
Die Werte innen müssen einander entsprechen, während die Werte außen variieren können!
Die Form der sich ergebenden Multiplikationsmatrix wird durch die äußeren variablen Parameter bestimmt (Anzahl der Reihen der ersten Matrix und Anzahl der Spalten der zweiten Matrix).
Für das gewöhnliche Matrizenprodukt haben wir den %*% Operator verwendet. Wenn wir stattdessen ein einfaches * verwenden, führt R eine komponentenweise Multiplikation der einzelnen Zellen durch:
m * n## [,1] [,2] [,3]
## [1,] 1 2 3
## [2,] 2 4 6
## [3,] 3 6 9
Wir nennen die entstehende Matrix wieder c. Die einzelnen Zellen c[i,j] dieser Matrix ergeben sich als das Produkt der entsprechenden Zellen aus beiden Vektoren, d.h. c[i,j] = m[i,j]*n[i,j].
Ein Beispiel:
Der Wert von Zelle c[3,2] unserer Ergebnismatrix beträgt 6. Zelle m[3,2] hat den Wert 2 und Zelle n[3,2] (also aus der anderen Matrix) hat den Wert 3, so dass sich 3*2 = 6 ergibt. Hier werden also einfach nur die entsprechenden Zellen beider Matrizen multipliziert.
Bei der komponentenweisen Multiplikation zweier Matrizen ist im Unterschied zum gewöhnlichen Matrixprodukt die Reihenfolge bei der Berechnung egal:
n * m## [,1] [,2] [,3]
## [1,] 1 2 3
## [2,] 2 4 6
## [3,] 3 6 9
Wenn wir also Matrix m und Matrix n vertauschen erhalten wir dieselbe Ergebnismatrix, daher gilt hier n*m = m*n.
Das Hadamard-Schur-Produkt ist für zwei Matrizen nur dann definiert, wenn diese Matrizen exakt dieselben Dimensionen haben, da ja jede Zelle aus der einen Matrix jeweils mit einer entsprechenden Zelle aus der anderen Matrix multipliziert werden soll.
m2 <- matrix(1:15, 5, 3)
n2 <- matrix(1:6, 3, 2)
m2 * n2## Error: nicht passende Arrays
Wenn man die Zeilen und Spalten einer Matrix m vertauscht erhält man die transponierte Matrix m'. Bei R kann eine Matrix mit Hilfe der t()-Funktion transponiert werden:
m## [,1] [,2] [,3]
## [1,] 1 2 3
## [2,] 1 2 3
## [3,] 1 2 3
t(m)## [,1] [,2] [,3]
## [1,] 1 1 1
## [2,] 2 2 2
## [3,] 3 3 3
library(Matrix)
m## [,1] [,2] [,3]
## [1,] 1 2 3
## [2,] 1 2 3
## [3,] 1 2 3
rankMatrix(m)## [1] 1
## attr(,"method")
## [1] "tolNorm2"
## attr(,"useGrad")
## [1] FALSE
## attr(,"tol")
## [1] 6.661e-16
Die Spur einer Matrix ist die Summe der Hauptdiagonalen:
library(psych)
m## [,1] [,2] [,3]
## [1,] 1 2 3
## [2,] 1 2 3
## [3,] 1 2 3
tr(m)## [1] 6
m3 = matrix(c(1, 2, 3, 4), 2, 2)
m3## [,1] [,2]
## [1,] 1 3
## [2,] 2 4
solve(m3)## [,1] [,2]
## [1,] -2 1.5
## [2,] 1 -0.5
m3 %*% solve(m3)## [,1] [,2]
## [1,] 1 0
## [2,] 0 1