13 Matrix-Operationen

Matrizen sind in R 2-dimensionale numerische Vektoren, die aus Zeilen und Spalten bestehen. Die Anzahl der Zeilen und Spalten gibt die Dimensionalität der Matrix an. Allgemein wird von einer m \times n-Matrix gesprochen, wobei m für die Anzahl der Zeilen und n für die Anzahl der Spalten steht.

Merke

Bei Matrizen werden immer zuerst die Zeilen und dann die Spalten angegeben.

13.1 Matrizen erstellen

Eine Matrix wird in R mit der Funktion matrix() erstellt. Diese Funktion erwartet einen Vektor als erstes Argument. Zusätzlich muss mit ncol oder nrow angegeben werden, wie viele Spalten bzw. Zeilen die Matrix haben soll. Der optionale Paramter byrow zeigt an, ob die Werte zeilen- oder spaltenweise in die Matrix übernommen werden sollen. Die Zeilenschreibweise erleichtert die Eingabe einer Matrix (Beispiel 13.1).

Beispiel 13.1 (Matrix in Zeilenschreibweise erzeugen)

( # Diese Klammer gibt das Ergebnis der Operation aus.
    matrixA = matrix( 
    c( 
        1, 2, 3,
        3, 2, 1
    ), ncol = 3, nrow = 2, byrow = TRUE)
)

     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    3    2    1

Ist die Länge des Eingabevektors grösser als die gewünschten Zeilen- oder Spaltenanzahl erlauben, dann werden alle überzähligen Werte verworfen (Beispiel 13.2) und eine Warnung erzeugt.

Praxis

Es muss nur die Anzahl der Spalten oder der Zeilen beim Erzeugen einer Matrix angegeben werden. Der jeweils andere Wert wird aus der Länge und dem angegebenen Wert ermittelt.

Beispiel 13.2 (Matrix mit überlangem Eingabevektor erzeugen)

matrix( 
    c( 
        1, 2, 3,
        3, 2, 1,
        4, 5, 6
    ), ncol = 3, nrow = 2, byrow = TRUE)

Warning in matrix(c(1, 2, 3, 3, 2, 1, 4, 5, 6), ncol = 3, nrow = 2, byrow =
TRUE): Datenlänge [9] ist kein Teiler oder Vielfaches der Anzahl der Zeilen [2]

     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    3    2    1

Ist die Länge des Eingabevektors kürzer als für eine Matrix mit den gewünschten Dimensionen notwendig wäre, dann wird der Vektor wie bei einer Vektortransformation solange wiederholt, bis alle Positionen in der Matrix besetzt sind (Beispiel 13.3). Ist der Vektor kein Vielfaches der Zeilen- oder der Spaltenzahl, dann werden alle überzähligen Werte mit einer entsprechenden Warnung verworfen.

Beispiel 13.3 (Matrix durch Auffüllen des Eingabevektors erzeugen)

matrix( 
    c( 
        1, 2, 3
    ), ncol = 4, nrow = 3, byrow = TRUE)

     [,1] [,2] [,3] [,4]
[1,]    1    2    3    1
[2,]    2    3    1    2
[3,]    3    1    2    3

13.1.1 Identitätsmatrix erzeugen

Die Identitätsmatrix ist eine quadratische Diagonalmatrix, wobei an allen Positionen der Hauptdiagonalen der Wert 1 steht. Diese Matrix wird in R mit der Funktion diag() erzeugt (Beispiel 13.4).

Beispiel 13.4 (5x5 Identitätsmatrix)

diag(5)

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    0    0    0    0
[2,]    0    1    0    0    0
[3,]    0    0    1    0    0
[4,]    0    0    0    1    0
[5,]    0    0    0    0    1

13.2 Matrixdimensionen

Die Länge einer Matrix entspricht der Anzahl der Positionen in der Matrix und kann wie bei Vektoren mit der Funktion length() ermittelt werden. Diese Information ist jedoch nicht sehr nützlich.

