# 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

```