LinearAlg added, css: padding vor code-fold triangle

2024-04-20 00:33:10 +02:00 · 2024-04-20 00:33:10 +02:00 · 81c688bc21
commit 81c688bc21
parent b3733b515e
3 changed files with 371 additions and 0 deletions
--- a/_quarto.yml
+++ b/_quarto.yml
@ -53,6 +53,7 @@ book:
    - chapters/9_functs.qmd
    - chapters/6_ArraysEtcP1.qmd
    - chapters/7_ArraysP2.qmd
+    - chapters/11_LinAlg.qmd
    - chapters/10_Strings.qmd
  #  - chapters/makie.qmd
  #  - chapters/ablaufsteuerung.qmd
--- a/chapters/11_LinAlg.qmd
+++ b/chapters/11_LinAlg.qmd
@ -0,0 +1,367 @@
+# Lineare Algebra 
+
+## Normen 
+
+Um Fragen wie Kondition oder Konvergenz eines Algorithmus studieren zu können, brauchen wir eine Metrik. Für lineare Räume ist es zweckmäßig, die Metrik über eine Norm zu definieren:
+$$
+d(x,y) := ||x-y||
+$$
+
+### $p$-Normen
+
+Eine einfache Klasse von Normen im $ℝ^n$ sind die $p$-Normen
+$$
+||\mathbf{x}||_p = \left(\sum |x_i|^p\right)^\frac{1}{p},
+$$
+die die  die euklidische Norm $p=2$ verallgemeinern.  
+
+Sei $x_{\text{max}}$ die _betragsmäßig_ größte Komponente von $\mathbf{x}\in ℝ^n$. Dann gilt  stets 
+$$ |x_{\text{max}}| \le ||\mathbf{x}||_p  \le n^\frac{1}{p} |x_{\text{max}}|  
+$$
+(Man betrachte einen Vektor, dessen Komponenten alle gleich $x_{\text{max}}$ sind bzw. einen Vektor, dessen Komponenten außer $x_{\text{max}}$  alle gleich Null sind.)
+
+Damit folgt 
+$$
+\lim_{p \rightarrow \infty}  ||\mathbf{x}||_p = |x_{\text{max}}| =:  ||\mathbf{x}||_\infty.
+$$
+
+
+In Julia definiert das `LinearAlgebra`-Paket eine Funktion `norm(v, p)`.
+
+```{julia}
+using LinearAlgebra
+
+v = [3, 4]
+w = [-1, 2, 33.2]
+
+@show norm(v)  norm(v, 2)  norm(v, 1) norm(v, 4) norm(w, Inf);
+```
+
+- Wenn das 2. Argument `p` fehlt, wird `p=2` gesetzt. 
+- Das 2. Argument kann auch `Inf` (also $+\infty$) sein. 
+- Das 1. Argument kann ein beliebiger Container voller Zahlen sein. Die Summe $\sum |x_i|^p$ erstreckt sich über *alle* Elemente des Containers. 
+- Damit ist für eine Matrix `norm(A)` gleich der _Frobenius-Norm_ der Matrix `A`. 
+
+```{julia}
+A = [1 2 3
+     4 5 6
+     7 8 9]
+norm(A)      # Frobenius norm
+```
+
+
+
+Da Normen homogen unter Multiplikation mit Skalaren sind, 
+$||\lambda \mathbf{x}|| = |\lambda|\cdot||\mathbf{x}||$, sind sie durch die Angabe der Einheitskugel vollständig bestimmt. Subadditivität der Norm (Dreiecksungleichung) ist äquivalent zur Konvexität der Einheitskugel.
+
+```{julia}
+#| code-fold: false
+#| fig-cap: "Einheitskugeln im $ℝ^2$ für verschiedene $p$-Normen: $p$=0.8; 1; 1.5; 2; 3.001 und 1000"
+using Plots
+
+colors=[:purple, :green, :red, :blue,:aqua, :black]
+x=LinRange(-1, 1, 1000)
+y=LinRange(-1, 1, 1000)
+
+fig1=plot()
+for p ∈ (0.8, 1, 1.5, 2, 3.001, 1000)
+    contour!(x,y, (x,y) -> p * norm([x, y], p), levels=[p], aspect_ratio=1, 
+        cbar=false, color=[pop!(colors)], contour_labels=true, ylim=[-1.1, 1.1])
+end
+fig1
+```
+Wie man sieht, muß $p\ge 1$ sein, damit die Einheitskugel konvex und $||.||_p$ eine Norm ist.
+
+Die Julia-Funktion `norm(v, p)` liefert allerdings für beliebige Parameter `p` ein Ergebnis.  
+
+
+### Induzierte Normen (Operatornormen)
+
+Matrizen $A$ repräsentieren lineare Abbildungen $\mathbf{v}\mapsto A\mathbf{v}$. Die von einer Vektornorm Induzierte Matrixnorm beantwortet die Frage: 
+
+> _„Um welchen Faktor kann ein Vektor durch die Transformation $A$ maximal gestreckt werden?“_
+
+Auf Grund der Homogenität der Norm unter Multiplikation mit Skalaren reicht es aus, das Bild der Einheitskugel unter der Transformation $A$ zu betrachten. 
+
+::: {.callout-tip}
+## Definition
+Sei $V$ ein Vektorraum mit einer Dimension $0<n<\infty$ und
+ $A$ eine $n\times n$-Matrix. Dann ist 
+$$
+||A||_p = \max_{||\mathbf{v}||_p=1} ||A\mathbf{v}||_p
+$$  
+:::
+
+Induzierte Normen lassen sich für allgemeines $p$ nur schwer berechnen. Ausnahmen sind die Fälle
+
+- $p=1$: Spaltensummennorm
+- $p=2$: Spektralnorm und
+- $p=\infty$: Zeilensummennorm
+
+Diese 3 Fälle sind in Julia in der Funktion `opnorm(A, p)` aus dem `LinearAlgebra`-Paket implementiert, wobei wieder `opnorm(A) = opnorm(A, 2)` gilt.
+
+```{julia}
+A = [ 0    1
+      1.2  1.5 ]
+
+@show opnorm(A, 1) opnorm(A, Inf) opnorm(A, 2) opnorm(A);
+```
+
+Das folgende Bild zeigt die Wirkung von $A$ auf Einheitsvektoren (Code durch anklicken sichtbar):
+```{julia}
+#| code-fold: true
+#| fig-cap: "Bild der Einheitskugel unter $v \\mapsto Av$"
+
+using CairoMakie
+
+# Makie bug  https://github.com/MakieOrg/Makie.jl/issues/3255
+# Würgaround https://github.com/MakieOrg/Makie.jl/issues/2607#issuecomment-1385816645
+tri = BezierPath([
+    MoveTo(Point2f(-0.5, -1)), LineTo(0, 0), LineTo(0.5, -1), ClosePath()
+])
+
+A = [ 0    1
+      1.2  1.5 ]
+
+colorlist = resample_cmap(:hsv, 12)
+t = LinRange(0, 1, 100)
+xs = sin.(2π*t)
+ys = cos.(2π*t)
+Axys = A * [xs, ys]
+
+u = [sin(n*π/6) for n=0:11]
+v = [cos(n*π/6) for n=0:11]
+x = y = zeros(12)
+
+Auv = A * [u,v] 
+
+fig2 = Figure(size=(800, 400))
+lines(fig2[1, 1], xs, ys, color=t, linewidth=5, colormap=:hsv, axis=(; aspect = 1, limits=(-2,2, -2,2), 
+      title=L"$\mathbf{v}$", titlesize=30))
+arrows!(fig2[1,1], x, y, u, v, arrowsize=10, arrowhead=tri, colormap=:hsv, linecolor=range(0,11), linewidth=3)
+
+Legend(fig2[1,2], MarkerElement[], String[], L"⟹", width=40, height=30, titlesize=30, framevisible=false)
+
+lines(fig2[1,3], Axys[1], Axys[2], color=t, linewidth=5, colormap=:hsv, axis=(; aspect=1, limits=(-2,2, -2,2), 
+      title=L"$A\mathbf{v}$", titlesize=30))
+arrows!(fig2[1,3], x, y, Auv[1], Auv[2], arrowsize=10, arrowhead=tri, colormap=:hsv, linecolor=range(0,11), 
+      linewidth=3)
+
+fig2
+```
+
+## Matrixfaktorisierungen
+
+Eine Basisaufgabe der numerischen linearen Algebra ist die Lösung von linearen Gleichungssystemen
+$$
+A\mathbf{x} = \mathbf{b}.
+$$
+Falls keine Lösung existiert, ist man oft an der bestmöglichen Annäherung an eine Lösung interessiert, d.h., gesucht wird der Vektor $\mathbf{x}$, für den 
+$$
+||A\mathbf{x} - \mathbf{b}||  \rightarrow \min.
+$$ 
+
+
+
+# Das _Linear Algebra_-Paket: eine kurze Auswahl
+
+- zusätzliche Matrix-Typen
+
+  - Subtypen von `AbstractMatrix`: genauso verwendbar, wie andere Matrizen
+  - `Tridiagonal`
+  - `SymTridiagonal`
+  - `Symmetric`
+  - `UpperTriangular`
+  - ...
+
+
+- Arithmetik: Matrixmultiplikation, `inv`, `det`, `exp`
+
+- Lineare Gleichungssysteme: `\`
+
+- Matrixfaktorisierungen
+
+  - `LU`
+  - `QR`
+  - `Cholesky`
+  - `SVD`
+  - ...
+  
+- Eigenwerte/-vektoren
+  
+  - `eigen`, `eigvals`, `eigvecs`
+  
+  
+- Zugriff auf BLAS/LAPACK-Funktionen
+
+## Matrixtypen
+
+
+
+```julia
+using LinearAlgebra
+```
+
+
+```julia
+A = SymTridiagonal(fill(1.0, 4), fill(-0.3, 3))
+```
+
+
+```julia
+B = UpperTriangular(A)
+```
+
+
+```julia
+A + B
+```
+
+### Einheitsmatrix `I`
+
+`I` bezeichnet eine Einheitsmatrix (quadratisch, Diagonalelemente = 1, alle anderen = 0) in der jeweils erforderlichen Größe
+
+
+```julia
+A + 4I
+```
+
+## Faktorisierungen
+
+
+### LU-Faktorisierung mit Zeilenpivoting 
+('Lower/Upper triangular matrix', im Deutschen auch oft "LR-Zerlegung" für "Linke/Rechte Dreiecksmatrix")
+
+
+
+```julia
+A = [0 22 1.
+     -1 2 3
+     77 18 19]
+```
+
+
+```julia
+# Faktorisierungen geben eine spezielle Struktur zurück, die die Matrixfaktoren und weitere 
+# Informationen enthalten:
+
+Af = lu(A);
+
+@show Af.L  Af.U Af.p;
+
+```
+
+
+```julia
+# man kann auch gleich auf der linken Seite ein entsprechendes Tupel verwenden
+
+l,u,p = lu(A)
+
+l
+```
+
+
+```julia
+u
+```
+
+
+```julia
+p
+```
+
+Der Permutationsvektor `p` zeigt an, wie die Zeilen der Matrix permutiert wurden:
+
+
+```julia
+A[p, :]   # 3. Zeile, 1. Zeile, 2. Zeile von A
+```
+
+Es gilt: $$ L\cdot U = PA$$
+
+
+```julia
+l * u - A[p,:]
+```
+
+### QR-Zerlegung
+
+
+```julia
+q, r = qr(A);
+
+q
+```
+
+
+```julia
+r
+```
+
+### Singular value decomposition
+
+
+```julia
+u, s, vt = svd(A);
+
+s
+```
+
+
+```julia
+u
+```
+
+
+```julia
+vt
+```
+
+
+```julia
+evalues, evectors = eigen(A)
+evalues
+```
+
+
+```julia
+evectors
+```
+
+### Lineare Gleichungssysteme
+
+Das lineare Gleichungssystem
+$$Ax = b$$
+kann man in Julia einfach lösen mit
+```
+x = A\b
+```
+
+
+```julia
+b = [2,3,4]
+
+A\b
+```
+
+Dabei wird eine geeignete Matrixfaktorisierung vorgenommen (meist LU). Wenn man Lösungen zu mehreren rechten Seiten $b_1, b_2,...$  benötigt, sollte man die Faktorisierung nur einmal durchführen: 
+
+
+```julia
+Af = factorize(A)
+```
+
+
+```julia
+Af\b
+```
+
+
+```julia
+Af\[5,7,9]
+```
+
+
+```julia
+
+```
--- a/css/styles.css
+++ b/css/styles.css
@ -208,3 +208,6 @@ div.cellmerge div.cell:nth-of-type(2) {
  font-size: 104% !important;
 }

+.code-fold summary {
+  padding-left: 0.5em;
+}