Die Dimensionalität einer Matrix wird mit der Funktion dim() ausgegeben. Das Ergebnis dieser Funktion gibt einen Vektor der Länge 2 zurück. Das erste Element dieses Vektors enthält die Anzahl der Zeilen und das zweite Element enthält die Anzahl der Spalten der Matrix.

Beispiel 13.5 (Matrixdimensionen mit dim() abfragen)

matrixA |> dim()

[1] 2 3

Die beiden Werte können separat mit den beiden Funktionen nrow() und ncol() abgefragt werden.

Beispiel 13.6 (Matrixdimensionen mit nrow() und ncol() abfragen)

matrixA |> nrow()

[1] 2

matrixA |> ncol()

[1] 3

13.3 Matrixwerte referenzieren

Das Referenzieren von Werten einer Matrix erfolgt analog zum Referenzieren von Vektorwerten. Der Index eines Werts einer Matrix ist über die Zeilen und die Spalten definiert.

Beispiel 13.7 (Matrixwerte referenzieren)

matrixA[2,1]

[1] 3

Über diese Notation ist es möglich eine ganze Zeile oder eine ganze Spalte einer Matrix zu referenzieren.

Beispiel 13.8 (Matrixspalten und -zeilen referenzieren)

matrixA[2,]  # Zeile 2

[1] 3 2 1

matrixA[, 2] # Spalte 2

[1] 2 2

Achtung

Eine Matrix bleibt im Hintergrund eine Vektorstruktur. Wird der Separator zwischen den Zeilen- und Spaltenindex weggelassen und nur ein Index angegeben, dann behandelt R die Matrix als Vektor in der spaltenweisen Form. Die Reihenfolge der Werte kann mit der Funktion as.vector() angezeigt werden. Das gleiche gilt für die Verwendung der Konkatenation ohne das dimensionstrennende Komma.

matrixA |> as.vector()

[1] 1 3 2 2 3 1

matrixA[2,3]

[1] 1

matrixA[c(2,3)]

[1] 3 2

matrixA[,c(2,3)]

     [,1] [,2]
[1,]    2    3
[2,]    2    1

13.3.1 Zeilen- und Spaltenüberschriften

Die Zeilen- und Spalten einer Matrix können in R mit Überschriften benannt werden. Das Benennen erfolgt über einen sog. Namensvektor. Diese Vektor muss die gleiche Länge haben, wie die Anzahl der zu benennenden Zeilen bzw. Spalten der Matrix, wobei die Zeilen und Spalten nicht gleichzeitig benannt werden können.

Merke

Die Zeilen- und Spaltennamen gehören nicht zu den Werten einer Matrix und werden in Operationen in der Regel nicht berücksichtigt.

Beispiel 13.9 (Zeilennamen zuweisen)

rownames(matrixA) <- c("oben", "unten")
colnames(matrixA) <- c("links", "mitte", "rechts")

matrixA

      links mitte rechts
oben      1     2      3
unten     3     2      1

Praxis

Grundsätzlich kann auch die Funktionsverkettung beim Benennen der Zeilen oder Spalten einer Matrix verwendet werden.

matrixA |> rownames() <- c("oben", "unten")

Diese Verwendung sollte allerdings vermieden werden, weil die Zuweisung und der Datenstrom in diesen Fällen gegenläufig wären.

Nachdem eine Zeile oder eine Spalte benannt wurde, werden die Namen in allen nachfolgenden Zugriffen immer in das Ergebnis aufgenommen. Ausserdem können die Namen zur Referenzierung der Werte verwendet werden (Beispiel 13.10).

Beispiel 13.10 (Zeilennamen zur Rerferenzierung verwenden)

matrixA["oben",]

 links  mitte rechts 
     1      2      3

matrixA["unten", "mitte"]

[1] 2

Es ist möglich einzelne Zeilen- oder Spaltennamen zuzuweisen oder zu ändern (Beispiel 13.11).

Beispiel 13.11 (Zeilennamen ändern)

colnames(matrixA)[2] <- "zentrum"

matrixA

      links zentrum rechts
oben      1       2      3
unten     3       2      1

