Add chapter concerning vector iteration

Notes/Semester 3/HM1 - Höhere Mathematik/Zusammenfassung.md

@@ -66,8 +66,11 @@
   - [Komplexe Zahlen](#komplexe-zahlen)
     - [Rechen-Regeln](#rechen-regeln)
   - [Eigenwerte und Eigenvektoren](#eigenwerte-und-eigenvektoren)
+    - [Numerische Bestimmung von Eigenwerten und Eigenvektoren](#numerische-bestimmung-von-eigenwerten-und-eigenvektoren)
+      - [Theorie](#theorie)
+      - [$QR$-Verfahren](#qr-verfahren)
+    - [Vektor-Iteration](#vektor-iteration)
   - [Formelbuchstaben](#formelbuchstaben)
-  - [Glossar](#glossar)
 
 ## Einführung
 ### Einsatzgebiet
@@ -1486,6 +1489,150 @@ Für den Eigenwert $\lambda$ von $A$ bilden Eigenvektoren zum Eigenwert $\lambda
 
 </div>
 
+### Numerische Bestimmung von Eigenwerten und Eigenvektoren
+#### Theorie
+
+<div class="formula">
+
+***Ähnliche Matrizen:***
+
+Eine Matrix $B$ ist zu einer Matrix $A$ ähnlich, wenn für eine beliebige Matrix $T$ gilt:
+
+$$B = T^{-1} \cdot A \cdot T$$
+
+***Diagonalisierbarkeit:***
+
+Eine Matrix $A$ ist _diagonalisierbar_, wenn für eine Matrix $T$ das Ergebnis $D$ von
+
+$$D = T^{-1} \cdot A \cdot T$$
+
+eine Diagonalmatrix ist.
+
+</div>
+<div class="letters">
+
+  - $A$: Beliebige Matrix
+  - $B$: Ergebnis einer Transformation der Matrix $A$
+  - $D$: Ergebnis einer Transformation der Matrix $A$, welche eine Diagonalmatrix ist
+  - $T$: Beliebige Transformations-Matrix
+
+</div>
+
+<div class="formula">
+
+***Eigenwerte und Eigenvektoren ähnlicher/diagonalisierbarer Matrizen:***
+
+  - Es seien $A$ und $B$ zueinander ähnliche Matrizen
+    - $A$ und $B$ haben dieselben Eigenwerte inkl. deren algebraische Vielfachheit
+    - Ist $x$ ein Eigenvektor zum Eigenwert $\lambda$ von $B$, so ist $T \cdot x$ ein Eigenvektor zum Eigenwert $\lambda$ von $A$
+    - Wenn $A$ diagonalisierbar ist gilt zudem folgendes:
+      - Für $D = T^{-1} \cdot A \cdot T$
+      - Die $n$ Diagonal-Elemente von $D$ sind die Eigenwerte von $A$
+      - Die $n$ linear unabhängigen Eigenvektoren von $A$ sind die Spalten des verwendeten $T$
+
+</div>
+
+#### $QR$-Verfahren
+Das $QR$-Verfahren ist ein iteratives Verfahren zur Bestimmung von Eigenwerten einer Matrix $A$.
+
+Der Vorgang ist dabei folgender:
+
+ 1. $A_0 = A$
+ 2. $P_0 = I_n$
+ 3. Für $i = 0, 1, 2, \dots, \infin$:
+    1. $QR$-Zerlegung durchführen: $A_i = Q_i \cdot R_i$
+    2. $A_{i + 1} = R_i \cdot Q_i$
+    3. $P_{i + 1} = P_i \cdot Q_i$
+ 4. $P_i$ zurückgeben
+
+***Code-Beispiel:***
+
+```py
+from numpy import array, identity, sign, sqrt, square, sum, zeros
+
+def qr(A):
+    A = array(A)
+    n = A.shape[0]
+    R = A.reshape((n, n))
+    Q = identity(n)
+
+    for i in range(n - 1):
+        I = identity(n - i)
+        Qi = identity(n)
+        e = zeros((n - i, 1))
+        e[0][0] = 1
+        a = R[i:,i:i + 1]
+        v = a + sign(a[0]) * sqrt(sum(square(a))) * e
+        u = (1 / sqrt(sum(square(v)))) * v
+        H = I - 2 * u @ u.T
+        Qi[i:,i:] = H
+        R = Qi @ R
+        Q = Q @ Qi.T
+        R[i + 1:,i:i + 1] = zeros((n - (i + 1), 1))
+    return [Q, R]
+
+def EV(A, iterations):
+    A = array(A)
+    n = A.shape[0]
+    P = identity(n)
+    for i in range(iterations):
+        [Q, R] = qr(A)
+        A = R @ Q
+        P = P @ Q
+    return [A, P]
+```
+
+### Vektor-Iteration
+
+Die Vektor-Iteration, auch **von-Mises-Iteration** genannt, erlaubt das Bestimmen des grössten Eigenwertes $\lambda$ einer diagonalisierbaren Matrix $A$.
+
+<div class="formula">
+
+***Spektral-Radius:***
+
+Der Spektral-Radius $\rho(A)$ definiert den höchsten Eigenwert der Matrix $A$:
+
+$$\rho(A) = \max\{|\lambda|\; | \; \lambda \text{ ist ein Eigenwert von }A \in \mathbb{R}^{n \times n}\}$$
+
+</div>
+<div class="formula">
+
+Sei $A$ eine diagonalisierbare Matrix mit den Eigenwerten $\lambda_1, \dots, \lambda_n$ wobei $\lambda_1$ betragsmässig am höchsten ist:
+
+$$|\lambda_1| > |\lambda_2| \ge \dots \ge | \lambda_n|$$
+
+Der grösste Eigenwert $\lambda_1$ und der dazugehörige Eigenvektor $v$ lässt sich mit der Vektor-Iteration bestimmen.
+
+Zunächst muss ein beliebiger Startvektor $v_0 \in \mathbb{C}^n$ mit Länge $1$ gewählt werden.
+
+Als nächstes wird für $k = 0, \dots, \infin$ folgendes ausgeführt:
+
+$$v^{(k + 1)} = \frac{A \cdot v^{(k)}}{||A \cdot v^{(k)}||_2}$$
+
+$$\lambda^{(k + 1)} = \frac{(v^{(k)})^T \cdot A \cdot v^{(k)}}{(v^{(k)})^T \cdot v^{(k)}}$$
+
+</div>
+
+***Code-Beispiel:***
+
+```py
+from numpy import array, linalg
+
+def vectorIteration(A, v, iterations = 10):
+    l = 0
+    v = array(v)
+    v = v.reshape(len(v), 1)
+    for i in range(iterations):
+        l = ((v.T @ A @ v) / (v.T @ v)).item()
+        v = (A @ v) / (linalg.norm(A @ v, ord=2))
+        print()
+        print(f"k: {i + 1}")
+        print(f"x: {v}")
+        print(f"λ: {l}")
+
+    return [v, l]
+```
+
 ## Formelbuchstaben
 <div class="letters">
 
@@ -1509,12 +1656,12 @@ Für den Eigenwert $\lambda$ von $A$ bilden Eigenvektoren zum Eigenwert $\lambda
   - $Q$: Orthogonal-Matrix in der $QR$-Zerlegung
   - $R$: Obere Dreiecksmatrix
   - $Rg(A)$: Der Rang der Matrix $A$ (Anzahl Zeilen $\not = 0$, die nach Gauss-Elimination übrig bleiben)
+  - $T$: Transformations-Matrix
   - $x$: Darzustellender Wert
   - $x_n$: Die $n$-te Approximation von $x$
   - $\tilde{x}$: Approximation/Annäherung an $x$
   - $x^{(k)}$: Die Annäherung von $x$ in der $k$-ten Iteration
   - $\lambda$: Eigenwert einer Matrix
+  - $\rho(A)$: Spektral-Radius der Matrix $A$ (siehe Vektor-Iteration)
 
 </div>
-
-## Glossar