---
format: pdf
fontsize: 11pt
bibliography: ../MV_Referenzen_Seminar.bib
include-in-header: ../MV_Header_Seminar.tex
lang: de
---


<!-- Sitzung 2: Matrizen -->
# (2) Matrizen

Ziel dieser Sitzung ist es, die Matrizenrechnung in **R** anhand der in der Vorlesung diskutierten Beispiele nachzuvollziehen und optional weitere Übungsaufgaben mithilfe von **R** zu lösen.


<!-- Abschnitt 1: Grundlagen -->
## Grundlegende Matrixoperationen

Wir betrachten zunächst die spaltenweise und zeilenweise Definition von Matrizen in **R** anhand zweier in der Vorlesung gegebener Beispiele zur Matrixaddition und Matrixsubtraktion. Man beachte, dass die zeilenweise Definition einer Matrix, die mithilfe des Arguments `byrow = TRUE` (non-default) erreicht wird, eine höhere Korrespondenz zwischen **R**-Codebild und **R** Repräsentation ermöglicht.

\small
```{r}
# spaltenweise Definition von A (R-Default)
A = matrix(c( 2, 1,-3, 6, 0, 5), nrow = 2)
print(A)
```

\small
```{r}
# zeilenweise Definition von B
B = matrix(c( 4, 1, 0,
             -4, 2, 0),
           nrow  = 2,
           byrow = TRUE)
print(B)
```

\normalsize
Die Addition und Subtraktion von Matrizen werden in **R** dann mit den Operatoren `+` und `-` implementiert. Entsprechend der in der Vorlesung eingeführten Rechenregeln ergeben sich

\small
```{r}
# Addition
C = A + B
print(C)
```

\normalsize
und

\small
```{r}
# Subtraktion
D = A - B
print(D)
```

\normalsize
Das in der Vorlesung betrachtete Beispiel zur Skalarmultiplikation ergibt sich mit dem Skalarmultiplikationsoperator `*` wie folgt.

\small
```{r}
# Definitionen
A = matrix(c(3,1,1,
             5,2,5,
             2,7,1,
             3,4,2),
           nrow = 4,
           byrow = TRUE)
c = -3

# Skalarmultiplikation
B = c*A
print(B)
```

\normalsize
Das in der Vorlesung betrachtete Beispiel zur Matrixtransposition schließlich ergibt sich mit dem Transpositionsoperator `t()` wie folgt.

\small
```{r}
# Definition
A = matrix(c(2,3,0,
             1,6,5),
           nrow = 2,
           byrow = TRUE)

# Transposition
AT = t(A)
print(A)
print(AT)
```


<!-- Abschnitt 2: Multiplikation -->
## Multiplikation von Matrizen

\normalsize
Das erste in der Vorlesung betrachtete Beispiel zur Matrixmultiplikation implementiert man in **R** mithilfe des Matrixmultiplikationsoperators `%*%` wie folgt.

\small
```{r}
# Definitionen
A = matrix(c( 2,-3, 0,
              1, 6, 5),
           nrow  = 2,
           byrow = TRUE)
B = matrix(c( 4, 2,
             -1, 0,
              1, 3),
           nrow  = 3,
           byrow = TRUE)

# Matrixmultiplikation
C = A %*% B
print(C)
```

\pagebreak
\normalsize
Das zweite Beispiel zur Matrixmultiplikation ergibt demzufolge so:

\small
```{r}
# Definitionen
A = matrix(c( 2,-3, 0,
              1, 6, 5),
           nrow  = 2,
           byrow = TRUE)
B = matrix(c( 4, 2,
             -1, 0,
              1, 3),
           nrow  = 3,
           byrow = TRUE)

# Matrixmultiplikation
D = B %*% A
print(D)
```

\normalsize
Ist die Multiplikation zweier in **R** definierter Matrizen nicht definiert, d.h. stimmt die Anzahl der Spalten der ersten Matrix nicht mit der Anzahl der Zeilen der zweiten Matrix überein, so ergibt sich ein Fehler.

\small
```{r, error = T}
# Beispiel für eine undefinierte Matrixmultipliation
E = t(A) %*% B      # (3 x 2)(3 x 2)
```


<!-- Abschnitt 3: Inverse -->
\pagebreak
## Inverse Matrizen

\normalsize
Inverse Matrizen berechnet man in **R** für gewöhnlich mit dem Befehl `solve()`. Für das in der Vorlesung betrachtete Beispiel einer invertierbaren $2 \times 2$ Matrix ergibt sich entsprechend folgender **R**-Code. (Man beachte, dass sich bei der rechtsseitigen Multiplikation von $A$ mit ihrer inversen minimale Rundungsfehler ergeben.)

\small
```{r}
# Definition
A = matrix(c(2,1,
             3,4),
           nrow  = 2,
           byrow = TRUE)

# Berechnen von A^{-1}
print(solve(A))

# Probe: Multiplikation von A^{-1} mit A
print(solve(A) %*% A)
print(A %*% solve(A))
```

\normalsize
Das in der Vorlesung betrachtete Beispiel für eine nicht-invertierbare Matrix ist auch numerisch nicht invertierbar, wie folgender Beispielcode in **R** demonstriert.