Die Namen einer Matrix lassen sich entfernen, indem den Zeilen- oder Spaltennamen der Wert NULL zugewiesen wird.

Beispiel 13.12 (Zeilennamen entfernen)

rownames(matrixA) <- NULL
colnames(matrixA) <- NULL

matrixA

     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    3    2    1

13.4 Matrizen transponieren

Beim Transponieren einer Matrix werden die Indizes für alle Werte vertauscht. Diese Operation übernimmt die R-Funktion t().

Beispiel 13.13 (Eine Matrix transponieren)

matrixA |> t()

     [,1] [,2]
[1,]    1    3
[2,]    2    2
[3,]    3    1

Merke

Beim Transponieren einer Matrix werden die Spalten in Zeilen bzw. die Zeilen in Spalten umgewandelt.

Tipp

Beim Transponieren werden vorhandene Zeilen- und Spaltennamen mittransponiert.

13.5 Vektorform

Matrizen kennen zwei Arten der Vektorform:

Die spaltenweise Vektorform, bei der die Spaltenvektoren einer Matrix zu einem Vektor konkateniert werden.
Die zeilenweise Vektorform, bei der die Zeilenvektoren einer Matrix zu einem Vektor konkateniert werden.

R speichert eine Matrix intern in ihrer spaltenweisen Vektorform. Die spaltenweise Vektorform kann also direkt über die Funktion as.vector() ermittelt werden. Das gleiche Ergebnis wird erzeugt, wenn die Matrix der Vektorkonkatenation c() als Argument übergeben wird (Beispiel 13.14).

Praxis

Weil bei der Verwendung der Funktion c() nicht leicht ersichtlich ist, dass die Vektorform ermittelt wird, sollte für diese Operation immer die Funktion as.vector() verwendet werden.

Beispiel 13.14 (Spaltenweise Vektorform einer Matrix)

matrixA |> as.vector()

[1] 1 3 2 2 3 1

matrixA |> c()

[1] 1 3 2 2 3 1

Beim Umwandeln einer Matrix in ihre zeilenweise Vektorform wird in R ausgenutzt, dass diese Vektorform identisch mit der spaltenweisen Vektorform ihrer transponierten Matrix ist. Diese Gleichheit ergibt sich aus dem Transponieren, bei der Zeilen in Spalten umgewandelt werden (Beispiel 13.15).

Beispiel 13.15 (Zeilenweise Vektorform einer Matrix)

matrixA |> t() |> as.vector()

[1] 1 2 3 3 2 1

matrixA |> t() |> c()

[1] 1 2 3 3 2 1

13.6 Skalar- und Vektortransformationen

Bei Skalartransformationen wird ein einzelner Wert mit jedem Wert in der Matrix verknüpft.

Beispiel 13.16 (Skalaraddition mit einer Matrix)

2 * matrixA

     [,1] [,2] [,3]
[1,]    2    4    6
[2,]    6    4    2

Dieses Prinzip lässt sich auf Vektoren und Matrizen verallgemeinern. Bei Vektoren muss der Vektor die gleiche Länge wie die Zeilen der Matrix haben. Der Vektor wird dann spaltenweise mit der Matrix verknüpft (Beispiel 13.17).

Beispiel 13.17 (Vektoraddition mit einer Matrix)

matrixA + 1:2

     [,1] [,2] [,3]
[1,]    2    3    4
[2,]    5    4    3

Achtung!

Hat der Vektor keine passende Länge, dann wird die Länge des Vektors durch Wiederholung an die Länge der Matrix angepasst. Die Transformation erfolgt in diesem Fall wie eine Vektortransformation, wobei die Zeilen- und Spaltenstruktur der Matrix erhalten bleibt (Beispiel 13.18).

Beispiel 13.18 (Vektoraddition mit einer Matrix und einem inkompatiblen Vektor)

matrixA + 1:3

     [,1] [,2] [,3]
[1,]    2    5    5
[2,]    5    3    4

