368 lines
7.5 KiB
Plaintext
368 lines
7.5 KiB
Plaintext
# 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
|
||
|
||
```
|