\small
```{r, error = T}
# nicht-invertierbare Matrizen sind auch numerisch nicht-invertierbar (= singulär)
B = matrix(c(1,0,
             0,0),
           nrow  = 2,
           byrow = TRUE)
solve(B)
```


<!-- Abschnitt 4: Determinanten -->
## Determinanten

\normalsize
Determinanten berechnet man in **R** mithilfe des Befehls `det()`. Für die in der Vorlesung betrachteten Beispiele ergibt sich folgender **R**-Code.

\small
```{r}
# Beispiel 1
A = matrix(c(2,1,                  # Matrixdefinition
             3,4),
           nrow = 2,
           byrow = TRUE)
det(A)                             # Determinantenberechnung

B = matrix(c(1,0,                  # Matrixdefinition
             0,0),
           nrow = 2,
           byrow = TRUE)
det(B)                             # Determinantenberechnung

# Beispiel 2
C = matrix(c(2,0,0,                # Matrixdefinition
             0,1,0,
             0,0,3),
           nrow = 3,
           byrow = TRUE)
det(C)                             # Determinantenberechnung
```


<!-- Abschnitt 5: Übungen -->
\pagebreak
## Weitere Aufgaben zur Übung

\normalsize
(1) Es seien 
\begin{equation}
A :=
\begin{pmatrix*}[r]
1 & 2 \\
2 & 1
\end{pmatrix*}, \quad
B :=
\begin{pmatrix*}[r]
3 & 0 \\
1 & 2
\end{pmatrix*},
\quad \mbox{und} \quad
c := 2
\end{equation}
Berechnen Sie
\begin{equation}
D := c\left(A - B^T\right)
\quad \mbox{und} \quad
E := \left(cA\right)^T + B.
\end{equation}
mit **R**.

```{r, eval = F, echo = F}
# Definition
A = matrix(c(1,2,
             2,1),
           nrow  = 2,
           byrow = TRUE)
B = matrix(c(3,0,
             1,2),
           nrow  = 2,
           byrow = TRUE)
c = 2

# Berechnung
print(A)
print(B)
print(c*(A - t(B)))
print(t(c*A) + B)
```

(2) Es seien
\begin{equation}
A :=
\begin{pmatrix*}[r]
1 & 2 & 3 \\
4 & 5 & 6 \\
3 & 2 & 0
\end{pmatrix*}, \quad
B :=
\begin{pmatrix*}[r]
1 & 2 & 2 \\
1 & 3 & 1 \\
2 & 0 & 0
\end{pmatrix*}
\quad \mbox{und} \quad
C :=
\begin{pmatrix*}[r]
1 \\ 3 \\ 2
\end{pmatrix*}.
\end{equation}
Berechnen Sie die Matrixprodukte
\begin{equation}
AB, \quad\quad
B^TA^T, \quad\quad
\left( B^T A^T \right)^T \quad \mbox{und} \quad
AC
\end{equation}
mit **R**.

```{r, eval = F, echo = F}
# Definition
A = matrix(c(1,2,3,
             4,5,6,
             3,2,0),
           nrow  = 3,
           byrow = TRUE)
B = matrix(c(1,2,2,
             1,3,1,
             2,0,0),
           nrow  = 3,
           byrow = TRUE)
C = matrix(c(1,3,2),
           nrow  = 3,
           byrow = TRUE)

# Berechnung
print(A)
print(B)
print(C)
print(A %*% B)
print(t(B) %*% t(A))
print(t(t(B) %*% t(A)))
print(A %*% C)
```

(3) Invertieren Sie die Matrizen $A$ und $B$ aus der vorherigen Aufgabe in **R** mithilfe von `solve()` und überprüfen Sie, dass es sich bei den erzielten Ergebnissen tatsächlich um die Inversen von $A$ und $B$ handelt.

```{r, eval = F, echo = F}
# Matrixinversion
A = matrix(c(1,2,3,
             4,5,6,
             3,2,0),
           nrow  = 3,
           byrow = TRUE)
B = matrix(c(1,2,2,
             1,3,1,
             2,0,0),
           nrow  = 3,
           byrow = TRUE)

# Berechnung
print(solve(A))
print(solve(B))
print(solve(A) %*% A)
print(solve(B) %*% B)
print(solve(B) %*% B)
```

(4) Berechnen Sie die Determinanten von
\begin{equation}
A := \begin{pmatrix} 2 & 1 \\ 1 & 2 \end{pmatrix}, \quad
B := \begin{pmatrix} 3 & 2 & 1 \\ 2 & 3 & 2 \\ 1 & 2 & 3 \end{pmatrix} \quad \mbox{und} \quad
C := \mbox{diag}(1,2,3)
\end{equation}
mit **R**.

```{r, eval = F, echo = F}
# Definition
A = matrix(c(2,1,
             1,2),
           nrow  = 2,
           byrow = TRUE)
B = matrix(c(3,2,1,
             2,3,2,
             1,2,3),
           nrow  = 3,
           byrow = TRUE)
C = diag(c(1,2,3))

# Berechnung
print(det(A))
print(det(B))
print(det(C))
```