Für die Transformation einer Matrix mit einer anderen Matrix mit R müssen beide Matrizen die gleiche Dimensionalität haben. Ist diese Voraussetzung gegeben, dann werden die Werte mit dem gleichen Index paarweise miteinander verknüpft (Beispiel 13.19).

Achtung!

Werden zwei Matrizen unterschiedlicher Dimensionalität verknüpft, dann erweitert R die kleinere der beiden Matrizen nicht!

Beispiel 13.19 (Verknüpfung von zwei Matrizen)

matrixB = matrix(c(1, 2, 2, 1, 1, 2), nrow = 2)

matrixA + matrixB

     [,1] [,2] [,3]
[1,]    2    4    4
[2,]    5    3    3

13.6.1 Matrizen vergleichen

Um die Gleichheit zwischen zwei Matrizen zu vergleichen, müssen zwei Bedingungen erfüllt sein:

Die Länge der beiden Matrizen muss gleich sein.
Die Dimensionalität der beiden Matrizen muss gleich sein.
An allen Positionen müssen die Werte gleich sein.

Diese Prüfung übernimmt in R die Funktion all.equal(). Damit diese Funktion in logischen Ausdrücken verwendet werden kann, muss der Wert an der ersten Position des Ergebnisvektors ausgewertet werden, weil diese Funktion alle Unterschiede zwischen zwei Matrizen zurückgibt (Beispiel 13.20).

Beispiel 13.20 (Zwei Matrizen vergleichen)

all.equal(matrixA, matrixB)

[1] "Attributes: < Length mismatch: comparison on first 1 components >"
[2] "Mean relative difference: 0.5555556"

# Für logische Ausdrücke
all.equal(matrixA, matrixB)[1] == TRUE

[1] FALSE

13.7 Kreuzprodukt

Das Kreuzprodukt (oder Matrixmultiplikation) ist eine Erweiterung der bekannten Multiplikation für Matrizen. Beim Kreuzprodukt muss die linke Matrix genausoviele Spalten haben, wie Zeilenanzahl der rechten Matrix. Das Kreuzprodukt ist dann wie folgt definiert:

\begin{aligned} A \times B &= \begin{bmatrix} a_{11} & a_{12} & \cdots & a_{1n} \\ a_{21} & a_{22} & \cdots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} & a_{m2} & \cdots & a_{mn} \\ \end{bmatrix} \times \begin{bmatrix} b_{11} & b_{12} & \cdots & b_{1p} \\ b_{21} & b_{22} & \cdots & b_{2p} \\ \vdots & \vdots & \ddots & \vdots \\ b_{n1} & b_{n2} & \cdots & b_{np} \\ \end{bmatrix} \\\ \\\ &= \begin{bmatrix} \sum_{i=1}^{n}{a_{1i} \cdot b_{i1}} & \sum_{i=1}^{n}{a_{1i} \cdot b_{i2}} & \cdots & \sum_{i=1}^{n}{a_{1i} \cdot b_{ip}} \\ \sum_{i=1}^{n}{a_{2i} \cdot b_{i1}} & \sum_{i=1}^{n}{a_{2i} \cdot b_{i2}} & \cdots & \sum_{i=1}^{n}{a_{2i} \cdot b_{ip}} \\ \vdots & \vdots & \ddots & \vdots \\ \sum_{i=1}^{n}{a_{mi} \cdot b_{i1}} & \sum_{i=1}^{n}{a_{mi} \cdot b_{i2}} & \cdots & \sum_{i=1}^{n}{a_{mi} \cdot b_{ip}} \\ \end{bmatrix} \end{aligned}

In R wird das Kreuzprodukt mit dem %*%-Operator durchgeführt.

matrixA

     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    3    2    1

(matrixC = matrix(
    c(3, 2, 2, 3, 
      1, 2, 3, 1, 
      1, 2, 1, 1), 
    ncol = 4, 
    byrow = TRUE)
)

     [,1] [,2] [,3] [,4]
[1,]    3    2    2    3
[2,]    1    2    3    1
[3,]    1    2    1    1

matrixA %*% matrixC

     [,1] [,2] [,3] [,4]
[1,]    8   12   11    8
[2,]   12   12   13   12

Praxis

Werden mehrere Matrizen nacheinander multipliziert, so können bekannte Matrizen vorab miteinander multipliziert werden, wenn sie in der Berechnung direkt aufeinanderfolgen.

13.7.1 Zeilen- und Spaltensummen

Für die Zeilensumme ist ein Spaltenvektor notwendig. Dieser Vektor ist ein Einsvektor mit der Länge von der Anzahl der Matrixspalten. Wegen der Regeln für das Kreuzprodukt muss der Einsvektor der rechte Operand des Kreuzprodukts sein (Beispiel 13.21).

Beispiel 13.21 (Zeilensumme)

matrixA %*% rep(1, ncol(matrixA))

     [,1]
[1,]    6
[2,]    6

Für die Spaltensumme ist ein Zeilenvektor notwendig. Dieser Vektor ist ein Einsvektor mit der Länge von der Anzahl der Matrixzeilen. Weil R-Vektoren keine Orientierung haben, sondern immer als Spaltenvektoren behandelt werden, muss der Vektor noch transponiert werden. Bei der Zeilensumme ist ausserdem zu beachten, dass der Einsvektor der linke Operand des Kreuzprodukts sein muss (Beispiel 13.22).

Beispiel 13.22 (Zeilensumme)

t(rep(1, nrow(matrixA))) %*% matrixA

     [,1] [,2] [,3]
[1,]    4    4    4

13.8 Äusseres Vektorprodukt

Das äussere Vektorprodukt erlaubt es Matrizen aus den Werte von zwei Vektoren mit einem beliebigen Operators zu erzeugen. Im Gegensatz zum Kreuzprodukt ist die Orientierung der beiden Vektoren durch das äussere Produkt vorgegeben: Der zweite Vektor wird immer als Zeilenvektor angenommen.

Der Operator des äusseren Produkts ist %o%, wobei als Verknüpfung die Multiplikation verwendet wird. Mit der Funktion outer() können beliebige Operatoren (d.h. Funktionen mit zwei Operatoren) angegeben werden.

Beispiel 13.23 (Äusseres Produkt mit der Addition als Operator)

outer(1:3, 0:5, `+`)

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1    2    3    4    5    6
[2,]    2    3    4    5    6    7
[3,]    3    4    5    6    7    8

In der Anwendung sind logische Ausdrücke als Operatoren für das äussere Produkt von besonderer Bedeutung. In R müssen alle logischen Ausdrücke, die nicht nur eine Vergleichsoperation umfassen, als Funktion der outer()-Funktion übergeben werden (s. Beispiel 13.25).

Praxis

Mit dem äusseren Produkt über logische Ausdrücle lassen sich beliebige Matrizenstrukturen aus Sequenzen erzeugen.

13.8.1 Dreieckmatrizen erzeugen

Dreiecksmatrizen werden in der Regel über das äussere Produkt zweier Sequenzen erzeugt. Es wird zwischen oberen und unteren Dreiecksmatrizen unterschieden. Bei einer oberen Dreiecksmatrix sind alle Positionen mit Zeilenindizes, welche kleiner als der jeweilige Spaltenindex sind, mit dem Wert 1 und alle anderen Position mit 0 belegt. Bei einer unteren Dreieckmatrix sind die Positionen mit dem Wert 1 belegt, an denen der Zeilenindex grösser als der Spaltenindex ist. Alternativ erzeugen die beiden Funktionen upper.tri() und lower.tri() die gewünschte Dreiecksmatrix aus einer existierenden Matrix.

Beispiel 13.24 (Erzeugen einer unteren Dreiecksmatrix)

1 * outer(1:4, 1:4, `>=`)

     [,1] [,2] [,3] [,4]
[1,]    1    0    0    0
[2,]    1    1    0    0
[3,]    1    1    1    0
[4,]    1    1    1    1

# etwas expressiver
1 * lower.tri(diag(4), diag = TRUE)

     [,1] [,2] [,3] [,4]
[1,]    1    0    0    0
[2,]    1    1    0    0
[3,]    1    1    1    0
[4,]    1    1    1    1

13.8.2 Vorgänger- und Nachfolgersummen

Vorgänger- und Nachfolgersummen bilden die Summe aus aufeinanderfolgenden Werten eines Vektors. Diese Summe kann durch die Kombination einer Matrixmultiplikation mit dem äusseren Produkt errreicht werden. Für diese Summen wird eine Matrix benötigt, in welcher an allen zu summierenden Positionen der Wert 1 (das neutrale Element der Multiplikation) steht.

Beispiel 13.25 bestimmt die Summe vom Wert und den beiden Vorgängern einer bestimmten Position in einem Vektor. Die Subtraktion mit 2 zeigt an, wie viele Werte vor der aktuellen Position berücksichtigt werden sollen.

Beispiel 13.25 (Vorgängersumme für einen Vektor der Länge 10)

vektor = 1:10
vektor %*% outer(
    1:10, 
    1:10, 
    function (a, b) (b >= a & a >= b - 2)
)

     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,]    1    3    6    9   12   15   18   21   24    27

13.9 Co-Occurence Matrizen

Eine Co-Occurence Matrix oder Kontingenztabelle aus zwei Vektoren lässt sich am leichtesten mit der table()-Funktion erstellen. Diese Funktion zählt das gemeinsame Auftreten von Werten in zwei gleichlangen Vektoren von beliebigen Datentyp.

Das Ergebnis ist eine benannte Matrix, wobei die Zeilen den Werten im ersten Vektor und die Spalten den Werten im zweiten Vektor entsprechen.

Beispiel 13.26 (Kontingenztabelle für zwei Vektoren)

v1 = c(1, 2, 4, 3, 2, 1, 1, 2, 4)
v2 = c(9, 8, 7, 7, 7, 8, 9, 9, 8)

(ctable = table(v1, v2))

ctable[,2]

1 2 3 4 
1 1 0 1

ctable[3,]

7 8 9 
1 0 0

13.10 Determinanten

Die Determinante einer quadratischen Matrix A wird mit der det()-Funktion ermittelt.

Beispiel 13.27 (Determinante einer Matrix bestimmen)

# Eine quadratische Matrix aus matrixA erzeugen
(matrixQ = matrixA %*% t(matrixA))

     [,1] [,2]
[1,]   14   10
[2,]   10   14

det(matrixQ)

[1] 96

13.11 Eigenwerte

Die Eigenwerte \lambda und Eigenvektoren einer quadratischen Matrix A werden mit der Funktion eigen() bestimmt. Diese Funktion gibt eine benannte Liste zurück. Unter values finden sich die Eigenwerte der Matrix und unter vectors sind die Eigenvektoren als Spaltenvektoren gespeichert.

Beispiel 13.28 (Eigenwerte und Eigenvektoren einer Matrix bestimmen)

basisQ = eigen(matrixQ)

basisQ[["values"]] # oder basisQ$values

[1] 24  4

basisQ[["vectors"]] # oder basisQ$vectors

          [,1]       [,2]
[1,] 0.7071068 -0.7071068
[2,] 0.7071068  0.7071068

13.12 Inversematrix

Die Inverse A^{-1} einer quadratischen Matrix A wird in R mit der Funktion solve() bestimmt (Beispiel 13.29).

Beispiel 13.29 (Inverse Matrix berechnen)

solve(matrixQ)

           [,1]       [,2]
[1,]  0.1458333 -0.1041667
[2,] -0.1041667  0.1458333

13.13 `Matrix`-Bibliothek

Das Kreuzprodukt, das äussere Produkt und das Transponieren werden durch R automatisch bereitgestellt. Für komplexere Aufgaben oder sehr grossere Matrizen dient die Bibliothek Matrix (Bates et al., 2023). Diese Bibliothek gehört zur R-Standardinstallation und ist auf jedem System vorhanden. Die Bibliothek stellt alle relevanten Funktionen für Matrix-Operationen, die für mathematische Matrix-Operationen benötigt werden.

Diese Bibliothek sollte immer geladen werden, wenn sehr grosse Matrizen oder Matrizen mit vielen 0-Werten verwendet werden. Besonders für den zweiten Fall ist die sog. Sparse Matrix (deutsch “dünnbesetzte Matrix”) von besonderer Bedeutung. Eine dünnbesetzte Matrix ist eine Matrix mit vielen 0-Werten, wobei viel “mehr als ein Drittel der Positionen” bedeutet. In solchen Matrizen lässt R die 0-Werte weg, so dass diese Werte keinen Speicher benötigen und keine Berechnungen für die entsprechenden Operationen (insbesondere beim Kreuzprodukt) durchgeführt werden. Abgesehen von dieser speziellen Behandlung der 0-Werte unterscheiden sich dünnbesetzte Matrizen in R nicht von anderen Matrizen.

Beispiel 13.30 (Dünnbesetzte Matrix erzeugen)

library(Matrix)


Attache Paket: 'Matrix'

Die folgenden Objekte sind maskiert von 'package:tidyr':

    expand, pack, unpack

Matrix( matrix(c(0, 1, 0, 0, 0, 1, 2, 0, 0), ncol = 3), sparse = TRUE)

3 x 3 sparse Matrix of class "dgCMatrix"
          
[1,] . . 2
[2,] 1 . .
[3,] . 1 .

Die Matrix-Bibloiothek stellt ausserdem viele Hilfreiche Funktionen für die Arbeit mit Matrizen bereit. Dazu gehören beispielsweise die Funktionen colSums() und rowSums(), mit denen die Spalten- bzw. die Zeilensummen berechnet werden. Beispiel 13.22 und Beispiel 13.21 lassen sich so vereinfachen (Beispiel 13.31).

Beispiel 13.31 (Zeilen- und Spaltensumme mit der Matrix-Bibliothek)

colSums(matrixA)

[1] 4 4 4

rowSums(matrixA)

[1] 6 6

Die Bibliothek stellt ausserdem mit der band()-Funktion eine komfortable Methode für diagonale Band-Matrizen bereit. Eine Bandmatrix heisst eine quadratische Matrix, die ein diagonales Werteband enthält. Mit dieser Funktion lassen sich Band-Matrize für gleitende Summen (Beispiel 13.25) leichter erzeugen (Beispiel 13.32)

Beispiel 13.32 (Vorgängersumme mit der band()-)

band(Matrix(1, 10, 10, sparse = TRUE), 0, 2)

10 x 10 sparse Matrix of class "dtCMatrix"
                         
 [1,] 1 1 1 . . . . . . .
 [2,] . 1 1 1 . . . . . .
 [3,] . . 1 1 1 . . . . .
 [4,] . . . 1 1 1 . . . .
 [5,] . . . . 1 1 1 . . .
 [6,] . . . . . 1 1 1 . .
 [7,] . . . . . . 1 1 1 .
 [8,] . . . . . . . 1 1 1
 [9,] . . . . . . . . 1 1
[10,] . . . . . . . . . 1

vektor %*% band(Matrix(1, 10, 10, sparse = TRUE), 0, 2)

1 x 10 Matrix of class "dgeMatrix"
     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
[1,]    1    3    6    9   12   15   18   21   24    27

13.1 Matrizen erstellen

13.1.1 Identitätsmatrix erzeugen

13.2 Matrixdimensionen

13.3 Matrixwerte referenzieren

13.3.1 Zeilen- und Spaltenüberschriften

13.4 Matrizen transponieren

13.5 Vektorform

13.6 Skalar- und Vektortransformationen

13.6.1 Matrizen vergleichen

13.7 Kreuzprodukt

13.7.1 Zeilen- und Spaltensummen

13.8 Äusseres Vektorprodukt

13.8.1 Dreieckmatrizen erzeugen

13.8.2 Vorgänger- und Nachfolgersummen

13.9 Co-Occurence Matrizen

13.10 Determinanten

13.11 Eigenwerte

13.12 Inversematrix

13.13 Matrix-Bibliothek

13.13 `Matrix`-Bibliothek