├── swt2 ├── v-modell.pdf ├── scrum_process.pdf └── xp_iteration.pdf ├── telematik └── TCP_Header.pdf ├── mikroprozessoren2 ├── Niagara1.pdf ├── Nvidia-Fermi.pdf ├── TI-TMS320C64x.pdf ├── Itanium_architecture.pdf ├── Niagara2_Erweiterungen.pdf └── Niagara1_Leistungsvergleich.pdf ├── it_sicherheitsmanagement └── xacml.pdf ├── listings_vhdl.sty ├── algo2 ├── algo_firstfit.tex ├── algo_praeflusspusch_lifte.tex ├── algo_pledge.tex ├── algo_ford-fulkerson.tex ├── algo_tuersuche-1.tex ├── algo_praeflusspusch_pusch.tex ├── algo_de-casteljau.tex ├── algo_schnitt.tex ├── algo_wert.tex ├── algo_an-die-spitze_leere.tex ├── algo_naive-textsuche.tex ├── algo_boyer-moore_sigma.tex ├── algo_simplex.tex ├── algo_sternsuche.tex ├── algo_praeflusspusch.tex ├── algo_zufallsgesteuerte-optimierung_grundalgorithmus.tex ├── algo_boyer-moore_gamma.tex ├── algo_quicksort.tex ├── algo_finde.tex ├── algo_boyer-moore.tex ├── algo_an-die-spitze.tex ├── algo_simuliertes-tempern.tex ├── algo_simplex_austausch.tex ├── algo_wanze.tex ├── algo_paare.tex ├── algo_pso.tex ├── algo_lr.tex ├── algo_brz.tex └── algo_konvexe-huelle.tex ├── .gitignore ├── algo2only.tex ├── vronly.tex ├── derivateonly.tex ├── assetpricingonly.tex ├── mp2only.tex ├── propaonly.tex ├── cgonly.tex ├── netzsicherheitfragenonly.tex ├── rsonly.tex ├── swt2only.tex ├── ioefragenonly.tex ├── netzsicherheitonly.tex ├── pmonly.tex ├── vsonly.tex ├── ioeonly.tex ├── sdionly.tex ├── telematikonly.tex ├── wasa2only.tex ├── sicherheitonly.tex ├── LICENSE ├── parallelrechnerparallelprogrammierungonly.tex ├── README.md ├── Makefile ├── main.tex ├── listings_mips.sty ├── listings_glsl.sty ├── vr.tex ├── algo2spickzettel.tex ├── telematik-themen.mm ├── assetpricing.tex ├── vs.tex ├── algo2algorithmen.tex └── investments.tex /swt2/v-modell.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ne0h/vorlesungen/HEAD/swt2/v-modell.pdf -------------------------------------------------------------------------------- /swt2/scrum_process.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ne0h/vorlesungen/HEAD/swt2/scrum_process.pdf -------------------------------------------------------------------------------- /swt2/xp_iteration.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ne0h/vorlesungen/HEAD/swt2/xp_iteration.pdf -------------------------------------------------------------------------------- /telematik/TCP_Header.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ne0h/vorlesungen/HEAD/telematik/TCP_Header.pdf -------------------------------------------------------------------------------- /mikroprozessoren2/Niagara1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ne0h/vorlesungen/HEAD/mikroprozessoren2/Niagara1.pdf -------------------------------------------------------------------------------- /it_sicherheitsmanagement/xacml.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ne0h/vorlesungen/HEAD/it_sicherheitsmanagement/xacml.pdf -------------------------------------------------------------------------------- /mikroprozessoren2/Nvidia-Fermi.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ne0h/vorlesungen/HEAD/mikroprozessoren2/Nvidia-Fermi.pdf -------------------------------------------------------------------------------- /mikroprozessoren2/TI-TMS320C64x.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ne0h/vorlesungen/HEAD/mikroprozessoren2/TI-TMS320C64x.pdf -------------------------------------------------------------------------------- /mikroprozessoren2/Itanium_architecture.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ne0h/vorlesungen/HEAD/mikroprozessoren2/Itanium_architecture.pdf -------------------------------------------------------------------------------- /mikroprozessoren2/Niagara2_Erweiterungen.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ne0h/vorlesungen/HEAD/mikroprozessoren2/Niagara2_Erweiterungen.pdf -------------------------------------------------------------------------------- /mikroprozessoren2/Niagara1_Leistungsvergleich.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ne0h/vorlesungen/HEAD/mikroprozessoren2/Niagara1_Leistungsvergleich.pdf -------------------------------------------------------------------------------- /listings_vhdl.sty: -------------------------------------------------------------------------------- 1 | \lstdefinelanguage{GLSL} { 2 | morekeywords=[1]{ 3 | library,use,all,entity,is,port,in,out,end,architecture,of, 4 | begin,and 5 | }, 6 | morecomment=[l]{--} 7 | } 8 | -------------------------------------------------------------------------------- /algo2/algo_firstfit.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{First Fit} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \For{i=1,...,m}{ 8 | Füge $a_i$ dem ersten Behälter hinzu, in den $a$ passt 9 | } 10 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_praeflusspusch_lifte.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Lifte} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$x$} 8 | \BlankLine 9 | 10 | $h(x) := 1+ \min_{(x,y) \in E_f}{h(y)}$ 11 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_pledge.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Pledge Strategie} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | $\phi \longleftarrow 0$ 8 | 9 | \While{$ R \in L $}{ 10 | gehe vorwärts bis Wand kontaktiert wird\newline 11 | \While{$R \not \in L$ oder $\phi = 0$}{ 12 | gehe links der Wand 13 | } 14 | } 15 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_ford-fulkerson.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Ford-Fulkerson} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$F(G,k,q,s)$} 8 | \Output{Ein maximaler Fluß $f$} 9 | \BlankLine 10 | 11 | $f \longleftarrow 0$ 12 | 13 | \While{Es gibt einen Pfad $q \rightarrow^* s$ in $G_f$} { 14 | Erhöhe $f$ über diesen maximal 15 | } 16 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_tuersuche-1.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Türsuche 1} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | $i \longleftarrow 1$ 8 | \BlankLine 9 | 10 | \While{Tür noch nicht gefunden}{ 11 | gehe $i$ Meter an der Wand entlang\newline 12 | \tcc{ändert die Laufrichtung} 13 | gehe i Meter zurück\newline 14 | $i \longleftarrow i+1$ 15 | } 16 | \end{algorithm} -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.aux 2 | *.log 3 | *.out 4 | *.toc 5 | *.dvi 6 | 7 | main.pdf 8 | algo2only.pdf 9 | assetpricingonly.pdf 10 | cgonly.pdf 11 | derivateonly.pdf 12 | ioeonly.pdf 13 | ioefragenonly.pdf 14 | mp2only.pdf 15 | netzsicherheitonly.pdf 16 | netzsicherheitfragenonly.pdf 17 | pmonly.pdf 18 | parallelrechnerparallelprogrammierungonly.pdf 19 | propaonly.pdf 20 | rsonly.pdf 21 | sicherheitonly.pdf 22 | swt2only.pdf 23 | sdionly.pdf 24 | telematikonly.pdf 25 | telematik-themen.pdf 26 | vronly.pdf 27 | vsonly.pdf 28 | wasa2only.pdf 29 | 30 | .DS_Store 31 | -------------------------------------------------------------------------------- /algo2/algo_praeflusspusch_pusch.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Pusch} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$x,y$} 8 | \Output{} 9 | \BlankLine 10 | 11 | $d \longleftarrow \min\{u(x), k_f(x,y)\}$ \newline 12 | $f(x,y) \longleftarrow f(x,y) + d$ \newline 13 | $u(x) \longleftarrow u(x) - d $ \newline 14 | $u(y) \longleftarrow u(y) + d$ \newline 15 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_de-casteljau.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{de Casteljau} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$b_0^0...b_n^0 \subset \mathbb{R}^d; t \in \mathbb{R}$} 8 | \Output{$b_0^0...b_0^n; b_0^n...b_n^0 \subset \mathbb{R}^d$} 9 | \BlankLine 10 | 11 | \For{$k=1,...,n$}{ 12 | \For{$i=0,...,n-k$}{ 13 | $b_i^k \longleftarrow b_i^{k-1} \cdot (1-t) + b_{i+1}^{k-1} \cdot t$ 14 | } 15 | } 16 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_schnitt.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Schnitt} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$(V,E)$ ein ungerichteter Multigraph} 8 | \Output{Ein Schnitt $S$} 9 | \BlankLine 10 | 11 | \While{$|V| \geq 3$} { 12 | Wähle eine zufällige Kante $(x,y) \in E$\newline 13 | Entferne alle $(x,y)$ aus $E$\newline 14 | Verschmelze $x$ mit $y$ 15 | } 16 | \BlankLine 17 | 18 | \Return{S:=E} 19 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_wert.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Wert} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$x$ Knoten eines binären Spielbaums} 8 | \Output{$Wert(x)$} 9 | \BlankLine 10 | 11 | $(y,z) \longleftarrow $ Paar der Kinder von $x$ in zufälliger Reihenfolge\newline 12 | $w \longleftarrow Wert(y)$ 13 | \BlankLine 14 | 15 | \eIf{$w = 1$}{ 16 | \Return{0} 17 | }{ 18 | \Return{0 $\downarrow$ Wert(z)} 19 | } 20 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_an-die-spitze_leere.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Leere} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$x$} 8 | \BlankLine 9 | 10 | \While{$u(x)>0$}{ 11 | \eIf{$i_x > 0$}{ 12 | $y \longleftarrow n_x(i_x)$ \newline 13 | \eIf{$(x,y)~puschbar$}{ 14 | $Pusch(x,y)$ 15 | }{ 16 | $i_x \longleftarrow i_x -1$} 17 | }{ $Lifte(x)$ \newline 18 | $i_x \longleftarrow Grad(x)$} 19 | 20 | } 21 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_naive-textsuche.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Naive Suche} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$A,t,s$} 8 | \Output{Kleinstes $t_{i+1},...,t_{i+m} = s$} 9 | \BlankLine 10 | 11 | $i \longleftarrow 0$\newline 12 | \While{$i\leq n-m$}{ 13 | $j \longleftarrow m$\newline 14 | \While{$j>0$ und $s_j=t_{i+j}$}{ 15 | $j \longleftarrow j-1$ 16 | } 17 | \BlankLine 18 | \eIf{$j=0$}{ 19 | \Return{$i$} 20 | }{ 21 | $i \longleftarrow i+1$ 22 | } 23 | } 24 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_boyer-moore_sigma.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{$\sigma$} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$\gamma(0,...,m-1)$} 8 | \Output{$\sigma(1,...,m)$} 9 | \BlankLine 10 | 11 | \For{$j = 1,...,m$}{ 12 | $\sigma(j) \longleftarrow m-\gamma(0)$ 13 | } 14 | \BlankLine 15 | 16 | \For{$i=0,...,m-1$}{ 17 | $k \longleftarrow m - \gamma(i) - i$\newline 18 | $j \longleftarrow m - \gamma(i)$ 19 | \If{$\sigma(j) > k$}{ 20 | $\sigma(j) \longleftarrow k$ 21 | } 22 | } 23 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_simplex.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Simplex} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{Normalform eines linearen Programms} 8 | \Output{Geänderte Normalform so dass $z(0) = c = max$} 9 | \BlankLine 10 | 11 | \While{$\exists c_s > 0$}{ 12 | \eIf{$\forall b_{is} \geq 0 $}{ 13 | \Return{keine Lösung} 14 | }{ 15 | bestimme r, so dass $\frac{b_r}{b_{rs}} = \max_{b_{is} < 0} \frac{b_i}{b_{is}}$ 16 | } 17 | \BlankLine 18 | 19 | $B \longleftarrow Austausch(B,r,s)$ 20 | } 21 | \end{algorithm} 22 | -------------------------------------------------------------------------------- /algo2only.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,11pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage[ruled,vlined]{algorithm2e} 13 | \usepackage{esdiff} 14 | 15 | \title{Algorithmen 2 am Karlsruher Institut für Technologie} 16 | \date{Juni 2015} 17 | \begin{document} 18 | \maketitle 19 | \tableofcontents 20 | \setcounter{tocdepth}{2} 21 | \setcounter{secnumdepth}{2} 22 | 23 | \include{algo2} 24 | \include{algo2algorithmen} 25 | %\include{algo2spickzettel} 26 | 27 | \end{document} 28 | -------------------------------------------------------------------------------- /algo2/algo_sternsuche.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Sternsuche} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$s$: Startpunkt;\newline 8 | $z$: Ziel;\newline 9 | $m$ Halbgeraden, startend in s} 10 | \BlankLine 11 | 12 | $\forall i \in \mathbb{N}_0 : f_i \leftarrow \left(\frac{m}{m-1}\right)^i$ 13 | $i \longleftarrow 0$ 14 | 15 | \While{z noch nicht gefunden}{ 16 | gehe $f_i$ Meter auf $H_{i~mod~m}$ entlang\newline 17 | gehe zurück zu $s$\newline 18 | $i \longleftarrow i+1$ 19 | } 20 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_praeflusspusch.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Präfluss-Pusch} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$F(G,k,q,s)$} 8 | \Output{Maximaler Fluss $f$} 9 | \BlankLine 10 | 11 | \For{alle $ x,y \in V $ }{ 12 | $ h(x) \leftarrow \begin{cases}|V| & x=q \\ 0 & \text{sonst}\end{cases}$ \newline 13 | $ f(x,y) \leftarrow \begin{cases}k(x,y) & x=q \\ 0 & \text{sonst}\end{cases}$} 14 | \While{Es gibt erlaubte Push oder Lifte Operationen}{ 15 | Führe diese \textit{Pusch}- oder \textit{Lifte}-Operation aus 16 | } 17 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_zufallsgesteuerte-optimierung_grundalgorithmus.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Grundalgorithmus} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \tcc{$q$ bezeichnet immer den aktuellen Zusatand} 8 | initialisiere $q$ 9 | \BlankLine 10 | 11 | \While{Ende nicht erreicht}{ 12 | erzeuge $p$ aus $q$ 13 | \BlankLine 14 | 15 | \eIf{$(p,q)$ aktzeptabel}{ 16 | \tcc{Aktualisiere $q$} 17 | $q \longleftarrow p$ 18 | }{ 19 | continue 20 | } 21 | } 22 | \BlankLine 23 | 24 | \tcc{Gib den aktuellen Zustand aus} 25 | \Return{q} 26 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_boyer-moore_gamma.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{$\gamma$} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$s_1,...,s_m$} 8 | \Output{$\gamma(0,...,m-1)$} 9 | \BlankLine 10 | 11 | $\gamma(m-1) \longleftarrow 0$\newline 12 | \For{i=m-1,...,1}{ 13 | $j \longleftarrow m - \gamma(i)$\newline 14 | \While{$s_i \ne s_j$ und $m \ne j$}{ 15 | $j \longleftarrow m - \gamma(j)$ 16 | } 17 | } 18 | \BlankLine 19 | 20 | \eIf{$s_i = s_j$}{ 21 | $\gamma(i-1) \longleftarrow m - j+1$ 22 | }{ 23 | $\gamma(i-1) \longleftarrow 0$ 24 | } 25 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_quicksort.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Quicksort} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$ S : = \{ s_1, ... , s_n \} $ mit paarweise verschiedenen $ s_i \in \mathbb{Z} $ } 8 | \Output{$(\sigma_1,...,\sigma_n)$ mit $\sigma_1 < ... < \sigma_n$ und $\{\sigma_1, ... , \sigma_n \} = S $} 9 | \BlankLine 10 | 11 | \While{ S $\ne \emptyset$} { 12 | Wähle ein zufälliges Pivotelement $ y \in S $ \newline 13 | Zerlege $S \setminus \{ y \} $ in $ s_1 $ und $ s_2 $, so dass $ s_1 < y < s_2 $ 14 | \BlankLine 15 | \Return{Quicksort($s_1$), $y$, Quicksort($s_2$)} 16 | } 17 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_finde.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Finde} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$S:= \{ s_1 , ... , s_n \} \subset \mathbb{M}$\\ 8 | $k \in \mathbb{N}$} 9 | \Output{$\sigma_k$, wobei $\sigma_1,...,\sigma_n \in S$ und $\sigma_1 < ... < \sigma_n$} 10 | \BlankLine 11 | 12 | Wähle $y$ zufällig aus $S$\newline 13 | $S_1 \longleftarrow \{x \in S~|~x < y \} $\newline 14 | $S_2 \longleftarrow \{x \in S~|~x > y \} $ 15 | \BlankLine 16 | 17 | \eIf{ $|S_1| = k-1$}{ 18 | \Return{y} 19 | }{ 20 | \eIf{$|S_1| > k-1$}{ 21 | $Finde(S_1,k)$ 22 | }{ 23 | $Finde(S_2, k-|S_1|-1)$ 24 | } 25 | } 26 | \end{algorithm} -------------------------------------------------------------------------------- /vronly.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage[ruled,vlined]{algorithm2e} 13 | \usepackage{esdiff} 14 | \usepackage{float} 15 | \usepackage{geometry} 16 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 17 | \restylefloat{table} 18 | 19 | \title{Verteiltes Rechnen am Karlsruher Institut für Technologie} 20 | \date{Januar 2018} 21 | \author{Maximilian Heß} 22 | 23 | \begin{document} 24 | \maketitle 25 | \tableofcontents 26 | \setcounter{tocdepth}{2} 27 | \setcounter{secnumdepth}{2} 28 | 29 | \include{vr} 30 | 31 | \end{document} 32 | -------------------------------------------------------------------------------- /derivateonly.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage[ruled,vlined]{algorithm2e} 13 | \usepackage{esdiff} 14 | \usepackage{float} 15 | \usepackage{geometry} 16 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 17 | \restylefloat{table} 18 | 19 | \title{BWL: Derivate am Karlsruher Institut für Technologie} 20 | \date{August 2016} 21 | \author{Maximilian Heß} 22 | 23 | \begin{document} 24 | \maketitle 25 | \tableofcontents 26 | \setcounter{tocdepth}{2} 27 | \setcounter{secnumdepth}{2} 28 | 29 | \include{derivate} 30 | 31 | \end{document} 32 | -------------------------------------------------------------------------------- /assetpricingonly.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage[ruled,vlined]{algorithm2e} 13 | \usepackage{esdiff} 14 | \usepackage{float} 15 | \usepackage{geometry} 16 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 17 | \restylefloat{table} 18 | 19 | \title{BWL: Asset Pricing am Karlsruher Institut für Technologie} 20 | \date{August 2017} 21 | \author{Maximilian Heß} 22 | 23 | \begin{document} 24 | \maketitle 25 | \tableofcontents 26 | \setcounter{tocdepth}{2} 27 | \setcounter{secnumdepth}{2} 28 | 29 | \include{assetpricing} 30 | 31 | \end{document} 32 | -------------------------------------------------------------------------------- /mp2only.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage[ruled,vlined]{algorithm2e} 13 | \usepackage{esdiff} 14 | \usepackage{float} 15 | \usepackage{geometry} 16 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 17 | \restylefloat{table} 18 | 19 | \title{Mikroprozessoren 2 am Karlsruher Institut für Technologie} 20 | \date{Februar 2016} 21 | \author{Maximilian Heß} 22 | 23 | \begin{document} 24 | \maketitle 25 | \tableofcontents 26 | \setcounter{tocdepth}{2} 27 | \setcounter{secnumdepth}{2} 28 | 29 | \include{mikroprozessoren2} 30 | 31 | \end{document} 32 | -------------------------------------------------------------------------------- /algo2/algo_boyer-moore.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Boyer-Moore} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$A,t,s$} 8 | \Output{Kleinstes $t_{i+1},...,t_{i+m} = s$} 9 | \BlankLine 10 | 11 | $i \longleftarrow 0$\newline 12 | \While{$i\leq n-m$}{ 13 | $j \longleftarrow m$\newline 14 | \While{$j>0$ und $s_j=t_{i+j}$}{ 15 | $j \longleftarrow j-1$ 16 | } 17 | \BlankLine 18 | \eIf{$j=0$}{ 19 | \Return{$i$} 20 | }{ 21 | $\nu \longleftarrow \nu(t_{i+j})$\newline 22 | \eIf{$\nu < j$}{ 23 | $i \longleftarrow i + max\{m-\nu,\sigma(j)\}$ 24 | }{ 25 | $i \longleftarrow i + max\{m-\nu+1,\sigma(j)\}$ 26 | } 27 | } 28 | } 29 | \end{algorithm} -------------------------------------------------------------------------------- /propaonly.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage[ruled,vlined]{algorithm2e} 13 | \usepackage{esdiff} 14 | \usepackage{float} 15 | \usepackage{geometry} 16 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 17 | \restylefloat{table} 18 | 19 | \title{Programmierparadigmen am Karlsruher Institut für Technologie} 20 | \date{April 2016} 21 | \author{Maximilian Heß} 22 | 23 | \begin{document} 24 | \maketitle 25 | \tableofcontents 26 | \setcounter{tocdepth}{2} 27 | \setcounter{secnumdepth}{2} 28 | 29 | \include{programmierparadigmen} 30 | 31 | \end{document} 32 | -------------------------------------------------------------------------------- /cgonly.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage{listings_glsl} 13 | \usepackage[ruled,vlined]{algorithm2e} 14 | \usepackage{esdiff} 15 | \usepackage{float} 16 | \usepackage{geometry} 17 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 18 | \restylefloat{table} 19 | 20 | 21 | \title{Computergrafik am Karlsruher Institut für Technologie} 22 | \date{März 2016} 23 | \author{Maximilian Hess} 24 | 25 | \begin{document} 26 | \maketitle 27 | \tableofcontents 28 | \setcounter{tocdepth}{2} 29 | \setcounter{secnumdepth}{2} 30 | 31 | \include{computergrafik} 32 | 33 | \end{document} -------------------------------------------------------------------------------- /algo2/algo_an-die-spitze.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{An die Spitze} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$F(G,k,q,s)$} 8 | \Output{Ein maximaler Fluss $f$} 9 | \BlankLine 10 | 11 | Initialisiere $f$ und $h$ wie in Präfluss-Pusch \newline 12 | Generiere $L$ \newline 13 | $x \longleftarrow Kopf(L)$ 14 | \BlankLine 15 | 16 | \For{$x \in V$}{ 17 | $i_x \longleftarrow Grad(x)$} 18 | \BlankLine 19 | 20 | \While{$x \ne Nil$ }{ 21 | $h_{alt} \longleftarrow h(x)$ \newline 22 | $Leere(x)$ \newline 23 | \If{$h_{alt} < h(x)$}{ 24 | Setze $x$ an die Spitze von $L$ 25 | } 26 | \BlankLine 27 | $x \longleftarrow \text{Nachfolger von x in L}$ 28 | } 29 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_simuliertes-tempern.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Simuliertes Tempern} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$t_1, ..., t_i$: Temperaturen;\newline 8 | $K$: Anzahl der zu berücksichtigenden Nachbarn;\newline 9 | $q$: Startpunkt;\newline 10 | $i$: aktueller Temperaturindex} 11 | \Output{$q$: die gefundene Lösung} 12 | \BlankLine 13 | 14 | \For{k = 1, k $\leq$ K, k++}{ 15 | wähle zufällig Nachbarn $p \in N(q)$ 16 | \BlankLine 17 | 18 | \If{$ c(p) > c(q) \text{ oder } exp(\frac{c(p) - c(q)}{t_i}) > Zufallszahl \in [0,1]$}{ 19 | \Return Simuliertes Tempern($[t_1,..,t_n], K, p, i+1$) 20 | } 21 | } 22 | \Return q 23 | \end{algorithm} -------------------------------------------------------------------------------- /netzsicherheitfragenonly.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage[ruled,vlined]{algorithm2e} 13 | \usepackage{esdiff} 14 | \usepackage{float} 15 | \usepackage{geometry} 16 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 17 | \restylefloat{table} 18 | 19 | \title{Netzsicherheit: Architekturen und Protkolle am Karlsruher Institut für Technologie \\ Fragenkatalog} 20 | \date{Dezember 2015} 21 | \author{Benjamin Fus} 22 | 23 | \begin{document} 24 | \maketitle 25 | \tableofcontents 26 | \setcounter{tocdepth}{2} 27 | \setcounter{secnumdepth}{2} 28 | 29 | \include{netzsicherheitfragenkatalog} 30 | 31 | \end{document} -------------------------------------------------------------------------------- /rsonly.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage{listings_mips} 13 | \usepackage{listings_vhdl} 14 | \usepackage[ruled,vlined]{algorithm2e} 15 | \usepackage{esdiff} 16 | \usepackage{float} 17 | \usepackage{geometry} 18 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 19 | \restylefloat{table} 20 | 21 | \title{Rechnerstrukturen am Karlsruher Institut für Technologie} 22 | \date{August 2016} 23 | \author{Maximilian Heß} 24 | 25 | \begin{document} 26 | \maketitle 27 | \tableofcontents 28 | \setcounter{tocdepth}{2} 29 | \setcounter{secnumdepth}{2} 30 | 31 | \include{rechnerstrukturen} 32 | 33 | \end{document} 34 | -------------------------------------------------------------------------------- /swt2only.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage{listings_glsl} 13 | \usepackage[ruled,vlined]{algorithm2e} 14 | \usepackage{esdiff} 15 | \usepackage{float} 16 | \usepackage{tikz} 17 | \usetikzlibrary{calc} 18 | \usepackage{geometry} 19 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 20 | \restylefloat{table} 21 | 22 | 23 | \title{Softwaretechnik 2 am Karlsruher Institut für Technologie} 24 | \date{Februar 2018} 25 | \author{Maximilian Hess} 26 | 27 | \begin{document} 28 | \maketitle 29 | \tableofcontents 30 | \setcounter{tocdepth}{2} 31 | \setcounter{secnumdepth}{2} 32 | 33 | \include{softwaretechnik2} 34 | 35 | \end{document} -------------------------------------------------------------------------------- /algo2/algo_simplex_austausch.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Austausch} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{Matrix A; r; s} 8 | \Output{Matrix A'} 9 | \BlankLine 10 | 11 | \tcc{Weder Pivotspalte, noch -zeile} 12 | \For{$i \neq r$ und $j \neq s$}{ 13 | $a'_{ij} \longleftarrow a_{ij} - \frac{a_{is}a_{rj}}{a_{rs}}$ 14 | } 15 | \BlankLine 16 | 17 | \tcc{Pivotzeile} 18 | \For{$i=r$ und $j \neq s$}{ 19 | $a'_{ij} \longleftarrow - \frac{a_{ij}}{a_{rs}}$ 20 | } 21 | \BlankLine 22 | 23 | \tcc{Pivotspalte} 24 | \For{$i \neq r$ und $j=s$}{ 25 | $a'_{ij} \longleftarrow \frac{a_{ij}}{a_{rs}} $ 26 | } 27 | \BlankLine 28 | 29 | \tcc{Pivot} 30 | \For{$i=r$ und $j=s$}{ 31 | $a'_{ij} \longleftarrow \frac{1}{a_{rs}} $ 32 | } 33 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_wanze.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Wanze} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$P_1 , ... , P_n$ disjunkte, einfache geschlossene Polygone $\subset A^2$, die sich nicht gegenseitig enthalten;\newline 8 | $s,z$: Start und Ziel $\in A^2 \setminus P$;\newline 9 | Roboter $R$ der seine eigene Position $r$ kennt} 10 | \Output{Weg von $s$ nach $z$} 11 | \BlankLine 12 | 13 | \While{$r \ne z$}{ 14 | gehe Richtung $z$ bis $r = z$ oder $\exists i:r \in P_i$ 15 | \BlankLine 16 | 17 | \If{$r \ne z$} { 18 | \tcc{Suche die Stelle auf dem zu umlaufenden Polygon mit minimalem Abstand zu $z$} 19 | umlaufe $P_i$ und suche $q \in argmin || x - z ||_2,~x \in P_i$ 20 | \BlankLine 21 | 22 | gehe zu $q$ 23 | } 24 | } 25 | \end{algorithm} -------------------------------------------------------------------------------- /ioefragenonly.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage,twocolumn,twoside,notitlepage,landscape]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage[ruled,vlined]{algorithm2e} 13 | \usepackage{esdiff} 14 | \usepackage{float} 15 | \usepackage{geometry} 16 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 17 | \restylefloat{table} 18 | \setcounter{secnumdepth}{4} 19 | \setcounter{tocdepth}{4} 20 | 21 | \title{Internet of Everything am Karlsruher Institut für Technologie \\ Fragenkatalog} 22 | \date{Februar 2016} 23 | \author{Benjamin Fus} 24 | 25 | \begin{document} 26 | \maketitle 27 | %\tableofcontents 28 | %\setcounter{tocdepth}{2} 29 | %\setcounter{secnumdepth}{2} 30 | 31 | \include{ioefragen} 32 | 33 | \end{document} 34 | -------------------------------------------------------------------------------- /algo2/algo_paare.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Paare} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{bipartiter Graph $(V_1 \stackrel{\cdot}{\cup} V_2, E)$} 8 | \Output{Maximale Paarung P} 9 | \BlankLine 10 | 11 | $V \longleftarrow V_1 \cup V_2 \cup \{ q,s \}$ \newline 12 | $\hat{E} \longleftarrow \{ q \} \times V_1 \cup E \cup V_2 \times \{ s \} $ \newline 13 | \BlankLine 14 | 15 | \tcc{Initialisiere alle Kanten mit $Kapazitaet=1$} 16 | $k \longleftarrow \begin{cases}1 & e \in \hat{E} \\ 0 & \text{sonst}\end{cases}$ \newline 17 | \BlankLine 18 | 19 | $f \longleftarrow Ford-Fulkerson( F(V, \hat{E} ),h,q,s)) $ \newline 20 | \BlankLine 21 | 22 | \tcc{Die Kanten mit $Fluss=1$ im Ursprungsgraphen bilden die maximale Paarung} 23 | $P \longleftarrow \{ e \in E~|~f(e) = 1 \} $ 24 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_pso.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{PSO} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$n$: Menge an Partikeln} 8 | \Output{$q$: die beste gefundene Lösung} 9 | \BlankLine 10 | 11 | \tcc{Setze Startposition und Geschwindigkeit der einzelnen Partikel} 12 | \For{i}{ 13 | wähle $p_i(0), v_i(0)$ zufällig 14 | } 15 | \BlankLine 16 | 17 | \tcc{es gilt immer: $q_i$ bisher beste Position von $p_i$, $q = max(q_i)$} 18 | \While{Abbruchgenauigkeit noch nicht erreicht}{ 19 | \For{i = 0,...,n} { 20 | $v_i \leftarrow v_i \omega + (q_i - p_i) c_1 \cdot r_1 + (q - p_i) c_2 \cdot r_2$\newline 21 | $p_i \leftarrow p_i + v_i$ 22 | } 23 | } 24 | \Return q\\ 25 | \end{algorithm} -------------------------------------------------------------------------------- /netzsicherheitonly.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage[ruled,vlined]{algorithm2e} 13 | \usepackage{esdiff} 14 | \usepackage{float} 15 | \usepackage{geometry} 16 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 17 | \restylefloat{table} 18 | \usepackage{tikz} 19 | \usetikzlibrary{calc} 20 | \usetikzlibrary{decorations.pathreplacing} 21 | \usetikzlibrary{shapes} 22 | \usepackage{placeins} 23 | 24 | \title{Netzsicherheit: Architekturen und Protkolle am Karlsruher Institut für Technologie} 25 | \date{September 2017} 26 | \author{Maximilian Heß} 27 | 28 | \begin{document} 29 | \maketitle 30 | \tableofcontents 31 | \setcounter{tocdepth}{2} 32 | \setcounter{secnumdepth}{2} 33 | 34 | \include{netzsicherheit} 35 | 36 | \end{document} -------------------------------------------------------------------------------- /pmonly.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage[ruled,vlined]{algorithm2e} 13 | \usepackage{esdiff} 14 | \usepackage{float} 15 | \usepackage{geometry} 16 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 17 | \restylefloat{table} 18 | \usepackage{enumitem} 19 | 20 | \setlistdepth{20} 21 | \renewlist{itemize}{itemize}{20} 22 | \setlist[itemize]{label=$\cdot$} 23 | \setlist[itemize,1]{label=\textbullet} 24 | \setlist[itemize,2]{label=--} 25 | \setlist[itemize,3]{label=\(\ast\)} 26 | 27 | \title{Powermanagement am Karlsruher Institut für Technologie} 28 | \date{Mai 2017} 29 | \author{Maximilian Heß} 30 | 31 | \begin{document} 32 | \maketitle 33 | \tableofcontents 34 | \setcounter{tocdepth}{2} 35 | \setcounter{secnumdepth}{2} 36 | 37 | \include{pm} 38 | 39 | \end{document} -------------------------------------------------------------------------------- /vsonly.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage[ruled,vlined]{algorithm2e} 13 | \usepackage{esdiff} 14 | \usepackage{float} 15 | \usepackage{geometry} 16 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 17 | \restylefloat{table} 18 | \usepackage{enumitem} 19 | 20 | \setlistdepth{20} 21 | \renewlist{itemize}{itemize}{20} 22 | \setlist[itemize]{label=$\cdot$} 23 | \setlist[itemize,1]{label=\textbullet} 24 | \setlist[itemize,2]{label=--} 25 | \setlist[itemize,3]{label=\(\ast\)} 26 | 27 | \title{Virtuelle Systeme am Karlsruher Institut für Technologie} 28 | \date{Mai 2017} 29 | \author{Maximilian Heß} 30 | 31 | \begin{document} 32 | \maketitle 33 | \tableofcontents 34 | \setcounter{tocdepth}{2} 35 | \setcounter{secnumdepth}{2} 36 | 37 | \include{vs} 38 | 39 | \end{document} -------------------------------------------------------------------------------- /ioeonly.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage[ruled,vlined]{algorithm2e} 13 | \usepackage{esdiff} 14 | \usepackage{float} 15 | \usepackage{geometry} 16 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 17 | \restylefloat{table} 18 | \usepackage{enumitem} 19 | 20 | \setlistdepth{20} 21 | \renewlist{itemize}{itemize}{20} 22 | \setlist[itemize]{label=$\cdot$} 23 | \setlist[itemize,1]{label=\textbullet} 24 | \setlist[itemize,2]{label=--} 25 | \setlist[itemize,3]{label=\(\ast\)} 26 | 27 | \title{Internet of Everything am Karlsruher Institut für Technologie} 28 | \date{Februar 2017} 29 | \author{Maximilian Heß} 30 | 31 | \begin{document} 32 | \maketitle 33 | \tableofcontents 34 | \setcounter{tocdepth}{2} 35 | \setcounter{secnumdepth}{2} 36 | 37 | \include{ioe} 38 | 39 | \end{document} -------------------------------------------------------------------------------- /sdionly.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage[ruled,vlined]{algorithm2e} 13 | \usepackage{esdiff} 14 | \usepackage{float} 15 | \usepackage{geometry} 16 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 17 | \restylefloat{table} 18 | 19 | \usepackage{enumitem} 20 | \setlistdepth{20} 21 | \renewlist{itemize}{itemize}{20} 22 | \setlist[itemize]{label=$\cdot$} 23 | \setlist[itemize,1]{label=\textbullet} 24 | \setlist[itemize,2]{label=--} 25 | \setlist[itemize,3]{label=\(\ast\)} 26 | 27 | \title{Systementwurf und Implementierung am Karlsruher Institut für Technologie} 28 | \date{November 2017} 29 | \author{Maximilian Heß} 30 | 31 | \begin{document} 32 | \maketitle 33 | \tableofcontents 34 | \setcounter{tocdepth}{2} 35 | \setcounter{secnumdepth}{2} 36 | 37 | \include{sdi} 38 | 39 | \end{document} -------------------------------------------------------------------------------- /telematikonly.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{mathtools} 11 | \usepackage{graphicx} 12 | \usepackage{listings} 13 | \usepackage[ruled,vlined]{algorithm2e} 14 | \usepackage{esdiff} 15 | \usepackage{float} 16 | \usepackage{placeins} 17 | \usepackage{lscape} 18 | \usepackage{array} 19 | \usepackage{geometry} 20 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 21 | \restylefloat{table} 22 | 23 | \usepackage{subcaption} 24 | \usepackage{tikz} 25 | \usetikzlibrary{calc} 26 | \usetikzlibrary{decorations.pathreplacing} 27 | \usetikzlibrary{shapes} 28 | 29 | 30 | \title{Telematik am Karlsruher Institut für Technologie} 31 | \date{März 2017} 32 | \author{Maximilian Hess} 33 | 34 | \begin{document} 35 | \maketitle 36 | \tableofcontents 37 | \setcounter{tocdepth}{2} 38 | \setcounter{secnumdepth}{2} 39 | 40 | \include{telematik} 41 | 42 | \end{document} -------------------------------------------------------------------------------- /wasa2only.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage[ruled,vlined]{algorithm2e} 13 | \usepackage{esdiff} 14 | \usepackage{float} 15 | \usepackage{geometry} 16 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 17 | \restylefloat{table} 18 | \usepackage{enumitem} 19 | 20 | \setlistdepth{20} 21 | \renewlist{itemize}{itemize}{20} 22 | \setlist[itemize]{label=$\cdot$} 23 | \setlist[itemize,1]{label=\textbullet} 24 | \setlist[itemize,2]{label=--} 25 | \setlist[itemize,3]{label=\(\ast\)} 26 | 27 | \title{Web-Anwendungen und Serviceorientierte Architekturen (II) am Karlsruher Institut für Technologie} 28 | \date{Juli 2017} 29 | \author{Maximilian Heß} 30 | 31 | \begin{document} 32 | \maketitle 33 | \tableofcontents 34 | \setcounter{tocdepth}{2} 35 | \setcounter{secnumdepth}{2} 36 | 37 | \include{wasa2} 38 | 39 | \end{document} -------------------------------------------------------------------------------- /sicherheitonly.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{mathtools} 11 | \usepackage{graphicx} 12 | \usepackage{listings} 13 | \usepackage{listings_glsl} 14 | \usepackage[ruled,vlined]{algorithm2e} 15 | \usepackage{esdiff} 16 | \usepackage{float} 17 | \usepackage{placeins} 18 | \usepackage{lscape} 19 | \usepackage{array} 20 | \usepackage{geometry} 21 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 22 | \restylefloat{table} 23 | 24 | \usepackage{subcaption} 25 | \usepackage{tikz} 26 | \usetikzlibrary{calc} 27 | \usetikzlibrary{decorations.pathreplacing} 28 | \usetikzlibrary{shapes} 29 | 30 | 31 | \title{Sicherheit am Karlsruher Institut für Technologie} 32 | \date{Oktober 2016} 33 | \author{Maximilian Hess} 34 | 35 | \begin{document} 36 | %\maketitle 37 | %\tableofcontents 38 | \setcounter{tocdepth}{2} 39 | \setcounter{secnumdepth}{2} 40 | 41 | \include{sicherheit} 42 | 43 | \end{document} -------------------------------------------------------------------------------- /algo2/algo_lr.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Lane-Riesenfeld} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{$c_{\mathbb{Z}}^0$: ein Polygon $ \subset \mathbb{R}^d$;\newline 8 | $n \in \mathbb{N}_0$: der Grad; 9 | $m \in \mathbb{N}$: die Unterteilungstiefe} 10 | \Output{$c_{\mathbb{Z}}^m \subset \mathbb{R}^d$} 11 | \BlankLine 12 | 13 | \For{$k=1,...,m$}{ 14 | \BlankLine 15 | 16 | \tcc{verdopple alle Kontrollpunkte} 17 | \For{$i \in \mathbb{Z}$}{ 18 | $d_{2i}^0 \longleftarrow d_{2i+1}^0 \longleftarrow c_{i}^{k-1}$ 19 | } 20 | \BlankLine 21 | 22 | \For{$j=1, ... ,n$}{ 23 | \tcc{mittele zwischen jeweils zwei Kontrollpunkten} 24 | \For{$i \in \mathbb{Z}$}{ 25 | $d_i^j \longleftarrow (d_{i-1}^{j-1} + d_i^{j-1}) \cdot \frac{1}{2}$ 26 | } 27 | } 28 | \BlankLine 29 | 30 | \tcc{Aktualisiere die Benennung der Kontrollpunkte} 31 | \For{$ i \in \mathbb{Z}$}{ 32 | $c_i^k \longleftarrow d_i^n$ 33 | } 34 | } 35 | \end{algorithm} -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2014 ne0h 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. -------------------------------------------------------------------------------- /parallelrechnerparallelprogrammierungonly.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage[ruled,vlined]{algorithm2e} 13 | \usepackage{esdiff} 14 | \usepackage{float} 15 | \usepackage{geometry} 16 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 17 | \restylefloat{table} 18 | 19 | \usepackage{enumitem} 20 | \setlistdepth{20} 21 | \renewlist{itemize}{itemize}{20} 22 | \setlist[itemize]{label=$\cdot$} 23 | \setlist[itemize,1]{label=\textbullet} 24 | \setlist[itemize,2]{label=--} 25 | \setlist[itemize,3]{label=\(\ast\)} 26 | 27 | \title{Parallelrechner und Parallelprogrammierung am Karlsruher Institut für Technologie} 28 | \date{September 2017} 29 | \author{Maximilian Heß} 30 | 31 | \begin{document} 32 | \maketitle 33 | \tableofcontents 34 | \setcounter{tocdepth}{2} 35 | \setcounter{secnumdepth}{2} 36 | 37 | \include{parallelrechnerparallelprogrammierung} 38 | 39 | \end{document} -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Vorlesungen 2 | =========== 3 | 4 | Zusammenfassung einiger Vorlesungen, die ich gehört habe. Zum Erzeugen des PDFs ist Latex 5 | notwendig: 6 | 7 | `$ make` 8 | 9 | Die meisten Kapitel können separat gebaut werden (siehe das `Makefile`). Um beispielsweise lediglich den Teil zu Algorithmen 2 zu bauen: 10 | 11 | `$ make algo2only` 12 | 13 | Aktuell enthalten 14 | ----------------- 15 | 16 | ### Bachelor 17 | 18 | * Algorithmen 2 19 | * BWL: BWL C/FR 20 | * BWL: Financial Management 21 | * BWL: Investments 22 | * Computergrafik 23 | * Echtzeitsysteme 24 | * IT-Sicherheitsmanagement für vernetzte Systeme 25 | * Programmierparadigmen 26 | 27 | ### Master 28 | 29 | * BWL: Asset Pricing 30 | * BWL: Derivate 31 | * Internet of Everything 32 | * Internet of Everything - Fragenkatalog 33 | * Mikroprozessoren 2 34 | * Netzsicherheit 35 | * Netzsicherheit - Fragenkatalog 36 | * Rechnerstrukturen 37 | * Parallelrechner und Parallelprogrammierung 38 | * Powermanagement 39 | * Sicherheit - Verfahren und Formelsammlung 40 | * Softwaretechnik 2 41 | * Systementwurf und Implementierung 42 | * Telematik 43 | * Verteiltes Rechnen 44 | * Virtuelle Systeme 45 | * Web-Anwendungen und Serviceorientierte Architekturen (II) -------------------------------------------------------------------------------- /algo2/algo_brz.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{BRZ} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{Ein Polyeder $P \subset \mathbb{R}^3$; orientierte, planare, disjunkte Polygone $P_1,...,P_n \subset \mathbb{R}^3$} 8 | \Output{Ein $RBZ$ für $P_1,...,P_n$} 9 | \BlankLine 10 | 11 | $k \longleftarrow 1$ 12 | \BlankLine 13 | \tcc{Sortiere Polygonenteile aus, die außerhalb von $P$ liegen (Clipping)} 14 | \For {$i=1,...,n$}{ 15 | $Q_k \longleftarrow P_i \cap P$\\ 16 | \If {$Q_k \neq \emptyset$} { 17 | $k \longleftarrow k + 1$ 18 | } 19 | } 20 | 21 | $l \longleftarrow 1$ 22 | 23 | \BlankLine 24 | \tcc{Falls ein Polygon $P$ komplett zerteilt, nehme dieses als Trennelement. Anderenfalls nehme das erste in der Liste} 25 | \If{Exists $j$: $Q_j$ zerlegt P vollständig}{ 26 | $l \longleftarrow j$ 27 | } 28 | 29 | $Wurzel \longleftarrow Q_l$ 30 | \BlankLine 31 | \tcc{Teile $P$} 32 | \If{$k \geq 3$}{ 33 | $Q \longleftarrow P \cap li.~HR~von~Q_l$\newline 34 | $li.~Wurzelteilbaum \longleftarrow BRZ(Q,Q_1,...,Q_{k-1})$\newline 35 | $Q \longleftarrow P \cap re.~HR~von~Q_l$\newline 36 | $re.~Wurzelteilbaum \longleftarrow BRZ(Q,Q_1,...,Q_{k-1})$ 37 | } 38 | 39 | \BlankLine 40 | \Return{Wurzel mit ihren Teilbaeumen} 41 | \end{algorithm} -------------------------------------------------------------------------------- /algo2/algo_konvexe-huelle.tex: -------------------------------------------------------------------------------- 1 | \begin{algorithm}[H] 2 | \caption{Konvexe Hülle} 3 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 4 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 5 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 6 | 7 | \Input{Punktmenge $P=(p_1,..,p_n) \cap A^3$} 8 | \Output{$\lbrack P \rbrack$} 9 | \BlankLine 10 | 11 | \tcc{Verschiebe $P$, so dass der Ursprung innerhalb der Konvexen Hülle liegt} 12 | $v \longleftarrow 0 - \sum_i \frac{p_i}{n}$\newline 13 | $P \longleftarrow P + v$ 14 | \BlankLine 15 | 16 | \tcc{Bestimme die Schnittmenge der ersten 4 HRe. Dadurch wird ein initialer Tetraeder aufgespannt} 17 | $V \longleftarrow$ Knotenliste von $p_1^{\leq} \cap ... \cap p_4^{\leq}$ 18 | \BlankLine 19 | 20 | \tcc{Prüfe für alle weiteren HRe, ob diese in $V$ liegen} 21 | \For{$j > i$} { 22 | \eIf{$p_j^{\leq} \supset V$}{ 23 | Entferne $p_j$ aus $P$\newline 24 | Aktualisiere "`gedanklich"' alle Indizes $k>j$ 25 | }{ 26 | Verknüpfe $p_j$ bidirektional mit einem $w_j \in V_4 \backslash p_j^{\leq}$ 27 | } 28 | } 29 | \BlankLine 30 | 31 | \tcc{Schritt 3} 32 | \For{i = 5,...,n}{ 33 | Durchlaufe $V$ von $w_i$ aus und setze dabei:\newline 34 | $N_i \longleftarrow \{ Schnittpunkte~der~Kanten~mit~p_i^{*}\}$\newline 35 | $W_i \longleftarrow V \cap p_i^{>}$\newline 36 | $V \longleftarrow (V \cup N_i) \backslash W_i$\newline 37 | \BlankLine 38 | \For{$j>i$ mit $w_j \in W_i$}{ 39 | \eIf{$N_i \subset p_j^{\leq}$}{ 40 | Entferne $P_j$ aus $P$\newline 41 | Aktualisiere "`gedanklich"' alle Indizes 42 | }{ 43 | Verknüpfe $p_j$ neu mit einem $w_j \in N_i \cap p_j^{>}$ 44 | } 45 | } 46 | } 47 | \BlankLine 48 | 49 | \Return{Verschobene Polarmenge $Q_P$} 50 | 51 | \end{algorithm} -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | all: 2 | pdflatex main.tex 3 | pdflatex main.tex 4 | 5 | clean: 6 | rm -f *.aux *.loc *.log *.out *.pdf *.toc 7 | 8 | algo2only: 9 | pdflatex algo2only.tex 10 | pdflatex algo2only.tex 11 | 12 | assetpricingonly: 13 | pdflatex assetpricingonly.tex 14 | pdflatex assetpricingonly.tex 15 | 16 | cgonly: 17 | pdflatex cgonly.tex 18 | pdflatex cgonly.tex 19 | 20 | derivateonly: 21 | pdflatex derivateonly.tex 22 | pdflatex derivateonly.tex 23 | 24 | ioeonly: 25 | pdflatex ioeonly.tex 26 | pdflatex ioeonly.tex 27 | 28 | ioefragenonly: 29 | pdflatex ioefragenonly.tex 30 | pdflatex ioefragenonly.tex 31 | 32 | mp2only: 33 | pdflatex mp2only.tex 34 | pdflatex mp2only.tex 35 | 36 | netzsicherheitonly: 37 | pdflatex netzsicherheitonly.tex 38 | pdflatex netzsicherheitonly.tex 39 | 40 | netzsicherheitfragenonly: 41 | pdflatex netzsicherheitfragenonly.tex 42 | pdflatex netzsicherheitfragenonly.tex 43 | 44 | pmonly: 45 | pdflatex pmonly.tex 46 | pdflatex pmonly.tex 47 | 48 | pponly: 49 | pdflatex parallelrechnerparallelprogrammierungonly.tex 50 | pdflatex parallelrechnerparallelprogrammierungonly.tex 51 | 52 | propaonly: 53 | pdflatex propaonly.tex 54 | pdflatex propaonly.tex 55 | 56 | rsonly: 57 | pdflatex rsonly.tex 58 | pdflatex rsonly.tex 59 | 60 | sicherheitonly: 61 | pdflatex sicherheitonly.tex 62 | pdflatex sicherheitonly.tex 63 | 64 | swt2only: 65 | pdflatex swt2only.tex 66 | pdflatex swt2only.tex 67 | 68 | sdionly: 69 | pdflatex sdionly.tex 70 | pdflatex sdionly.tex 71 | 72 | telematikonly: 73 | pdflatex telematikonly.tex 74 | pdflatex telematikonly.tex 75 | 76 | vronly: 77 | pdflatex vronly.tex 78 | pdflatex vronly.tex 79 | 80 | vsonly: 81 | pdflatex vsonly.tex 82 | pdflatex vsonly.tex 83 | 84 | wasa2only: 85 | pdflatex wasa2only.tex 86 | pdflatex wasa2only.tex 87 | -------------------------------------------------------------------------------- /main.tex: -------------------------------------------------------------------------------- 1 | \documentclass[a4paper,8pt,titlepage]{scrbook} 2 | 3 | \usepackage[T1]{fontenc} 4 | \usepackage[utf8]{inputenc} 5 | \usepackage[ngerman]{babel} 6 | \usepackage{hyperref} 7 | \usepackage{tabularx} 8 | \usepackage{amsmath} 9 | \usepackage{amssymb} 10 | \usepackage{graphicx} 11 | \usepackage{listings} 12 | \usepackage{listings_glsl} 13 | \usepackage{listings_mips} 14 | \usepackage{listings_vhdl} 15 | \usepackage[ruled,vlined]{algorithm2e} 16 | \usepackage{esdiff} 17 | \usepackage{float} 18 | \usepackage{placeins} 19 | \usepackage{lscape} 20 | \usepackage{array} 21 | \usepackage{geometry} 22 | \geometry{left=2cm,right=2cm,top=2cm,bottom=2cm,bindingoffset=10mm} 23 | \restylefloat{table} 24 | 25 | \usepackage{enumitem} 26 | \setlistdepth{20} 27 | \renewlist{itemize}{itemize}{20} 28 | \setlist[itemize]{label=$\cdot$} 29 | \setlist[itemize,1]{label=\textbullet} 30 | \setlist[itemize,2]{label=--} 31 | \setlist[itemize,3]{label=\(\ast\)} 32 | 33 | \usepackage{subcaption} 34 | \usepackage{tikz} 35 | \usetikzlibrary{calc} 36 | \usetikzlibrary{decorations.pathreplacing} 37 | \usetikzlibrary{shapes} 38 | 39 | \title{Vorlesungen am Karlsruher Institut für Technologie} 40 | \author{Maximilian Heß} 41 | \date{Februar 2018} 42 | 43 | \begin{document} 44 | \maketitle 45 | \tableofcontents 46 | 47 | \part{Bachelor} 48 | \include{algo2} 49 | \include{algo2algorithmen} 50 | \include{bwlc} 51 | \include{computergrafik} 52 | \include{echtzeitsysteme} 53 | \include{financial_management} 54 | \include{investments} 55 | \include{it_sicherheitsmanagement} 56 | \include{programmierparadigmen} 57 | 58 | \part{Master} 59 | \include{assetpricing} 60 | \include{derivate} 61 | \include{ioe} 62 | \include{ioefragen} 63 | \include{mikroprozessoren2} 64 | \include{netzsicherheit} 65 | \include{rechnerstrukturen} 66 | \include{parallelrechnerparallelprogrammierung} 67 | \include{pm} 68 | \include{sicherheit} 69 | \include{softwaretechnik2} 70 | \include{sdi} 71 | \include{telematik} 72 | \include{vr} 73 | \include{vs} 74 | \include{wasa2} 75 | 76 | \end{document} 77 | -------------------------------------------------------------------------------- /listings_mips.sty: -------------------------------------------------------------------------------- 1 | %% MIPS Assembler language definition for the LaTeX listings package 2 | %% mips.sty 3 | %% Copyright 2009 Adam Wolfe Gordon 4 | % minor edits by Martin Thoma 5 | % 6 | % This work may be distributed and/or modified under the 7 | % conditions of the LaTeX Project Public License, either version 1.3 8 | % of this license or (at your option) any later version. 9 | % The latest version of this license is in 10 | % http://www.latex-project.org/lppl.txt 11 | % and version 1.3 or later is part of all distributions of LaTeX 12 | % version 2005/12/01 or later. 13 | % 14 | % This work has the LPPL maintenance status `maintained'. 15 | % 16 | % The Current Maintainer of this work is Adam Wolfe Gordon 17 | % 18 | % This work consists of the file mips.sty. 19 | 20 | \lstdefinelanguage[mips]{Assembler}% 21 | {morestring=[b]", 22 | morekeywords=[1]{abs,abs.d,abs.ps,abs.s,add,add.d,add.ps,add.s,addi,addiu,addu,alnv.ps,and,% 23 | andi,b,bal,bc1f,bc1fl,bc1t,bc1tl,bc2f,bc2fl,bc2t,bc2tl,beq,beql,beqz,bge,bgeu,bgez,% 24 | bgezal,bgezall,bgezl,bgt,bgtu,bgtz,bgtzl,ble,bleu,blez,blezl,blt,bltu,bltz,bltzal,% 25 | bltzall,bltzl,bne,bnel,bnez,break,c.eq.d,c.eq.ps,c.eq.s,c.f.d,c.f.ps,c.f.s,c.le.d,% 26 | c.le.ps,c.le.s,c.lt.d,c.lt.ps,c.lt.s,c.nge.d,c.nge.ps,c.nge.s,c.ngl.d,c.ngl.ps,% 27 | c.ngl.s,c.ngle.d,c.ngle.ps,c.ngle.s,c.ngt.d,c.ngt.ps,c.ngt.s,c.ole.d,c.ole.ps,c.ole.s,% 28 | c.olt.d,c.olt.ps,c.olt.s,c.seq.d,c.seq.ps,c.seq.s,c.sf.d,c.sf.ps,c.sf.s,c.ueq.d,c.ueq.ps,% 29 | c.ueq.s,c.ule.d,c.ule.ps,c.ule.s,c.ult.d,c.ult.ps,c.ult.s,c.un.d,c.un.ps,c.un.s,cache,% 30 | ceil.l.d,ceil.l.s,ceil.w.d,ceil.w.s,cfc0,cfc1,cfc2,clo,clz,cop2,ctc0,ctc1,ctc2,cvt.d.l,% 31 | cvt.d.s,cvt.d.w,cvt.l.d,cvt.l.s,cvt.ps.s,cvt.s.d,cvt.s.l,cvt.s.pl,cvt.s.pu,cvt.s.w,% 32 | cvt.w.d,cvt.w.s,deret,di,div,div.d,div.s,divu,ehb,ei,eret,ext,floor.l.d,floor.l.s,floor.w.d,% 33 | floor.w.s,ins,j,jal,jalr,jalr.hb,jr,jr.hb,l.d,l.s,la,lb,lbu,ld,ldc1,ldc2,ldxc1,lh,lhu,li,li.d,% 34 | li.s,ll,lui,luxc1,lw,lwc1,lwc2,lwl,lwr,lwxc1,madd,madd.d,madd.ps,madd.s,maddu,mfc0,mfc1,% 35 | mfc1.d,mfc2,mfhc1,mfhc2,mfhi,mflo,mov.d,mov.ps,mov.s,move,movf,movf.d,movf.ps,movf.s,movn,% 36 | movn.d,movn.ps,movn.s,movt,movt.d,movt.ps,movt.s,movz,movz.d,movz.ps,movz.s,msub,msub.d,msub.ps,% 37 | msub.s,msubu,mtc0,mtc1,mtc1.d,mtc2,mthc1,mthc2,mthi,mtlo,mul,mul.d,mul.ps,mul.s,mulo,% 38 | mulou,mult,multu,neg,neg.d,neg.ps,neg.s,negu,nmadd.d,nmadd.ps,nmadd.s,nmsub.d,nmsub.ps,% 39 | nmsub.s,nop,nor,not,or,ori,pll.ps,plu.ps,pref,prefx,pul.ps,puu.ps,rdhwr,rdpgpr,recip.d,% 40 | recip.s,rem,remu,rfe,rol,ror,rotr,rotrv,round.l.d,round.l.s,round.w.d,round.w.s,rsqrt.d,% 41 | rsqrt.s,s.d,s.s,sb,sc,sd,sdbbp,sdc1,sdc2,sdxc1,seb,seh,seq,sge,sgeu,sgt,sgtu,sh,sle,sleu,% 42 | sll,sllv,slt,slti,sltiu,sltu,sne,sqrt.d,sqrt.s,sra,srav,srl,srlv,ssnop,sub,sub.d,sub.ps,% 43 | sub.s,subu,suxc1,sw,swc1,swc2,swl,swr,swxc1,sync,synci,syscall,teq,teqi,tge,tgei,tgeiu,tgeu,% 44 | tlbp,tlbr,tlbwi,tlbwr,tlt,tlti,tltiu,tltu,tne,tnei,trunc.l.d,trunc.l.s,trunc.w.d,trunc.w.s,ulh,% 45 | ulhu,ulw,ush,usw,wrpgpr,wsbh,xor,xori},% 46 | morekeywords=[2]{.alias,.align,.ascii,.asciiz,.asm0,.bgnb,.byte,.comm,.data,.double,.end,.endb,% 47 | .endr,.ent,.err,.extern,.file,.float,.fmask,.frame,.globl,.half,.kdata,.ktext,.lab,.lcomm,% 48 | .livereg,.loc,.mask,.noalias,.option,.rdata,.repeat,.sdata,.set,.space,.struct,.text,% 49 | .verstamp,.vreg,.word},% 50 | comment=[l]\#% 51 | }[keywords,comments,strings] 52 | -------------------------------------------------------------------------------- /listings_glsl.sty: -------------------------------------------------------------------------------- 1 | % Taken from http://blog.virtualglobebook.com/2011/02/syntax-highlighting-c-and-glsl-source.html 2 | \lstdefinelanguage{GLSL} { 3 | sensitive=true, 4 | morekeywords=[1]{ 5 | attribute, const, uniform, varying, 6 | layout, centroid, flat, smooth, 7 | noperspective, break, continue, do, 8 | for, while, switch, case, default, if, 9 | else, in, out, inout, float, int, void, 10 | bool, true, false, invariant, discard, 11 | return, mat2, mat3, mat4, mat2x2, mat2x3, 12 | mat2x4, mat3x2, mat3x3, mat3x4, mat4x2, 13 | mat4x3, mat4x4, vec2, vec3, vec4, ivec2, 14 | ivec3, ivec4, bvec2, bvec3, bvec4, uint, 15 | uvec2, uvec3, uvec4, lowp, mediump, highp, 16 | precision, sampler1D, sampler2D, sampler3D, 17 | samplerCube, sampler1DShadow, 18 | sampler2DShadow, samplerCubeShadow, 19 | sampler1DArray, sampler2DArray, 20 | sampler1DArrayShadow, sampler2DArrayShadow, 21 | isampler1D, isampler2D, isampler3D, 22 | isamplerCube, isampler1DArray, 23 | isampler2DArray, usampler1D, usampler2D, 24 | usampler3D, usamplerCube, usampler1DArray, 25 | usampler2DArray, sampler2DRect, 26 | sampler2DRectShadow, isampler2DRect, 27 | usampler2DRect, samplerBuffer, 28 | isamplerBuffer, usamplerBuffer, sampler2DMS, 29 | isampler2DMS, usampler2DMS, 30 | sampler2DMSArray, isampler2DMSArray, 31 | usampler2DMSArray, struct}, 32 | morekeywords=[2]{ 33 | radians,degrees,sin,cos,tan,asin,acos,atan, 34 | atan,sinh,cosh,tanh,asinh,acosh,atanh,pow, 35 | exp,log,exp2,log2,sqrt,inversesqrt,abs,sign, 36 | floor,trunc,round,roundEven,ceil,fract,mod,modf, 37 | min,max,clamp,mix,step,smoothstep,isnan,isinf, 38 | floatBitsToInt,floatBitsToUint,intBitsToFloat, 39 | uintBitsToFloat,length,distance,dot,cross, 40 | normalize,faceforward,reflect,refract, 41 | matrixCompMult,outerProduct,transpose, 42 | determinant,inverse,lessThan,lessThanEqual, 43 | greaterThan,greaterThanEqual,equal,notEqual, 44 | any,all,not,textureSize,texture,textureProj, 45 | textureLod,textureOffset,texelFetch, 46 | texelFetchOffset,textureProjOffset, 47 | textureLodOffset,textureProjLod, 48 | textureProjLodOffset,textureGrad, 49 | textureGradOffset,textureProjGrad, 50 | textureProjGradOffset,texture1D,texture1DProj, 51 | texture1DProjLod,texture2D,texture2DProj, 52 | texture2DLod,texture2DProjLod,texture3D, 53 | texture3DProj,texture3DLod,texture3DProjLod, 54 | textureCube,textureCubeLod,shadow1D,shadow2D, 55 | shadow1DProj,shadow2DProj,shadow1DLod, 56 | shadow2DLod,shadow1DProjLod,shadow2DProjLod, 57 | dFdx,dFdy,fwidth,noise1,noise2,noise3,noise4, 58 | EmitVertex,EndPrimitive}, 59 | morekeywords=[3]{ 60 | gl_VertexID,gl_InstanceID,gl_Position, 61 | gl_PointSize,gl_ClipDistance,gl_PerVertex, 62 | gl_Layer,gl_ClipVertex,gl_FragCoord, 63 | gl_FrontFacing,gl_ClipDistance,gl_FragColor, 64 | gl_FragData,gl_MaxDrawBuffers,gl_FragDepth, 65 | gl_PointCoord,gl_PrimitiveID, 66 | gl_MaxVertexAttribs,gl_MaxVertexUniformComponents, 67 | gl_MaxVaryingFloats,gl_MaxVaryingComponents, 68 | gl_MaxVertexOutputComponents, 69 | gl_MaxGeometryInputComponents, 70 | gl_MaxGeometryOutputComponents, 71 | gl_MaxFragmentInputComponents, 72 | gl_MaxVertexTextureImageUnits, 73 | gl_MaxCombinedTextureImageUnits, 74 | gl_MaxTextureImageUnits, 75 | gl_MaxFragmentUniformComponents, 76 | gl_MaxDrawBuffers,gl_MaxClipDistances, 77 | gl_MaxGeometryTextureImageUnits, 78 | gl_MaxGeometryOutputVertices, 79 | gl_MaxGeometryOutputVertices, 80 | gl_MaxGeometryTotalOutputComponents, 81 | gl_MaxGeometryUniformComponents, 82 | gl_MaxGeometryVaryingComponents,gl_DepthRange 83 | }, 84 | morecomment=[l]{//}, 85 | morecomment=[s]{/*}{*/}, 86 | morecomment=[l][keywordstyle4]{\#}, 87 | } -------------------------------------------------------------------------------- /vr.tex: -------------------------------------------------------------------------------- 1 | \chapter{Verteiltes Rechnen} 2 | 3 | Zusammenfassung der Vorlesung "`Verteiltes Rechnen"' aus dem Wintersemester 2017.\footnote{\url{https://www.scc.kit.edu/personen/11188.php}} 4 | 5 | \section{Einführung} 6 | 7 | \subsection{Verteilte Systeme und Middleware} 8 | \begin{itemize} 9 | \item Definition: Zusammenschluss unabhängiger Computer zu einem einzelnen, kohärenten System 10 | \item Single-View; Unterschiede zwischen den verschiedenen Systemen werden vor dem Nutzer verborgen 11 | \item Anforderungen: Skalierbar, erweiterbar, fehlertolerant 12 | \item Beispiele: Workstations als \texttt{DesktopGrid}, WWW 13 | \item \textbf{Ziele} 14 | \begin{itemize} 15 | \item Zusammenführen von Nutzern und Ressourcen: Sicherer Zugang zu entfernten Ressourcen. Verteiltes System wird oft (aus ökonomischen Gründen) zwischen verschiedenen Institutionen geteilt \(\rightarrow\) AAA notwendig 16 | \item Transparenz: Abstrahieren von Datenzugriffen (bsp. Repräsentation, Byte-Order, Parallelität) und Lokation; Fehlerbehandlung 17 | \item Offenheit: Erweiterbar und portierbar durch standardisierte Protokolle/Schnittstellen/Semantiken 18 | \item Skalierung 19 | \end{itemize} 20 | \end{itemize} 21 | 22 | 23 | \subsection{Web Services} 24 | \begin{itemize} 25 | \item XML-basiert (SOAP), plattformunabhängige Schnittstelle auf die mittels Webprotokoll zugegriffen werden kann \(\rightarrow\) ermöglicht lose Kopplung zwischen Systemen 26 | \item WSDL\footnote{Web Service Description Language} zur standardisierten Beschreibung. Stub-/Skeleton-Klassen können automatisch generiert werden ("`selbstbeschreibend"') 27 | \item Verwendung zur Maschine-zu-Maschine-Kommunikation. Explizit nicht anwenderfreundlich 28 | \end{itemize} 29 | 30 | 31 | \subsection{Web Services Resource Framework (WSRF)} 32 | \begin{itemize} 33 | \item Generisches Framework zur Definition/Verwendung zustandsbehafteter Web Services (bsp. Ressourcenzugriff) 34 | \item Bestandteile: Ressourcen, Lifecycle-Management, Service-Gruppen und Fehlerbehandlung 35 | \end{itemize} 36 | 37 | 38 | 39 | \section{Grid} 40 | \begin{itemize} 41 | \item Form des verteilten Rechnens, bei der ein virtueller Supercomputer aus einem Cluster lose gekoppelter Computer erzeugt wird\footnote{\url{https://de.wikipedia.org/wiki/Grid-Computing}} 42 | \item Typische Eigenschaften: Loose gekoppelt, heterogen, geografische Verteilung, häufig Verwendung von Standardsoftware 43 | \item \textbf{Checkliste nach Foster} 44 | \begin{itemize} 45 | \item Keine zentrale Kontrolle 46 | \item Verwendung allgemeiner, standardisierter, quelloffener Software und Schnittstellen 47 | \item Lieferung nicht-trivialer Dienstgüten (Antwortzeit, Durchsatz, Sicherheit, Verfügbarkeit, etc.). Mehrwert des Systems insgesamt höher als die Summe der Einzelsysteme 48 | \end{itemize} 49 | \item \textbf{Meta-Computing} 50 | \begin{itemize} 51 | \item Zusammenschluss unabhängiger, heterogener Supercomputer mittels Hochgeschwindkeits-WAN \(\rightarrow\) Verteilung einer einzelnen Anwendung über mehrere Supercomputer 52 | \item Beispiel: Gekoppelte Simulation, die ein einzelner Supercomputer nicht berechnen könnte 53 | \end{itemize} 54 | \item \textbf{Klassifikation} 55 | \begin{description} 56 | \item[Compute Grid:] Stellt Rechenkapazität zur Verfügung; weitere Spezifizierung in \textit{Desktop Grid} (oft Windows-basiert), \textit{Server Grids} (oft Unix-basiert) oder \textit{HPC-/Cluser-Grids} 57 | \item[Data Grids:] Stellt föderativen, sicheren, transparenten Hochgeschwindigkeitszugang zu Ressourcen zur Verfügung 58 | \item[P2P Grids:] Geteilter Zugriff auf Speicher eines Desktoprechners, zentral oder dezentral 59 | \item[Collaborative Grids:] Stellen Kollaborationsdienste zur Verfügung. Bsp. Videokonferenzen, Chaträume, live-Messdaten 60 | \end{description} 61 | \end{itemize} 62 | 63 | 64 | \subsection{Architektur} 65 | \begin{itemize} 66 | \item Verwendung von Middleware-Architekturen, die über Protokolle, APIs und SDK definiert sind 67 | \item Stundenglasmodell: Wenige zentrale Abstraktionen um möglichste viele Anwendungen zu unterstützen. Bsp. Internet: lediglich \texttt{IP} innerhalb des Netzwerk-Stacks vorgegeben 68 | \item \textbf{Anatomie: Schichtenarchitektur} 69 | \begin{itemize} 70 | \item Middleware-Schichten-Architektur, bestehend aus Protokollen, Services, APIs und SDKs 71 | \item Schichten 72 | \begin{description} 73 | \item[Collective Layer:] Verwaltung mehrerer Ressourcen mittels Verzeichnisdienste zum Allokieren, Schedulen, Verteilten/Monitoren/Replizieren 74 | \item[Resource Layer:] Ermöglicht Teilen einzelner Ressourcen mittels Standardprotokolle zum Verbindungsaufbau, Monitoring, Accounting, Bezahlen. Implementierung nutzt \textit{Fabric-Layer}-Methoden 75 | \item[Connectivity Layer:] Ermöglicht Verbindungen zwischen unterschiedlichen Fabric-Ressourcen (Transport, Routing, Naming, etc.), meist dem \texttt{IP}-Stack entnommen; Authentifizierung 76 | \item[Fabric Layer:] Physikalische Verbindung der geteilten Hardware-Ressourcen unter Berücksichtigung verschiedener Hardware-Typen und Verbindungstypen 77 | \end{description} 78 | \item Resource-Layer vs. Fabric-Layer: \textit{Fabric-Layer} umfasst die Plattform (Hardware und Betriebssystem); \textit{Resource-Layer} umfasst virtuelle, abstrakte Ressourcen 79 | \end{itemize} 80 | \item \textbf{Physiologie} 81 | \begin{itemize} 82 | \item Implementierung mittels OGSA\footnote{Open Grid Service Architecture}: Service-orientiertes Modell, auf dessen Ressourcen per WSRF\footnote{Web Services Resource Framework} zugegriffen wird 83 | \item Service-orientiert \(\rightarrow\) alle Ressourcen werden durch einen Service repräsentiert; alle Komponenten sind virtuell 84 | \item Beinhaltet Basisschnittstellen für den Ressourcenzugriff mittels WSRF sowie Capabilities für Integration/Management der Services 85 | \item OGS Capabilities 86 | \begin{description} 87 | \item[Execution Management Services:] Finden und auswählen möglicher Ausführungsorte sowie Vorbereiten/Initiieren/Verwalten der Ausführung 88 | \item[Data Service:] Verwalten entfernter Daten, inklusive Staging/Replikation/Derivation und Metadaten 89 | \item[Resource Management Services:] Verwaltung der Ressourcen sowie der dazugehörigen \texttt{OSGA}-Infrastruktur 90 | \item[Security Services:] (Föderative-) Authentifikation und Autorisierung 91 | \item[Self-Management Services:] Dient der automatische Grid-Verwaltung, inklusive Monitoring, Fehlertoleranz, Eigenreparatur, Analyse. Ziel: Anpassen der Konfiguration um SLA\footnote{Service-Level-Agreement} einzuhalten 92 | \item[Information Services:] Naming, Service-/Ressourcendiscovery, Logging/Monitoring 93 | \end{description} 94 | \end{itemize} 95 | \item Anatomie vs. Physiologie: \textit{Anatomie} beschreibt die Architektur eines Grids als Middleware; \textit{Physiologie} beschreibt die Kommunikation mittels OSGA 96 | \end{itemize} 97 | 98 | 99 | \subsection{Sicherheit} 100 | \begin{itemize} 101 | \item Grid-Ressourcen kommunizieren über das Internet \(\rightarrow\) Angreifer können Nachrichten lesen/ändern/löschen/hinzufügen/etc. 102 | \end{itemize} 103 | 104 | 105 | \subsection{Infrastruktur} 106 | \begin{itemize} 107 | \item \textbf{Hierarchisches Modell des Worldwide LHC Computing Grid (WLCG)} % TODO 108 | \begin{description} 109 | \item[Tier-0:] Aufzeichnen der Messdaten direkt am CERN (\textit{the accelarator centre}) 110 | \item[Tier-1:] Permanente Speicherung sowie datenintensive Analysen (12 \textit{regional centers} weltweit, beispielsweise GridKa) 111 | \item[Tier-2:] Simulationen und Endanwender-Analysen (\(\sim\) 150 Anlagen in 35 Ländern) 112 | \end{description} 113 | \end{itemize} 114 | 115 | 116 | \subsection{Job Submission} 117 | \begin{enumerate} 118 | \item Resource Discovery: Statisches Finden der passenden Ressourcen, die für die Job-Ausführung benötigt werden (und zu denen der Benutzer Zugang hat). Problem: Während der Discovery sind ggf. noch nicht alle Details der Ressourcen bekannt 119 | \item Resource Selection and Allocation: Anfordern detaillierter Informationen zu den Ressourcen inklusive periodischem Zustandsprüfen bis die Ressourcen allokiert wurden und dem Job zugeordnet sind. Wird v.a. benötigt um detailliertere Information zu den Ressourcen zu erlangen 120 | \item Execution und Job-Verwaltung: Grid-Middleware führt den Job aus (vgl. Betriebssystemaufgaben zur Prozessausführung). Zusätzlich erfolgt Monitoring 121 | \end{enumerate} 122 | 123 | 124 | 125 | \section{Big Data} 126 | 127 | \subsection{Einführung} 128 | \begin{itemize} 129 | \item \textbf{Charakteristika\footnote{\url{https://en.wikipedia.org/wiki/Big_data\#Characteristics}}} 130 | \begin{description} 131 | \item[Volume:] Die Menge der erzeugten/generierten Daten \(\rightarrow\) gibt Aufschluss über den Wert der Daten und ob es sich um "`Big Data"' handelt 132 | \item[Velocity:] Geschwindigkeit, in der die Daten gewonnen/verarbeitet werden. Bei Big Data oft in Echtzeit 133 | \item[Variety:] Typ/Art der Daten. Ermöglicht die effektive Nutzung der Daten. Big Data wird aus verschiedensten Quellen gewonnen und verknüpft 134 | \item[Value:] (Nicht-)Reproduzierbarkeit der Daten 135 | \item[Variability:] Inkonsistenzen der Daten können Verwaltungsprozesse verhindern oder erschweren 136 | \item[Veracity:] Qualität der Daten (bspw. Korrektheit) \(\rightarrow\) maßgeblich für Ausgabequalität 137 | \end{description} 138 | \item \textbf{Anwendung Charakteristika auf LHC\footnote{Large Hadron Collider}} 139 | \begin{description} 140 | \item[Volume:] Sehr wichtig, da mehrere Terabyte pro Sekunde erzeugt werden 141 | \item[Velocity:] Nicht so wichtig, da die Aggregation nicht während des Experiments erfolgen muss (implementierungsabhängig) 142 | \item[Variety:] Unwichtig, nur sehr wenige Datentypen 143 | \item[Value:] Unwichtig, da das Experiment wiederholt werden kann 144 | \item[Variability:] Unwichtig, da sich die Datentypen nicht ändern 145 | \end{description} 146 | \end{itemize} 147 | 148 | 149 | \subsection{Data Stewardship, Data Curation and Data Preservation} 150 | \begin{itemize} 151 | \item \textbf{Data Stewardship} 152 | \begin{itemize} 153 | \item Verantwortliche Nutzung und Sicherheit digitaler Güter. Beinhaltet Pflege, Verwaltung und Zugang 154 | \item Stellt \textit{Data Preservation} sicher und unterstützt \textit{Data Curation} 155 | \end{itemize} 156 | \item \textbf{Data Preservation} 157 | \begin{itemize} 158 | \item Ziel: Sicherstellung der Langzeit-Brauchbarkeit und Verfügbarkeit digitaler Güter 159 | \item Beeinhaltet Authentizität (digitales Logbuch), Verfügbarkeit (\textit{Trusted Source}), Nutzbarkeit (Formate, VMs, Emulation,...) und Integrität 160 | \item Speicherformate etc. müssen regelmäßig aktualisiert werden 161 | \item Bitstream-Preservation: Physische Datenhaltung auf Datenträgern 162 | \end{itemize} 163 | \item \textbf{Data Curation} 164 | \begin{itemize} 165 | \item Verwaltung und Wertsteigerung digitaler Güter \(\rightarrow\) Verwaltung der Metadaten 166 | \item Beinhaltet Zugang (inklusive Authentifizierung) und Rechteverwaltung 167 | \item Tätigkeiten: Hinzufügen von Erläuterungen; Erstellen von Verknüpfungen; Verbessern und Aktualisieren der Dokumentation 168 | \end{itemize} 169 | \end{itemize} 170 | 171 | 172 | \subsection{MapReduce} 173 | \begin{itemize} 174 | \item Skalierbares, massiv-paralleles Programmiermodell zum Verarbeiten extrem großer Datenmengen in Form von Key-Value-Paaren 175 | \item Ungeeignet bei Ahängigkeiten zwischen den Daten oder serieller Ausführung \(\rightarrow\) nicht parallelisierbar 176 | \item \textbf{Vorgehen} 177 | \begin{description} 178 | \item[Map:] Durchführen einer Map-Operation pro KV-Paar. Erzeugt \textit{Intermediate Values} 179 | \item[Reduce:] Zusammenfassen der selben \textit{Intermediate Values}. Eine \texttt{Reduce}-Instanz pro \textit{Intermediate}-Key mit einem Iterator auf sämtliche Values zu diesem Key 180 | \end{description} 181 | \item Schritte: Split, Map, Shuffle, Reduce 182 | \item \textbf{Beispiele} 183 | \begin{itemize} 184 | \item \texttt{WordCount} 185 | \begin{description} 186 | \item[Eingabe:] Liste mit Dokumenten; jede \texttt{Map}-Instanz gibt pro Wort ein KV-Paar weiter 187 | \item[Intermediate Value:] \texttt{EmitIntermediate(w, 1);} 188 | \item[Ausgabe:] Jede \texttt{Reduce}-Operation ermittelt über den Iterator die Häufigkeit des jeweiligen Wortes 189 | \end{description} 190 | \item \texttt{PageRank} 191 | \begin{itemize} 192 | \item Formel 193 | \begin{itemize} 194 | \item \(PR(u) = \frac{1-\beta}{N} + \beta \sum_{v \in B_u}\frac{PR(v)}{L(v)}\) 195 | \item \(\beta\): Dämpfungsfaktor, meist \(\beta \approx 0.8\). In der Praxis werden nicht unendliche viele Websites besucht; verhindert Selbstverlinkung, die zu einem unendlichen PageRank-Wert führen würden 196 | \item \(B_u\): Liste aller Seiten, die auf Seite \(u\) verweisen 197 | \item \(L_v\): Anzahl der ausgehenden Links von Seite \(v\) 198 | \end{itemize} 199 | \item Implementierung 200 | \begin{description} 201 | \item[Map:] Weitergabe von KV-Paaren der Form \texttt{\(\big(\)Ziel ausgehender Link, Anteil Quell-PageRank geteilt durch Anzahl ausgehender Links\(\big)\)} 202 | \item[Reduce:] Summe über die Elemente des Iterators 203 | \end{description} 204 | \end{itemize} 205 | \end{itemize} 206 | \end{itemize} 207 | 208 | 209 | 210 | \section{Cloud} 211 | 212 | \subsection{Einführung} 213 | \begin{itemize} 214 | \item \textbf{Checkliste (Abgrenzung gegenüber Grid-Computing)} 215 | \begin{itemize} 216 | \item Checkliste 217 | \begin{itemize} 218 | \item Zentrale Kontrolle 219 | \item Verwendung proprietärer Protokolle und Schnittstellen (bindet den Kunden an den Anbieter) 220 | \item Erfüllen eher "`einfache"' Aufgaben 221 | \end{itemize} 222 | \item Weitere Unterschiede 223 | \begin{itemize} 224 | \item Einsatz: Cloud kommerziell (Peakleistungsverteilung zwischen mehreren Kunden), Grid in der Forschung 225 | \item Grid-Rechner global verteilt, Cloud in Rechenzentren 226 | \end{itemize} 227 | \end{itemize} 228 | \item \textbf{Charakteristik (NIST)} 229 | \begin{description} 230 | \item[On-Demand Self-Service:] Kunden können Ressourcen automatisch, ohne Freischaltung durch Technikerpersonal, hinzubuchen 231 | \item[Broad Netwerk Access:] Ressourcen sind mittels Standardprotokolle über das Netzwerk zugänglich 232 | \item[Resource Pooling:] Die Ressourcen des Providers werden zusammengefasst mehreren Kunden zur Verfügung gestellt 233 | \item[Rapid Elasticity:] Kunden können Ressourcen dynmaisch verringern und erweitern (scale-in, scale-out) 234 | \item[Measured Service:] Die Ressourcenverwendung durch den Kunden wird automatisch verwaltet und optimiert. Abrechnungsgrundlage des Providers 235 | \end{description} 236 | \item \textbf{Deployment-Modelle} 237 | \begin{description} 238 | \item[Private Cloud:] Private Cloud einer einzelnen Organisation (beispielsweise öffentliche Verwaltung) 239 | \item[Community Cloud:] Wird Gemeinschaft mit gemeinsamem Ziel betrieben (selten verwendet) 240 | \item[Public Cloud:] Öffentliche Cloud mit typischerweise kommerziellem Interesse 241 | \item[Hybrid Cloud:] Mischung privater und öffentlicher Cloud(-systeme) (beispielsweise hinzubuchen von VMs einer öffentlichen Cloud zu einer privaten Cloud) 242 | \end{description} 243 | \item \textbf{Scale-Out vs. Scale-Up} 244 | \begin{description} 245 | \item[Scale-Out:] Hinzufügen weiterer Ressourcen-Einheiten (beispielsweise VMs) \(\rightarrow\) horizontale Skalierung 246 | \item[Scale-Up:] Verbesserung der einzelnen Ressourcen-Einheiten (beispielsweise bessere CPUs in VMs) \(\rightarrow\) vertikale Skalierung 247 | \end{description} 248 | \item \textbf{Service-Modelle} 249 | \begin{description} 250 | \item[IaaS:] Infrastructure-as-a-Service 251 | \item[PaaS:] Platform-as-a-Service 252 | \item[SaaS:] Software-as-a-Service 253 | \end{description} 254 | \end{itemize} 255 | 256 | 257 | \subsection{Virtualisierung} 258 | \begin{itemize} 259 | \item \textbf{Vorteile} 260 | \begin{itemize} 261 | \item Betriebssystem und Ressourcen können on-demand angepasst werden \(\rightarrow\) einfache Verwaltung 262 | \item Gäste sind isoliert (Sicherheit, dedizierte Leistung, etc.) 263 | \item Gäste können unkompliziert migriert werden 264 | \item Verwendung von Legacy-Systemen 265 | \end{itemize} 266 | \item \textbf{Virtualisierung vs. Emulation} 267 | \begin{description} 268 | \item[Virtualisierung:] Instruktionen des Gastsystemes werden (so weit wie möglich) direkt durch die Hardware des Hostsystems ausgeführt (\textit{Trap'n'emulate}) 269 | \item[Emuation:] Instruktionen des Gastsystems werden vom Host nachgebildet und ausgeführt. Ermöglicht die Ausführung von Fremdarchitekturen 270 | \end{description} 271 | \item Kritische Instruktionen: Sensitive, aber nicht privilegierte Instruktionen. 17 bei x86, beispielsweise \text{POPF} \(\rightarrow\) trappen nicht\footnote{\url{https://de.wikipedia.org/wiki/Virtualisierungsforderungen_von_Popek_und_Goldberg}} 272 | \item \textbf{Virtualisierungstypen} 273 | \begin{itemize} 274 | \item Vollvirtualisierung: \textit{Binary Translation} zur Laufzeit zum Finden und Ersetzen kritischer Anweisungen; User-Level-Anweisungen werden direkt ausgeführt (native Geschwindigkeit). Gast "`weiß"' nicht, dass er in einer virtuellen Umgebung läuft (\texttt{Ring 1}) 275 | \item Paravirtualisierung: Kritische Instruktionen werden vor der Ausführung durch \textit{Hypercalls} ersetzt und kommunizieren direkt mit dem Hypervisor. Gast "`weiß"', dass er virtuell läuft (\texttt{Ring 1}) 276 | \item Hardware-assistierte Virtualisierung (VT-x, AMD-V): Zusätzlicher Ausführungsmodus für Gastsysteme 277 | \item Speichervirtualisierung: Der physische Speicher des Gastes wird in den physischesn Speicher des Hypervisors gemappt \(\rightarrow\) Gast hat keinen direkten Zugriff aus den Arbeitsspeicher des Hosts 278 | \item Ring-Modell 279 | \begin{description} 280 | \item[Ring 3:] Emulation 281 | \item[Ring 2:] Paravirtualisierung 282 | \item[Ring 1:] Vollvirtualisierung 283 | \item[Ring 0:] Hostbetriebssystem 284 | \end{description} 285 | \end{itemize} 286 | \item \textbf{Docker} 287 | \begin{itemize} 288 | \item Container-Virtualisierung (LXC\footnote{\url{https://en.wikipedia.org/wiki/LXC}}): Leichtgewichtige, vollständige Ausführungsumgebung für Anwendungen. Beinhaltet Libraries und Konfigurationen; benötigt explizit kein dediziertes Betriebssystem sondern nutzt Betriebssystemfunktionalität des Hosts (beispielsweise \texttt{cgroups}\footnote{\url{https://en.wikipedia.org/wiki/Cgroups}} oder \texttt{namespaces}); allerdings schlechte Portierbarkeit 289 | \item Verwendet den Betriebssystem-Kernel \(\rightarrow\) meist sehr gute Performance bei wenig Overhead 290 | \end{itemize} 291 | \end{itemize} 292 | -------------------------------------------------------------------------------- /algo2spickzettel.tex: -------------------------------------------------------------------------------- 1 | \section{Appendix B: Spickzettel} 2 | 3 | \subsection{Flussnetzwerke} 4 | 5 | \subsubsection{Definitionen} 6 | \begin{itemize} 7 | \item Ein Flussnetzwerk besteht aus einer Kapazitätsfunktion \(k\), einem gerichteten Graph \(G\), einer Quelle \(q\) und einer Senke \(s\) 8 | \item \textbf{Eigenschaften eines Flusses \(f:V^2 \rightarrow \mathbb{R}\)} 9 | \begin{enumerate} 10 | \item \(f \leq k\) (der Fluss kann nicht höher sein als die Kantenkapazität) 11 | \item \(\forall x,y \in V:~f(x,y) = -f(y,x)\) (keine negativen Flüsse) 12 | \item \(\forall x \in V \setminus \{ q,s\}:~0 = \sum f(x,V) = \sum_{y \in V} f(x,y)\) (Flusserhalt) 13 | \end{enumerate} 14 | \item Wert eines Flusses: \(W_f = \sum f(q,V)\) 15 | \item Residualgraph: Die Kanten \(f(e) < k(e)~|~e \in E\) bilden den Residualgraph \(G_f = G(V,E_f)\) 16 | \end{itemize} 17 | 18 | \subsubsection{Maximaler Fluss} 19 | Der maximale Fluss ist 20 | \begin{itemize} 21 | \item die Summe der von \(q\) ausgehenden Kanten, 22 | \item bei \(s\) ankommenden genutzten Kapazitäten oder 23 | \item der minimale Schnitt durch das Netzwerk. 24 | \end{itemize} 25 | 26 | \subsubsection{Algorithmus von Ford und Fulkerson} 27 | \begin{itemize} 28 | \item Terminiert Ford-Fulkerson, so ist \(f\) maximal 29 | \item Aufwand: \(\mathcal{O}(|E| \cdot max\{W_f~|~f~Fluss~in~F\})\), denn ein Pfad \(q \rightarrow^{*} s\) kann in \(|E|\) Schritten gefunden werden 30 | \end{itemize} 31 | 32 | \subsubsection{Algorithmus von Edmonds und Karp} 33 | Erhöhe den Fluss in \textit{FORD-FULKERSON} immer längs eines kürzesten Pfads (Breitensuche). Aufwand: \(\mathcal{O} (|E|^2 \cdot |V|)\). 34 | 35 | \subsubsection{Präfluss-Pusch-Methode} 36 | Jeder Knoten erhält zusätzlich eine Höhe und ein Reservoir, um vorübergehend beliebig viel Fluß speichern zu können. Aufwand: \(\mathcal{O} (|V|^2 \cdot |E|)\). 37 | 38 | \subsubsection{Move-to-Front-Algorithmus} 39 | Durch eine strukturierte Abarbeitung der Operationen wird \textit{Präfluss-Pusch} beschleunigt. Aufwand: \(\mathcal{O}(|V|^3)\) 40 | 41 | 42 | \subsection{Zuordnungsprobleme} 43 | 44 | \subsubsection{Paare in bipartiten Graphen} 45 | TODO 46 | 47 | \subsubsection{Paarungsvergrößerung in allgemeinen Graphen} 48 | \begin{itemize} 49 | \item Suche \((x,y)\) mit ungepaartem \(x\) 50 | \item Setze \((x,y)\) durch Breitensuche zu einem alternierenden, maximalen Weg ungerader Länge fort 51 | \end{itemize} 52 | 53 | \subsubsection{Maximal gewichtete Paarungen} 54 | Man kann eine maximal gewichtete Paarung finden, indem eine maximal gewichtete Kante iterativ durch einen vergrößernden Weg zu einer nächst größeren und maximal gewichteten Paarung vergrößert wird. Aufwand: \(\mathcal{O}(min\{|V|^3, |V| \cdot |E| \cdot log|V|\})\) 55 | 56 | \subsection{Stochastische Algorithmen} 57 | 58 | \subsubsection{Algorithmen} 59 | \begin{itemize} 60 | \item Las Vegas Algorithmen: Falls der Algorithmus terminiert, ist das Ergbenis korrekt (nichtdeterministisch) 61 | \item Monte Carlo Algorithmus: Der Algorithmus terminiert immer, allerdings ist das Ergebnis mit einer bestimmten Wahrscheinlichkeit falsch 62 | \end{itemize} 63 | 64 | \subsubsection{Erwartungswert} 65 | \begin{itemize} 66 | \item Die Zufallsvariable \(X_i\) nimmt mit einer Wahrscheinlichkeit \(p\) einen bestimmten Wert an 67 | \item \(\mathbb{E}\lbrack \sum X_i \rbrack = \sum \mathbb{E} \lbrack X_i \rbrack\) 68 | \end{itemize} 69 | 70 | \subsubsection{Bedingte Wahrscheinlichkeit} 71 | \[Pr\lbrack E_1 | E_2 \rbrack = \frac{Pr \lbrack E_1 \cap E_2 \rbrack}{Pr \lbrack E_2 \rbrack}\] 72 | 73 | \subsubsection{SCHNITT} 74 | Solange die Gesamtkantenzahl \(\geq 3\) ist, wähle zufällig eine Kante \((x,y)\), entferne alle \((x,y)\) und verschmelze \(x\) mit \(y\). 75 | 76 | 77 | \subsection{Spieltheorie} 78 | \begin{itemize} 79 | \item Jedes 2-Personen-Nullsummenspiel wird durch die Spielmatrix \(M = \lbrack m_{ij} \rbrack_{i,j=1,1}^{m,n}\) beschrieben 80 | \item Optimale Strategie von \(A\): \(max_i~min_j~M_{ij}\) (maximiert den Mindestgewinn von \(A\)) 81 | \item Optimale Strategie von \(B\): \(min_j~max_i~M_{ij}\) (minimiert den Maximalverlust von \(B\)) 82 | \item Verfolgen \(A\) und \(B\) gemischte Strategien, so gilt: \(\mathbb{E} \lbrack Gewinn(A)\rbrack = p^TMq\) 83 | \end{itemize} 84 | 85 | \subsubsection{Minimax Theorem} 86 | Sei $M=\begin{pmatrix} 87 | 5 & 6 \\ 88 | 7 & 4 89 | \end{pmatrix} $ dann ist $ min_y = \begin{pmatrix} 90 | x & 1-x 91 | \end{pmatrix} 92 | \begin{pmatrix} 93 | 5 & 6 \\ 94 | 7 & 4 95 | \end{pmatrix} = 0 $ Nullsetzen.\newline $max_x = 96 | \begin{pmatrix} 97 | 5 & 6 \\ 98 | 7 & 4 99 | \end{pmatrix} 100 | \begin{pmatrix} 101 | y \\ 102 | 1-y 103 | \end{pmatrix} = 0 $ ebenfalls Nullsetzen. 104 | Die Nullstellen entsprechen dem Ergebnis. \newline Also ist $f(x,y)=(max_x,min_y)$ bzw. $(\begin{pmatrix} 105 | max_x \\ 106 | 1 - max_x 107 | \end{pmatrix} 108 | , 109 | \begin{pmatrix} 110 | min_y \\ 111 | 1 - min_y 112 | \end{pmatrix} )$ und der Wert ergibt sich durch Einsetzen in $ max_x \cdot min_y \cdot M=f(x,y) = 113 | \begin{pmatrix} 114 | x & 1-x 115 | \end{pmatrix} 116 | \begin{pmatrix} 117 | 5 & 6 \\ 118 | 7 & 4 119 | \end{pmatrix} 120 | \begin{pmatrix} 121 | y \\ 122 | 1-y 123 | \end{pmatrix}$ und von rechts nach links ausrechnen. 124 | 125 | \subsubsection{Von Neumanns Minimax Theorem} 126 | \[max_p~min_q~p^TMq = min_q~max_p~p^TMq\] 127 | 128 | \subsubsection{Yaos Technik} 129 | Lautzeitabschätzung eines stochastischen Algorithmus \(A\) für ein Problem \(P\). 130 | \begin{itemize} 131 | \item Worst-Case-Laufzeit: \(max_i~M_{ij}\) 132 | \item Best-Case-Laufzeit: \(min_j~M_{ij}\) 133 | \item Deterministische Komplexität \(K_d\) von \(P\): \(min_j~max_i~M_{ij}\) 134 | \item Stochastische Komplexität \(K_s\) von \(P\): \(max_i~min_j~M_{ij}\) 135 | \item \(K_s \leq K_d\) 136 | \item Verteilungskomplexität \(K_v\): \(max_p~min_q~p^TMq\) 137 | \end{itemize} 138 | 139 | \subsubsection{Spielbaumauswertung} 140 | \[Wert(x) = Wert(y) \downarrow Wert(z)\] 141 | 142 | TODO: Algorithmus 143 | 144 | 145 | \subsection{Algorithmen für geometrische Probleme} 146 | 147 | \subsubsection{Binärer Raumzerlegungsbaum (RZB)} 148 | \begin{itemize} 149 | \item Gerichtete Strecken \(s_1,...,s_n\) zerlegen eine Ebene \(A\) 150 | \item Ziel: Kleine RZBs mit wenigen Zerlegungen 151 | \item Aufwand: \(\mathbb{E} \lbrack~|Zerlegungen|~\rbrack < 2nlogn\) 152 | \end{itemize} 153 | 154 | \begin{minipage}{\textwidth} 155 | BRZ 156 | \begin{lstlisting}[frame=single,numbers=left,mathescape] 157 | $k = 1$ 158 | Forall $P_i$ { 159 | Bestimme Schnittflaeche mit $P$ 160 | Falls es eine Schittflaeche gibt: $k++$ 161 | } 162 | $l = 1$ 163 | Falls es ein $j$ gibt: $Q_j$ zerlegt $P$ { 164 | $l = j$ 165 | } 166 | Wurzel = $Q_l$ 167 | Falls $k \geq 3$ { 168 | $Q$ = Schnittmenge von $P$ und dem li. HR von $Q_l$ 169 | linker Wurzelteilbaum = $BRZ(Q,Q_1,...,Q_{k-1})$ 170 | $Q$ = Schnittmenge von $P$ und dem re. HR von $Q_l$ 171 | rechter Wurzelteilbaum = $BRZ(Q,Q_1,...,Q_{k-1})$ 172 | } 173 | Return Wurzel und Teilbaeume 174 | \end{lstlisting} 175 | \end{minipage} 176 | 177 | \subsubsection{Beziehungen zwischen Knoten, Kanten und Facetten} 178 | Für einen Polyeder mit \(v\) Knoten, \(e\) Kanten und \(f\) Seiten gilt: 179 | \begin{itemize} 180 | \item \(v-e+f=2\) (Eulers Formel) 181 | \item \(\frac{2e}{v} \leq 6\) (mittlerer Knotengrad) 182 | \item \(\frac{2e}{f} \leq 6\) (mittlere Kantenzahl) 183 | \end{itemize} 184 | 185 | \subsubsection{Konvexe Hülle} 186 | \textbf{Aufwand: } \(\mathcal{O}(nlogn)\) 187 | \\\\ 188 | \begin{minipage}{\textwidth} 189 | KONVEXE HÜLLE 190 | \begin{lstlisting}[frame=single,numbers=left,mathescape] 191 | # TODO anschaulich 192 | \end{lstlisting} 193 | \end{minipage} 194 | 195 | 196 | \subsection{Geometrische Algorithmen} 197 | Generell ist hierbei die Qualität der Ausgabe wichtiger als die Laufzeit. Es kann sein, dass keine oder keine eindeutige Lösung existiert. 198 | 199 | \subsubsection{Ausweg aus einem Labyrinth} 200 | Wir betrachten ein Labyrinth \(L\) und einen Roboter \(R\) mit Tastsensor und Drehwinkelmessgerät. 201 | \\\\ 202 | \begin{minipage}{\textwidth} 203 | PLEDGE-Strategie 204 | \begin{lstlisting}[frame=single,numbers=left,mathescape] 205 | While $R \in L$ { 206 | Gehe vorwaerts bis Wand kontaktiert wird 207 | While $R \in L$ OR Drehwinkel = $0$ { 208 | Gehe links der Wand 209 | } 210 | } 211 | \end{lstlisting} 212 | \end{minipage} 213 | 214 | \subsubsection{Zum Ziel in unbekannter Umgebung} 215 | Gegeben sind \(P_1,...P_n\) disjunkte Polygone, ein Roboter \(r\), ein Startpunkt \(s\) und ein Ziel \(z\). 216 | \\\\ 217 | \begin{minipage}{\textwidth} 218 | WANZE 219 | \begin{lstlisting}[frame=single,numbers=left,mathescape] 220 | While $r \ne z$ { 221 | Laufe in Richtung $z$ bis $r == z$ 222 | OR $r$ nicht aus einem Polygon herauskommt 223 | Falls $r \ne z$ { 224 | Suche den kuerzesten Punkt $q$ an $P_i$ zu $z$ 225 | Laufe zu $q$ 226 | } 227 | } 228 | \end{lstlisting} 229 | \end{minipage} 230 | Wanze terminiert. 231 | 232 | \subsubsection{Türsuche} 233 | \paragraph{Algorithmus} Laufe abwechselnd links und rechts einer Wand und verlängere iterativ die Laufweite. 234 | 235 | \paragraph{Berechnung des Kompetivitätsfaktors} 236 | Ist die Tür im ungünstigsten Fall \(d = 2^{n + \delta}\) entfernt, so gilt: 237 | \[w \leq 2 \sum_{i=0}^{n+1} + d = 2^{n+3+\delta} + d \leq 9 \cdot 2^{n+\delta}\] 238 | 239 | \subsubsection{Sternsuche} 240 | \paragraph{Algorithmus} Gegeben sind \(m\) regelmäßig angeordnete Halbgeraden mit einem gemeinesamen Startpunkt \(s\), wobei sich das Ziel auf einer Halbgeraden mit unbekanntem Abstand von \(s\) befindet. Laufe reihum mit wachsender Suchtiefe, bis das \(z\) gefunden ist. 241 | 242 | \paragraph{Berechnung des Kompetivitätsfaktors} 243 | TODO 244 | 245 | \subsubsection{Suche in Polygonen} 246 | TODO? 247 | 248 | 249 | \subsection{Lineare Programmierung} 250 | 251 | \subsubsection{Simplex-Algorithmus} 252 | 253 | \begin{minipage}{\textwidth} 254 | SIMPLEX 255 | \begin{lstlisting}[frame=single,numbers=left,mathescape] 256 | Solange ein $c_S > 0$ 257 | Falls alle $b_{is} \geq 0$ 258 | Keine Loesung 259 | Sonst 260 | Bestimme $r$ so, dass $\frac{b_r}{b_{rs}} = max_{(b_{is} < 0)}~\frac{b_i}{b_{is}}$ 261 | AUSTAUSCH 262 | \end{lstlisting} 263 | \end{minipage} 264 | 265 | \begin{minipage}{\textwidth} 266 | AUSTAUSCH(A, r, s) 267 | \begin{lstlisting}[frame=single,numbers=left,mathescape] 268 | Forall $i \ne r$, $j \ne s$ { 269 | $a_{ij}' = a_{ij} - \frac{a_{is} \cdot a_{rj}}{a_{rs}}$ 270 | } 271 | # Pivotzeile 272 | Forall $i == r$, $j \ne s$ { 273 | $a_{ij}' = -\frac{a_{ij}}{a_{rs}}$ 274 | } 275 | # Pivotspalte 276 | Forall $i \ne r$, $j == s$ { 277 | $a_{ij}' = \frac{a_{ij}}{a_{rs}}$ 278 | } 279 | # Pivot 280 | Forall $i == r$, $j == s$ { 281 | $a_{ij}' = \frac{1}{a_{rs}}$ 282 | } 283 | \end{lstlisting} 284 | \end{minipage} 285 | 286 | \subsubsection{Lösen einer Spielmatrix mit Simplexalgorithmus} 287 | \textbf{Gegeben:} \(A = \begin{pmatrix} 5 & 6 \\ 7 & 4 \end{pmatrix}\). Daraus ergibt sich das lineare Programm: 288 | \[\begin{pmatrix} 5 & 6 & -1 & 0 \\ 7 & 4 & -1 & 0 \\ -1 & -1 & 0 & 1 \\ 0 & 0 & 1 & 5 \end{pmatrix}\] 289 | 290 | \(\begin{pmatrix} 5 & 5 \\ 5 & 5 \end{pmatrix}\) kann zur Vereinfachung erstmal von der Ausgangsmatrix abgezogen, muss beim Ergebnis allerdings berücksichtigt werden. 291 | 292 | \subsubsection{Ausgleichen/Minimieren mit der Maximumsnorm} 293 | \textbf{Ziel:} Minimiere mit Hilfe der Maximusnorm \(\begin{pmatrix} y(-1) & -(-1) \\ y(0) & -1 \\ y(1) & -1 \end{pmatrix}\). 294 | \\\\ 295 | Daraus ergibt sich das überbestimmte Gleichungssystem 296 | \[\begin{pmatrix} 1 & -1 \\ 1 & 0 \\ 1 & 1 \end{pmatrix} \begin{pmatrix} x_1 \\ x_2 \end{pmatrix} = \begin{pmatrix} -1 \\ 1 \\ 1\end{pmatrix}.\] 297 | \\\\ 298 | Das Gleichungssystem zeigt die invertierten und nicht-invertierten Nebenbedingungen des Linearen Programms: 299 | \[\begin{array}{ccc|c} 300 | x_0 & x_1 & x_2 \\ 301 | \hline 302 | -1 & -1 & -1 & 1 \\ 303 | 1 & -1 & 0 & 1 \\ 304 | 1 & -1 & 1 & 1 \\ 305 | -1 & 1 & -1 & 1 \\ 306 | -1 & 1 & 0 & 1 \\ 307 | -1 & 1 & 1 & 1 \\ 308 | \hline 309 | 1 & 0 & 0 & 0 \\ 310 | \end{array}\] 311 | Das Lineare Programm kann zeichnerisch oder rechnisch gelöst werden (siehe Klausuraufgabe 7/WS2014). 312 | 313 | \subsubsection{Berechnung der Normalform} 314 | Unter Verwendung der Normalform können sukszessive Zeilen in der Reihenfolge \(r=1,2,...,n\) eleminiert werden. Das der Ursprung dabei im Simplex bleibt, muss gelten: 315 | \[a_i - \frac{a_{ir}\cdot a_r}{a_{rr}} \geq 0,~ \forall i>r\] 316 | 317 | \paragraph{Algorithmus} 318 | \begin{enumerate} 319 | \item Prüfe ob Zeile \(i\) eleminiert werden kann 320 | \item Wende \textit{AUSTAUSCH} an 321 | \item Streiche Zeile \(i\) und gehe zur nächsten Zeile 322 | \end{enumerate} 323 | 324 | 325 | 326 | \subsection{de Casteljau} 327 | \[\frac{\Delta B_0}{t} \frac{\Delta B_1}{t-1} = C(\Delta B,t)\] 328 | 329 | 330 | \subsection{Unterteilungsalgorithmen} 331 | Das Differenzenschema existiert nur, wenn \(\alpha(z)\) den Faktor \(1+z\) besitzt oder 332 | \[\alpha(-1) = \sum_{i \in \mathbb{Z}} \alpha_{2i} - \sum_{i \in \mathbb{Z}}\alpha_{2i + 1} = 0\] 333 | gilt. 334 | 335 | \subsubsection{Unterteilungsmatrizen} 336 | Die Unterteilungsmatrizen stellen den Algorithmus dar. 337 | 338 | \subsubsection{Symbol} 339 | \begin{itemize} 340 | \item \(\alpha (z) \) ist das Symbol des Unterteilungsalgorithmus und stellt den Algorithmus dar \(\rightarrow\) kann ersetzt werden, um einen beliebigen Algorithmus zu erhalten 341 | \item \(c(z^2)\) ist die Ausgangsmatrix, die unterteilt wird 342 | \item \(b(z) = \alpha(z) \cdot c(z^2)\) ist die Unterteilungsgleichung 343 | \end{itemize} 344 | 345 | 346 | \subsubsection{Differenzenschema} 347 | \(\beta(z)\) bezeichnet das Differenzenschema zu \(\alpha\). 348 | \[\beta(z) = \frac{\alpha(z)}{1+z}\] 349 | \\\\ 350 | Das Differenzenschema zu \(\alpha(z)\) existiert nur, wenn \(\alpha(z)\) den Faktor \((1+z)\) hat, bzw. wenn 351 | \[\alpha(-1) = \sum_{i \in \mathbb{Z}}\alpha_{2i} - \sum_{i \in \mathbb{Z}}\alpha_{2i+1} = 0.\] 352 | 353 | \subsubsection{Konvergenz} 354 | Die Funktion \(c^k(x)\) konvergiert gegen eine Funktion \(c_{\infty}(x)\) so, dass 355 | \[sup(x \in \mathbb{R})~|~c_{\infty}(x) - c^k(x)~|~\in \mathcal{O}(4^{-k}).\] 356 | 357 | \paragraph{Folgerung 1} 358 | Die skalierten Differenzpolygone \(2^k d^k(x)\) (Ableitungspolygone) konvergieren gegen 359 | \[\frac{d}{dx} c_{\infty}(x).\] 360 | 361 | \paragraph{Folgerung 2} 362 | Induktiv folgt aus \textit{Folgerung 1}, dass die \(n\)-te Ableitung 363 | \[\frac{d^n}{dx^n} c_{\infty}(x)\] 364 | der Limesfunktion stückweise konstant ist. 365 | 366 | 367 | \subsection{Unterteilungsalgorithmen für Flächen} 368 | Die Matrizen \(U\) und \(V\) sind stationäre Unterteilungsalgorithmen für Kurven und unterteilen das biinfinite Kontrollnetz wie folgt (Tensorproduktunterteilungsschema, Tepus): 369 | \[B = b_{\mathbb{Z}^2} = UCV^T\] 370 | 371 | \subsubsection{Symbole} 372 | \begin{itemize} 373 | \item \(\alpha(x)\) und \(\beta(y)\) sind die Symbole von \(U\) und \(V\) 374 | \item \(c_{\mathbb{Z}^2}\) ist das Symbol des Kontrollnetzes 375 | \item \(b(x,y) = \alpha(x) \cdot c(x^2,y^2) \cdot \beta(y)\) 376 | \item \(\gamma(x,y) = \alpha(x) \cdot \beta(y) = \sum \gamma_{ij} \cdot x^i \cdot y^j\) ist das Symbol des neuen Unterteilungsschemas 377 | \item \(b(x,y) = \gamma(x,y) \cdot c(x^2,y^2)\) 378 | \end{itemize} 379 | 380 | \subsubsection{Masken} 381 | Siehe Übungsaufgabe 11.1 und 11.2. 382 | 383 | 384 | \subsection{Boyer-Moore-Algorithmus} 385 | Siehe Algorithmen im Skript. Alphabet beachten! 386 | 387 | 388 | \subsection{Optimierungsprobleme Lineare Programmierung} 389 | 390 | TODO: AUSTAUSCH Algorithmus 391 | TODO: Hässlicher Grundaufbau 392 | TODO: SIMPLEX + Vertauschungen 393 | 394 | 395 | \subsection{Stochastische Verfahren} 396 | \subsubsection{Feststellung von 397 | Dueck,Scheuer und Wallmeister} 398 | \begin{itemize} 399 | \item Schwellwert-Verfahren 400 | und simuliertes Tempern können aus 401 | kleinen, aber tiefen lokalen Minima 402 | entkommen, die anderen Verfahren 403 | nicht. 404 | \item Aber bei 405 | hoch-nicht-lineraren 406 | Optimierungsaufgaben mit vielen 407 | Parametern sind lokale Extremwerte im 408 | Allgemeinen weniger markant und tief. 409 | \item Sinflut und 410 | Schwellwert-Verfahren sind dem 411 | simulierten Tempern überlegen. 412 | \end{itemize} 413 | 414 | 415 | \subsection{Evolutionäre Algorithmen} 416 | Nachkommen mutieren nach der Regel 417 | $q^(t+1) = q^t +d$ ,wobei d normal 418 | oder geometrisch verteilt mit dem 419 | Steuungsvektor $\sigma$ ist. Das 420 | Heißt 421 | ein Nachkomme kann um bis zu $\sigma$ 422 | vom Elter abweichen. 423 | 424 | \subsubsection{ Die Plus oder ( $\mu$ 425 | + 426 | $\lambda$ ) Evolutionsstrategie} 427 | Zu jedem Zeitpunkt werden $\lambda$ 428 | Nachkommen erzeugt jedoch überleben 429 | nur $\mu$ Individuen der besten 430 | Fitness 431 | $c(q)$ . Eltern können überleben 432 | 433 | \subsubsection{Komma oder 434 | ($\mu$ , $\lambda$ 435 | )Evolutionsstrategie} 436 | Gleich der Plus-Strategie, aber 437 | Eltern überleben nicht. Nur unter den 438 | Nachkommen überleben die Stärksten. 439 | 440 | \subsection{Genetische Algorithmen} 441 | \subsubsection{Fortpflanzung} 442 | Jedes Individuum q wird mit Wahrscheinlichkeit $W(q)=c(p)/ \sum_{p \in Q}c(p)$ Elter. Die $\mu$ Individuen der Population erzeugen $\mu$ Klon Nachkommen nur diese überleben. 443 | \subsubsection{Kreuzung} 444 | Unter den $\mu$ Nachkommen werden p\% Individuen der Kreuzung unterzogen. Zufällige Kreuzungspaare. 445 | $a:= (a_1, \dots , a_n)$ und $ b:=(b_1, \dots , b_n)$ ergibt $c:= (a_1 , \dots , a_j , b_{j+1} , \dots , b_n$ und $d:= ( b_1 , \dots , b_j , a_{j+1} , \dots , a_n)$ 446 | \subsubsection{Mutation} 447 | Invertierung jedes Bits des Merkmalsvektors mit sehr niederiger Wahrscheinlichkeint $p_m$ 448 | 449 | \subsection{Vergleich Evolutionsstrategien und Genetische Algorithmen} 450 | \subsubsection{Evolutionsstrategien} 451 | \begin{itemize} 452 | \item konvergieren im allgemeinen schneller 453 | \item enden öfter im lokalen Minimum 454 | \end{itemize} 455 | \subsubsection{Genetische Algorithmen} 456 | \begin{itemize} 457 | \item bevorzugen Kreuzung vor Mutation 458 | \item spähen daher Suchraum in größeren Sprüngen aus 459 | \item finden öfter ein globales Optimum 460 | \item aber konvergieren schlechter 461 | \end{itemize} 462 | 463 | \subsection{Partikelschwarm-Optimierung} 464 | Ein Schwarm besteht aus Partikeln. i-ter Parikel: \begin{itemize} 465 | \item Position $p_i(t)$ im $\mathbb{R}^n$ 466 | \item Fitness $f(p_i)$ 467 | \item Geschwindigkeit $v_i(t)=p_i(t)-p_i(t-1)$ 468 | \end{itemize} Dabei wird $f(x)$ optimiert. 469 | \begin{itemize} 470 | \item \textbf{Initialisiere} die $p_i(0)$ und $v_i(0)$ zufällig. Zum Zeitpunkt $t$ sei $q_i$ die bisher beste Position von $p_i$ und $q$ das bisher beste $q_i$ 471 | \item \textbf{Aktualisiere} damit die nächsten Positionen und Geschwindigkeiten: $v_i \leftarrow v_i + \omega + (q_i - p_i)*c_1 * r_1 + (q - p_i)*c_2 *r_2$ 472 | wobei $\omega$ , 473 | $c_1$ , $c_2$ 474 | Lernkonstanten und $r_1$, $r_2$ Zufallszahlen in $[1,2]$ 475 | \item \textbf{Typische Zahlen:} 20-40 Partikel, $\omega \in [0.4,0.9]$, $c_1=c_2 \in [0,4]$ 476 | \end{itemize} 477 | 478 | \subsection{Ameisen-System} 479 | Seien ${1, \dots , n}^2$ die Kantenmenge eines Graphen, $d_{ij}$ Länge Kante $ij$ und $p_{ij}$ die Intensität Pheromonmarkierung. 480 | Von $m$ Knoten aus wird je eine Ameise auf eine Rundreise geschickt danach $p_{ij}$ neu gesetzt. 481 | 482 | $p_{ij}= \rho p_{ij} + \sum_{k} 483 | \Delta p_{ij}^k $ 484 | , wobei $\rho$ eine Evaporationsrate in 485 | $[0,1)$ 486 | 487 | $\Delta p_{ij}^k = 488 | \left\{\begin{array}{cl} 489 | 1/d_{ij}, & \mbox{falls Ameise k Kante ij benutzte }\\ 490 | 0, & \mbox{sonst} 491 | \end{array}\right.$ 492 | 493 | TODO: Wenn noch Platz komplette Altklausur auf den Spickzettel packen 494 | -------------------------------------------------------------------------------- /telematik-themen.mm: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214 | 215 | 216 | 217 | 218 | 219 | 220 | 221 | 222 | 223 | 224 | 225 | 226 | 227 | 228 | 229 | 230 | 231 | 232 | 233 | 234 | 235 | 236 | 237 | 238 | 239 | 240 | 241 | 242 | 243 | 244 | 245 | 246 | 247 | 248 | 249 | 250 | 251 | 252 | 253 | 254 | 255 | 256 | 257 | 258 | 259 | 260 | 261 | 262 | -------------------------------------------------------------------------------- /assetpricing.tex: -------------------------------------------------------------------------------- 1 | \chapter{BWL: Asset Pricing} 2 | 3 | Zusammenfassung der Vorlesung "`Asset Pricing"' aus dem Sommersemester 2017.\footnote{\url{https://derivate.fbv.kit.edu/942.php}} 4 | 5 | 6 | 7 | \section{Einführung} 8 | \begin{itemize} 9 | \item \textbf{Kovarianz zweier Zufallsvariablen \(X\) und \(Y\)} 10 | \begin{description} 11 | \item[Kovarianz ist positiv:] Monotoner Zusammenhang \(\rightarrow\) Werte von \(X\) und \(Y\) sind entweder beide hoch oder beide niedrig 12 | \item[Kovarianz ist negativ:] Gegensinniger monotoner Zusammenhang \(\rightarrow\) Wert von \(X\) ist hoch, Wert von \(Y\) ist niedrig (und umgekehrt) 13 | \item[Kovarianz ist Null:] Kein monotoner Zusammenhang 14 | \end{description} 15 | \end{itemize} 16 | 17 | 18 | 19 | \section{Stochastischer Diskont-Faktor Ansatz} 20 | \begin{itemize} 21 | \item SDF ist zufällig und für alle Assets identisch 22 | \item Häufig als \textit{reale} Größe modelliert, da Konsum üblicherweise als \textit{reale} Größe gemessen wird 23 | \item In schlechten Zuständen hoch, da eine Zahlung dann besonders wertvoll ist 24 | \end{itemize} 25 | 26 | \subsection{Powernutzenfunktion} 27 | \begin{itemize} 28 | \item \textbf{Anforderungen} 29 | \begin{itemize} 30 | \item Positiver Grenznutzen: \(u^\prime(c)>0\); "`mehr ist besser als weniger"' (nicht-gesättigter Investor) 31 | \item Abnehmender Grenznutzen: \(u^{\prime\prime}(c)<0\); je höher der Konsum, desto geringer ist der weitere Nutzenzuwachs 32 | \end{itemize} 33 | \item \textbf{Interpretation von \(\gamma\) ("`Krümmungsparameter"')} 34 | \begin{description} 35 | \item[\(\gamma<0\):] Risikofreudig; kleineres \(\gamma\) bedeutet höhere Risikofreudigkeit 36 | \item[\(\gamma=0\):] Risikoneutral 37 | \item[\(\gamma>0\):] Risikoavers; höheres \(\gamma\) bedeutet höhere Risikoaversion und höhere Krümmung der Funktion \(\rightarrow\) höhere Risikovergütung gefordert (verdeutlicht durch die Krümmung) 38 | \end{description} 39 | \end{itemize} 40 | 41 | \subsection{Zentrale Bewertungsgleichung mit SDF} 42 | \begin{itemize} 43 | \item Zentrale Bewertungsgleichung: \(p=\mathbb{E} \big\lbrack \beta \frac{u^\prime(c_{t+1})}{u^\prime(c_t)} \cdot x_{t+1} \big\rbrack\) 44 | \item \(m_{t+1} = \beta \cdot \frac{u^\prime(c_{t+1})}{u^\prime(c_t)}\) (SDF) vereinfacht die zentrale Bewertungsgleichung zu \(p=\mathbb{E} \big\lbrack m_{t+1} x_{t+1} \big\rbrack\) 45 | \end{itemize} 46 | 47 | \subsubsection{Beispiele für Preise und Zahlungen} 48 | \begin{itemize} 49 | \item Aktieninvestment: Preis \(p_t\) setzt sich aus Preis \(p_{t+1}\) und Dividendenzahlung \(d_{t+1}\) zusammen (siehe \ref{eq:paktie}) 50 | \item Brutto-Return: Berechnung des anteiligen "`Gewinnzuwachses"' im Erfolgsfall (siehe \ref{eq:br}) 51 | \item Überschuss-Return: Zahlung eines Portfolios ohne Kapitaleinsatz mit \(p_t=0\) (siehe \ref{eq:uer}) 52 | \item Einperiodige Anleihe: Anleihepreis in \(t\), Rückzahlung \(x_{t+1}=1\) (siehe \ref{eq:an}) 53 | \item Geldmarktkonto: siehe \ref{eq:gmk} 54 | \item Kaufoption: siehe \ref{eq:ko} 55 | \end{itemize} 56 | 57 | 58 | 59 | \section{Klassische Theorien} 60 | 61 | \subsection{Ökonomie der Zinsen} 62 | \begin{itemize} 63 | \item Zentrale Bewertungsbeziehung für das Geldmarktkonto: \ref{eq:rf} 64 | \item \textbf{Erkenntnisse} 65 | \begin{itemize} 66 | \item Realzinsen sind hoch, wenn Investoren ungeduldig sind (niedriges \(\beta\)) oder wenn das Konsumwachstum hoch ist. Grafisch: Zinsen entsprechen der Steigung der Indifferenzkurve \(\rightarrow\) höheres Konsumverhalten \(\rightarrow\) höhere Steigung \(\rightarrow\) höhere Zinsen 67 | \item Realzinsen reagieren sensitiver bei hoher Risikoaversion (hohes \(\gamma\)) auf Änderungen des Konsumwachstums 68 | \item Konsumwachstum ist hoch, wenn die Zinsen hoch sind (bei hohen Zinsen wird mehr gespart) 69 | \item In unsicheren Zeiten wird mehr gespart \(\rightarrow\) niedrigere Zinsen ("`Precautionary Savings"') 70 | \end{itemize} 71 | \end{itemize} 72 | 73 | 74 | \subsection{Risikoanpassung} 75 | \begin{itemize} 76 | \item \textbf{Preis ergibt sich aus:} 77 | \begin{itemize} 78 | \item Diskontierung des erwarteten Payoffs mit dem risikolosen Zinssatz. Kovarianz wird \(0\), wenn eine der Komponenten sicher und damit \(0\) ist 79 | \begin{description} 80 | \item[Sicherheit:] \(x\) ist konstant 81 | \item[Risikoneutralität:] \(m\) ist konstant 82 | \end{description} 83 | \item Risikokorrektur über Kovarianzterm: Je stärker Kovarianz mit SDF, desto höher der Preis 84 | \end{itemize} 85 | \item Für Assets, die mehr zur Konsumglättung beitragen, werden höhere Preise bezahlt 86 | \item Preis wird nach oben korrigiert, falls Payoff in schlechten Zeiten hoch ist (Versicherungsidee) 87 | \item Wieso Kovarianz statt Varianz relevant? - Investor interessiert sich nicht für Volatilität eines einzelnen Papiers, sondern für den resultierenden Konsum 88 | \item Überrendite: Wertpapiere, deren Returns positiv mit Konsum variieren, führen zu volatilerem Konsum \(\rightarrow\) liefern höherere erwartete Returns (und umgekehrt) 89 | \item Beispiel Sicherheitsgedanke: "`Lieber im schlechten Fall mehr, als wenn ich ohnehin schon viel habe"' \(\rightarrow\) für Assets, die mehr zur Konsumglättung beitragen, werden höhere Preise bezahlt 90 | \end{itemize} 91 | 92 | 93 | \subsection{Unsystematisches Risiko} 94 | \begin{itemize} 95 | \item Mit SDF unkorrelierte Zahlungen (\(Cov(m,x)=0\)) erfordern keine Risikokorrektur im Preis \(\rightarrow\) unsystematisches Risiko wird nicht vergütet 96 | \item Erwartete Rendite entspricht der risikolosen Rendite 97 | \end{itemize} 98 | 99 | 100 | \subsection{Beta als Risikomaß} 101 | \begin{itemize} 102 | \item \(\beta_i\): Sensitivität der Rendite von Wertpapier \(i\) gegenüber der Marktrendite (siehe \ref{eq:beta}) 103 | \item Klassisches (systematisches) Risikomaß der Finanzwertschaft, typischerweise anhand des CAPM bestimmt 104 | \end{itemize} 105 | 106 | 107 | \subsection{Der \(\mu\)-\(\sigma\)-Rand} 108 | \begin{itemize} 109 | \item Alle erreichbaren Kombinationen liegen zwingend in kegelförmigen Bereich 110 | \item \textbf{Investments auf dem \(\mu\)-\(\sigma\)-Rand} 111 | \begin{description} 112 | \item[Oberer Rand:] Alle Investments, die perfekt negativ mit dem SDF korrelieren \(\rightarrow\) maximal riskant; höchste Rendite; maximale Konsumschwankung; maximale Sharpe-Ratio 113 | \item[Unterer Rand:] Bestmögliche Versicherung gegen Konsumschwankungen; perfekt positiv mit dem SDF korreliert \(\rightarrow\) zahlt Wert des SDF 114 | \end{description} 115 | \item Erwartete Rendite besteht aus \textit{risikoloser Rendite} \(R^f\) und \textit{Risikoprämie} \(\beta_{i,mv}\lambda\) 116 | \end{itemize} 117 | 118 | 119 | \subsection{Equity Premium Puzzle} 120 | \begin{itemize} 121 | \item Übermäßig hoher Unterschied zwischen den Renditen von Wertpapieren mit hohen Risiken im Vergleich zu niedrigen 122 | \item Tatsächliche Unterschiede deutlich größer als durch theoretische Modelle vorausgesagt 123 | \item Verschiedene Erklärungsversuche: Aktienrenditen purer Zufall?; Investoren risikoaverser als angenommen?; Teile der Modelle falsch? 124 | \item Letzterer Gegenstand aktueller Forschung 125 | \end{itemize} 126 | 127 | 128 | 129 | \section{Contingent Claims} 130 | 131 | \subsubsection{Wann sind Märkte vollständig?} 132 | \begin{itemize} 133 | \item Anzahl zukünftiger Umweltzustände sind gleich der Dimension des Vektorraums 134 | \item Auszahlungsvektoren in den Umweltzuständen sind linear unabhängig 135 | \end{itemize} 136 | 137 | \subsubsection{Berechnen von Arrow-Debreu-Preisen} 138 | \begin{enumerate} 139 | \item Aufteilung des Papiers in zwei Papiere, die jeweils in genau einem Zustand \(S\) eine Einheit auszahlen 140 | \item Berechnen von \(\Delta\) und \(k\) (siehe \ref{eq:adp1} und \ref{eq:adp2}) 141 | \item Arbitrage-Tableau für \(S_u = \begin{pmatrix} 1 \\ 0 \end{pmatrix}\): Verkauf von \(\Delta\) Einheiten \(WP_1\); Kauf entsprechender Anzahl Bonds; Preis des Arrow-Debreu-Papiers aus dieser Differenz berechenbar 142 | \item Arbitrage-Tableau für \(S_d = \begin{pmatrix} 0 \\ 1 \end{pmatrix}\): Kauf von \(\Delta\) Einheiten \(WP_2\); Verkauf entsprechender Anzahl Bonds; Preis des Arrow-Debreu-Papiers aus dieser Differenz berechenbar 143 | \item Berechnung von \(m_u\) und \(m_d\) (siehe \ref{eq:adpm}) 144 | \end{enumerate} 145 | 146 | 147 | \subsection{Diskontfaktor im vollständigen Markt} 148 | \begin{itemize} 149 | \item Heutiger Preis \(p\) setzt sich aus Wert der einzelnen Contingent Claims zusammen 150 | \end{itemize} 151 | 152 | 153 | \subsection{Risikoneutrale Wahrscheinlichkeiten} 154 | \begin{itemize} 155 | \item Der Wert eines Derivats in der realen Welt, in der Anwender sich nicht risikoneutral verhalten, muss identisch sein zum Wert des gleichen Derivats in einer hypothetischen, risikoneutralen Welt\footnote{\url{https://de.wikipedia.org/wiki/Risikoneutrale_Bewertung}} \(\rightarrow\) Bewertung erfolgt als wären Akteure risikoneutral 156 | \item Zukünftige Zahlungen müssen nur noch mit risikolosem Zinssatz diskontiert werden (siehe \ref{eq:prn}) 157 | \item Zustände mit überdurchschnittlich hohem Grenznutzen werden stärker gewichtet 158 | \item Bei Risikoaversion werden "`schlechte"' Zustände stärker gewichtet 159 | \item Anwendung Derivatebewertung: Unterstelle Verteilung für Underlying und bestimme im aktuellen Underlying-Preis implizite risikoneutrale Wahrscheinlichkeiten 160 | \item Interpretation im gesamtökonomischen Kontext: Bei \(\pi^*_i < \pi_i\) handelt es sich um einen ökonomisch guten Zustand, da die risikoneutrale Eintrittswahrscheinlichkeit nach unten korrigiert ist 161 | \end{itemize} 162 | 163 | 164 | 165 | \section{Faktormodelle} 166 | 167 | \subsection{Grundidee der Faktormodelle} 168 | \begin{itemize} 169 | \item Ersetze konsumbasierten Ausdruck für Grenznutzen durch lineares Faktormodell (siehe \ref{eq:lfm}) 170 | \item \textbf{Zentrale Frage: Wie soll \(f_{t+1}\) gewählt werden?} 171 | \begin{itemize} 172 | \item Faktoren sollen gute/schlechte Zustände der Ökonomie anzeigen bzw. eine gute Näherung mit dem Konsumwachstum liefern (siehe \ref{eq:lff}) 173 | \item Prognosegehalt 174 | \item Veränderungen und keine Levels 175 | \item Gute Datenverfügbarkeit 176 | \end{itemize} 177 | \item Unternehmensspezifische Charakteristika können \textit{nie} als Faktor verwendet werden, da sonst durch die Differenz von gebündelten Papieren und einzelnen Papieren des Unternehmens ein Arbitrage-Gewinn möglich wäre 178 | \item \textbf{Grundsätzliches Vorgehen zur Berechnung der erwarteten Rendite} 179 | \begin{itemize} 180 | \item Berechnung der Risikoexposition mittels Zeitreihendaten 181 | \item Berechnung der Risikoprämien durch Querschnittsregression 182 | \end{itemize} 183 | \end{itemize} 184 | 185 | 186 | \subsection{Capital Asset Pricing Modell} 187 | \begin{itemize} 188 | \item Berühmtes, weit verbreitetes Gleichgewichtsmodell 189 | \item Diskontfaktor wird an Return des Marktportfolios geknüpft (siehe) 190 | \end{itemize} 191 | 192 | 193 | \subsection{Arbitragepreistheorie} 194 | \begin{itemize} 195 | \item Aus dem CAPM entwickelt, fordert allerdings kein Marktgleichgewicht sondern lediglich Arbitragefreiheit 196 | \item Besteht aus Faktoren, denen jeweils Risikoprämien zugeordnet werden (siehe \ref{eq:apt}) 197 | \item Betrachtet idosynkratisches Risiko als nicht bewertungsrelevant 198 | \end{itemize} 199 | 200 | \subsection{Fama-French-Dreifaktorenmodell} 201 | \begin{itemize} 202 | \item Erweitert CAPM um zwei weitere Faktoren, um die Rendite eines Papiers mit der Marktrendite zu erklären 203 | \item Long und Short in ähnlichen Firmen \(\rightarrow\) keine Risikoexposition gegenüber Markt \(\rightarrow\) reine \(\alpha\)-Strategie (möglichst niedrig zu wählen) 204 | \item \textbf{\textit{high (Buch-Marktwert-Verhältnis) minus low} (HML)} 205 | \begin{itemize} 206 | \item Renditedifferenz zwischen Value- und Growthaktien 207 | \item Renditedifferenz zwischen Aktien mit hohem und niedrigem \textit{Buchwert-zu-Marktwert-Verhältnis} 208 | \item Interpretation 209 | \begin{description} 210 | \item[Hoch:] Asset-lastige Industrie 211 | \item[Niedrig:] Hohes Wachstumspotential 212 | \end{description} 213 | \end{itemize} 214 | \item \textbf{\textit{small (Marktkapitalisierung) minus big} (SMB)} 215 | \begin{itemize} 216 | \item Renditedifferenz zwischen kleinen und großen Aktien 217 | \item Renditedifferenz von Aktien mit geringem und hohem Marktwert des Eigenkapitals 218 | \item Interpretation 219 | \begin{description} 220 | \item[Hoch:] Junge Unternehmen; Nischenmarkt 221 | \item[Niedrig:] 222 | \end{description} 223 | \end{itemize} 224 | \end{itemize} 225 | \newpage 226 | 227 | 228 | \section{Appendix A: Formelsammlung} 229 | 230 | \subsection{Grundlagen} 231 | 232 | \subsubsection{Erwartete Rendite} 233 | \begin{equation} 234 | \mathbb{E} \big\lbrack R \big\rbrack = \frac{\mathbb{E} \big\lbrack x \big\rbrack}{p} = \frac{\mathbb{E} \big\lbrack x \big\rbrack}{\mathbb{E} \big\lbrack mx \big\rbrack} 235 | \end{equation} 236 | 237 | \subsubsection{Varianz} 238 | \begin{equation} 239 | Var(m) = \pi_u \Big(m_u - \mathbb{E} \big\lbrack m_u \big\rbrack\Big)^2 + \pi_d \Big(m_d - \mathbb{E} \big\lbrack m_d \big\rbrack\Big)^2 = \mathbb{E} \big\lbrack x^2 \big\rbrack - \Big( \mathbb{E} \big\lbrack x \big\rbrack \Big)^2 240 | \end{equation} 241 | 242 | \subsubsection{Kovarianz} 243 | \begin{equation} 244 | Cov\big(m,x\big) = \mathbb{E} \big\lbrack m x \big\rbrack - \mathbb{E} \big\lbrack m \big\rbrack \cdot \mathbb{E} \big\lbrack x \big\rbrack 245 | \end{equation} 246 | 247 | \subsubsection{Standardabweichung \(\sigma\)} 248 | \begin{equation} 249 | \sigma = \sqrt{Var} 250 | \end{equation} 251 | 252 | \subsubsection{Korrelation} 253 | \begin{equation} 254 | \rho_{x,y} = \frac{Cov(x,y)}{\sqrt{Var(x) \cdot Var(y)}} = \frac{Cov(x,y)}{\sigma_x \cdot \sigma_y} 255 | \end{equation} 256 | 257 | \subsubsection{Ökonomie charakterisieren} 258 | \begin{equation} 259 | \frac{\mathbb{E} \big\lbrack x \big\rbrack}{R^f} < p \Rightarrow oberer~Zustant~der~bessere 260 | \end{equation} 261 | \begin{equation} 262 | \frac{\mathbb{E} \big\lbrack x \big\rbrack}{R^f} > p \Rightarrow unterer~Zustant~der~bessere 263 | \end{equation} 264 | 265 | 266 | \subsection{Stochastischer Diskontfaktor (Grenzrate der Substitution)} 267 | \begin{equation} 268 | m_{t_1,t_2} = \beta^{t_2 - t_1} \cdot \frac{u^\prime(c_{t_2})}{u^\prime(c_{t_1})} = \beta^{t_2 - t_1} \cdot \bigg(\frac{c_{t_2}}{c_{t_1}}\bigg)^{-\gamma} \label{eq:m} 269 | \end{equation} 270 | 271 | \subsubsection{Preis} 272 | \begin{equation} 273 | p = \sum^n_1 \mathbb{E} \big\lbrack m_{0,i} x_i \big\rbrack = \mathbb{E} \big\lbrack m \big\rbrack \cdot \mathbb{E} \big\lbrack x \big\rbrack + Cov\big(m,x\big) = \frac{\mathbb{E} \big\lbrack x \big\rbrack}{R^f} + Cov\big(m,x\big) \label{eq:p} 274 | \end{equation} 275 | \paragraph{Für \(n=1\)} 276 | \begin{equation} 277 | p = \sum^1_1 \mathbb{E} \big\lbrack m x \big\rbrack = \pi_u \cdot m_u \cdot x_u + \pi_d \cdot m_d \cdot x_d 278 | \end{equation} 279 | 280 | \subsubsection{Aktieninvestment} 281 | \begin{equation} 282 | p_t = \mathbb{E} \big\lbrack m \cdot (p_{t+1} + d_{t+1}) \big\rbrack \label{eq:paktie} 283 | \end{equation} 284 | 285 | \subsubsection{Brutto-Return} 286 | \begin{equation} 287 | 1 = \mathbb{E} \big\lbrack m \cdot R \big\rbrack \Leftrightarrow R = \frac{\mathbb{E} \big\lbrack x \big\rbrack}{p} \label{eq:br} 288 | \end{equation} 289 | 290 | \subsubsection{Effektiver Zinssatz (Bruttorendite, in Zuständen in denen das Papier auszahlt} 291 | \begin{equation} 292 | R^{eff} = \frac{\mathbb{E} \big\lbrack x \big\rbrack}{p} 293 | \end{equation} 294 | 295 | \subsubsection{Überschuss-Return} 296 | \begin{equation} 297 | 0 = \mathbb{E} \big\lbrack m \cdot (R_a - R_b) \big\rbrack \label{eq:uer} 298 | \end{equation} 299 | 300 | \subsubsection{Einperiodige Anleihe} 301 | \begin{equation} 302 | p_t = \mathbb{E} \big\lbrack m \big\rbrack \label{eq:an} 303 | \end{equation} 304 | 305 | \subsubsection{Geldmarktkonto} 306 | \begin{equation} 307 | 1 = \mathbb{E} \big\lbrack m \cdot R^f \big\rbrack \label{eq:gmk} 308 | \end{equation} 309 | 310 | \subsubsection{Kaufoption} 311 | \begin{equation} 312 | p_t = \mathbb{E} \big\lbrack m \cdot (max(S-K,0)) \big\rbrack \label{eq:ko} 313 | \end{equation} 314 | 315 | \subsubsection{Risikoloser Zinssatz} 316 | \begin{equation} 317 | \mathbb{E} \big\lbrack m \big\rbrack = \pi_u \cdot m_u + \pi_d \cdot m_d = \frac{1}{R^f} \label{eq:E} 318 | \end{equation} 319 | \begin{equation} 320 | R^f_{t_1, t_2} = \frac{1}{\mathbb{E} \big\lbrack m_{t_1,t_2} \big\rbrack} = \frac{1}{\beta^{t_2-t_1}} \cdot \mathbb{E} \Bigg\lbrack \frac{u^\prime(c_{t_2})}{u^\prime(c_{t_1})} \Bigg\rbrack^{-1} = \frac{1}{\beta^{t_2-t_1}} \cdot \mathbb{E} \Bigg\lbrack \bigg( \frac{c_{t_2}}{c_{t_1}} \bigg)^{-\gamma} \Bigg\rbrack^{-1} \label{eq:rf} 321 | \end{equation} 322 | 323 | 324 | \subsection{Beta als Risikomaß} 325 | 326 | \subsubsection{Risikomenge} 327 | \begin{equation} 328 | \beta_{i,m} = \frac{Cov(m,R_i)}{Var(m)}\label{eq:beta} 329 | \end{equation} 330 | 331 | \subsubsection{Preis des Risikos} 332 | \begin{equation} 333 | \lambda_m = - \frac{Var(m)}{\mathbb{E} \big\lbrack m \big\rbrack} 334 | \end{equation} 335 | 336 | 337 | \subsection{Equity Premium Puzzle} 338 | 339 | \subsubsection{Sharpe-Ratio} 340 | \begin{equation} 341 | SR = \frac{\mathbb{E} \big\lbrack R^i \big\rbrack - R^f}{\sigma \big\lbrack R^i \big\rbrack} 342 | \end{equation} 343 | 344 | \subsubsection{Maximale Sharpe-Ratio (Steigung des oberen \(\mu\)-\(\sigma\)-Rands)} 345 | \begin{equation} 346 | SR_{max} = \frac{\sqrt{Var \big( m \big)}}{\mathbb{E} \big\lbrack m \big\rbrack} 347 | \end{equation} 348 | 349 | 350 | \subsection{Contingent Claims} 351 | 352 | \subsubsection{Arrow-Debreu-Preise} 353 | \begin{equation} 354 | \Delta S_u + k \cdot 1 = 1 \label{eq:adp1} 355 | \end{equation} 356 | \begin{equation} 357 | \Delta S_d + k \cdot 1 = 0 \label{eq:adp2} 358 | \end{equation} 359 | \begin{equation} 360 | m(s) = \frac{pc(s)}{\pi(s)} \label{eq:adpm} 361 | \end{equation} 362 | \paragraph{Risikoloser Zinssatz} 363 | \begin{equation} 364 | R^f = \frac{1}{\mathbb{E} \big\lbrack m \big\rbrack} = \frac{1}{pc(s_1) + \dots + pc(s_n)} = \frac{1}{\sum_s pc(s_i)} 365 | \end{equation} 366 | \paragraph{Heutiger Preis als Summe der Contingent Claims} 367 | \begin{equation} 368 | p(s) = \sum pc(s)\cdot x(s) 369 | \end{equation} 370 | 371 | \subsubsection{Risikoneutrale Wahrscheinlichkeiten} 372 | \begin{equation} 373 | \pi^*_u = \frac{m_u}{\mathbb{E} \big\lbrack m \big\rbrack} \cdot \pi_u = \frac{m_u}{m_u \cdot \pi_u + m_d + \pi_u} \cdot \pi_u 374 | \end{equation} 375 | \begin{equation} 376 | \pi^*_d = 1 - \pi^*_u 377 | \end{equation} 378 | \begin{equation} 379 | p^* = \frac{\mathbb{E}^* \big\lbrack x \big\rbrack}{R^f} = \frac{\pi^*_u \cdot x_u + \pi^*_d \cdot x_d}{R^f} \label{eq:prn} 380 | \end{equation} 381 | 382 | \subsubsection{Berechnung von Calls und Puts} 383 | \paragraph{Call (\(S_d\) wird Null)} 384 | \begin{equation} 385 | C_t = \frac{\pi^*_u \cdot \big( S_{u,t+1} - Ausuebungspreis \big)}{R^f} 386 | \end{equation} 387 | \paragraph{Call (\(S_u\) wird Null)} 388 | \begin{equation} 389 | P_t = \frac{\pi^*_d \cdot \big( Ausuebungspreis - S_{d,t+1} \big)}{R^f} 390 | \end{equation} 391 | 392 | 393 | \subsection{Faktormodelle} 394 | 395 | \subsubsection{Lineares Faktormodell} 396 | \begin{equation} 397 | m_{t+1} = a + b^\prime f_{t+1} \label{eq:lfm} 398 | \end{equation} 399 | \begin{equation} 400 | \beta \cdot \frac{u^\prime(c_{t+1})}{u^\prime(c_t)} \approx a + b^\prime f_{t+1} \label{eq:lff} 401 | \end{equation} 402 | 403 | \subsubsection{Capital Asset Pricing Modell} 404 | \begin{equation} 405 | \mathbb{E} \big\lbrack R^i \big\rbrack = R^f + \beta_{i,R^M} \cdot \big( \mathbb{E} \big\lbrack R^M \big\rbrack - R^f \big) \label{eq:capm} 406 | \end{equation} 407 | \paragraph{Diskontfaktor} 408 | \begin{equation} 409 | m_{t+1} = a + b \cdot R^M_{t+1} 410 | \end{equation} 411 | \paragraph{Risikoloses Instrument} 412 | \begin{equation} 413 | 1 = \mathbb{E} \big\lbrack m \cdot R^f \big\rbrack 414 | \end{equation} 415 | \paragraph{Return des Marktportfolios} 416 | \begin{equation} 417 | 1 = \mathbb{E} \big\lbrack m \cdot R^M \big\rbrack 418 | \end{equation} 419 | 420 | \subsubsection{Abritragepreistheorie} 421 | \begin{equation} 422 | \mathbb{E} \big\lbrack r \big\rbrack = R^f + \beta_1 \cdot \lambda_1 \dots \beta_n \cdot \lambda_n \label{eq:apt} 423 | \end{equation} 424 | 425 | \subsubsection{Fama-French-Dreifaktorenmodell} 426 | 427 | \(\lambda_M\), \(\lambda_{SMB}\) und \(\lambda_{HML}\) bezeichnen individuelle Marktrisiokoprämien. 428 | \begin{equation} 429 | r = R^f + \beta_M \cdot \lambda_M + \beta_{SMB} \cdot \lambda_{SMB} + \beta_{HML} \cdot \lambda_{HML} \label{eq:ff} 430 | \end{equation} 431 | 432 | \subsubsection{Berechnen der Marktrisikoprämien} 433 | \begin{equation} 434 | \lambda_M = \mathbb{E} \big\lbrack R^M - R^f \big\rbrack = (Ueberrendite~des~Marktes) \cdot (Handelstage~pro~Jahr) 435 | \end{equation} 436 | 437 | \begin{equation} 438 | \lambda_{SMB} = \mathbb{E} \big\lbrack R^S - R^B \big\rbrack = (Durchschnittswerte) \cdot (Handelstage~pro~Jahr) 439 | \end{equation} 440 | 441 | \begin{equation} 442 | \lambda_{HML} = \mathbb{E} \big\lbrack R^H - R^L \big\rbrack = (Durchschnittswerte) \cdot (Handelstage~pro~Jahr) 443 | \end{equation} 444 | -------------------------------------------------------------------------------- /vs.tex: -------------------------------------------------------------------------------- 1 | \chapter{Virtuelle Systeme} 2 | 3 | Zusammenfassung der Vorlesung "`Virtuelle Systeme"' aus dem Wintersemester 2016.\footnote{\url{https://os.itec.kit.edu/deutsch/3257_3261.php}} 4 | 5 | \section{Einführung} 6 | \begin{itemize} 7 | \item "`Computer sind komplex"': Vereinfachung durch Abstraktionsebenen and wohldefinierten Schnittstellen 8 | \item Abstraktion: Versteckt Implementierungsdetails niedrigerer Ebenen und stellt vereinfachte Schnittstellen zu Ressourcen zur Verfügung \(\rightarrow\) vereinfacht das Design auf höheren Ebenen. Beispiel: Dateien als Abstraktion einer Festplatte mit einfacher, allgemeiner Schnittstelle (\texttt{open, read, write}) 9 | \item \textbf{Schnittstellen} 10 | \begin{itemize} 11 | \item Instruction Set Architectur (ISA): Betriebssystemunabhängige Schnittstelle für den Hardwarezugriff; beispielsweise \texttt{IA-32} 12 | \item Application Binary Interface (ABI): Interface für den Hardwarezugriff, das vom Betriebssystem zur Verfügung gestellt wird; beispielsweise \texttt{SYSCALL} 13 | \item Nachteile: Eventuell schlechte Portabilität, da höhere Ebenen von entsprechenden Schnittstellen abhängig sind; beispielsweise ist Software an bestimmte ISAs und Betriebssysteme gebunden 14 | \end{itemize} 15 | \item Generelles Problem: Software an bestimmte \texttt{ISA} und Betriebssystem gebunden; Betriebssystem an bestimmte Hardwaretypen und Systemschnittstellen gebunden \(\rightarrow\) Reduzierung der Interoperabilität 16 | \end{itemize} 17 | 18 | 19 | \subsection{Virtualisierung} 20 | \begin{itemize} 21 | \item Abstrakt: Isomorphismus zwischen Gast und Host (Gastoperationen werden auf enstprechende Hostoperationen abgebildet) 22 | \item \textbf{Aufgaben der Virtualisierung} 23 | \begin{itemize} 24 | \item Zuordnung von virtuellen zu realen Ressourcen 25 | \item Verwendung von realen Maschinenbefehlen oder \texttt{SYSCALL} um die Anweisungen des Gastsystem auszuführens 26 | \end{itemize} 27 | \item \textbf{Process Virtual Machines} 28 | \begin{itemize} 29 | \item Simuliert ein Programm/Prozess: Führt Anwendungen für die selbe oder eine andere \texttt{API}, \texttt{ABI} oder \texttt{ISA} aus \(\rightarrow\) abstrahiert \texttt{API}, \texttt{ABI} oder \texttt{ISA} 30 | \item Interaktion mit dem Host-Betriebssystem zur Laufzeit via \texttt{SYSCALL} 31 | \item Runtime zur Verwaltung der Gastprozesse \(\rightarrow\) Gastprozesse existieren parallel zu den Hostprozessen 32 | \item OS Compatibility Layer (emuliert \texttt{ABI} und \texttt{API}) 33 | \begin{itemize} 34 | \item Virtualisiert Software: Bibliothek um von Gast-\texttt{API} nach Host-\texttt{API} übersetzen zu können 35 | \item Beispiel: \texttt{Wine} 36 | \end{itemize} 37 | \item Binary Translation (emuliert \texttt{ISA} und \texttt{ABI}) 38 | \begin{itemize} 39 | \item Selbes Betriebssystem, verschiedene \texttt{ISAs}: Einführung einer Zwischenschicht zur Übersetzung der \texttt{ABI}-Befehle 40 | \item Beispiel \texttt{Digital FX!32}: Erlaubt das Ausführen von Windows-Anwendungen, die für \texttt{x86} kompiliert worden sind, auf \texttt{Alpha}-Prozessoren 41 | \item Binary Optimization: Optimierung zur Laufzeit innerhalb der selben Umgebung (beispielsweise \texttt{HP Dynamo}) 42 | \end{itemize} 43 | \item High-level Language Runtime (emuliert \texttt{ISA}, \texttt{ABI} und \texttt{API}) 44 | \begin{itemize} 45 | \item Stellt eine komplette virtuelle Umgebung zur Verfügung 46 | \item Spezifizierung eines high-level Interfaces. Das Betriebssystem wird als Standard-Bibliothek abstrahiert (beispielsweise \texttt{JVM}) 47 | \end{itemize} 48 | \end{itemize} 49 | \item \textbf{System Virtual Machines} 50 | \begin{itemize} 51 | \item Abstrahiert die \textbf{ISA} des Hosts als separate, virtuelle Maschinen \(\rightarrow\) simuliert kompletten PC 52 | \item Interaktion über den \textit{Virtual Machine Monitor} (VMM) 53 | \item Typen 54 | \begin{itemize} 55 | \item Native System VM: VMM im privilegierten Modus; Gast im Benutzermodus; beispielsweise \texttt{Xen} oder \texttt{Hyper-V} 56 | \item Hosted System VM: VMM und Gast im Benutzermodus; beispielsweise \texttt{VirtualBox} oder \texttt{QEMU} 57 | \item Dual-Mode System VM: VMM teilweise im privilegierten Modus; beispielsweise \texttt{QEMU} mit \texttt{KVM} 58 | \end{itemize} 59 | \item Vorteile System VM 60 | \begin{itemize} 61 | \item Erhöhte Kompatibilität 62 | \item Höhere Effizienz, da mehrere virtuelle Maschinen auf einer physikalischen laufen können 63 | \item Zuverlässigkeit und Verfügbarkeit wird durch Replikations- und Migrationsmöglichkeiten erhöht 64 | \item Sicherheit durch Isolierung zwischen den Gästen 65 | \item Möglichkeiten zur System-Analyse auf \texttt{ISA}-Ebene (Debugging, Malware-Analyse, Forschung) 66 | \end{itemize} 67 | \end{itemize} 68 | \end{itemize} 69 | 70 | 71 | 72 | \section{Emulation} 73 | \begin{itemize} 74 | \item Ziel: Implementieren von Interface/Funktionalität eines Systems auf einem anderen System 75 | \item \textbf{Interpretation vs. Binary Translation} 76 | \begin{itemize} 77 | \item Interpretation 78 | \begin{itemize} 79 | \item Quellinstruktion wird analysiert, in Zielinstruktion überführt und ausgeführt 80 | \item Einfach zu implementieren; allerdings mit hohen Ausführungskosten verbunden 81 | \end{itemize} 82 | \item Binary Translation 83 | \begin{itemize} 84 | \item Betrachtet immer einen ganzen Instruktionsblock, übersetzt diesen und speichert ihn zwischen 85 | \item Komplexer; beim Start höhere Ausführungskosten; allerdings geringe Ausführungskosten 86 | \end{itemize} 87 | \end{itemize} 88 | \item \textbf{Aufbau einer Process VM} 89 | \begin{itemize} 90 | \item Emulation Engine: Emuliert die Instruktionen (wahlweise mittels Interpretation oder Binary Translation; verantwortlich für die Auswahl der Emulationstechnik) 91 | \item Profile Database: Sammelt dynamisch Informationen zum laufenden Programm \(\rightarrow\) bildet Basis für Emulationstechnikentscheidungen und Optimierung im Translater 92 | \item Code Cache: Verwaltet die zwischengespeicherten, bereits übersetzten Code-Fragmente. \textit{Code Cache Manager} entscheidet, ob Fragmente im Cache abgelegt werden 93 | \item Interpreter: Für virtuelle Quell-CPU und die Speicherverwaltung verantwortlich 94 | \end{itemize} 95 | \item \textbf{Techniken} 96 | \begin{itemize} 97 | \item Interpretation 98 | \begin{itemize} 99 | \item Decode-Dispatch-Interpretation: Interpreter betrachter das Quell-Programm schrittweise in einer zentralen Schleife; dekodiert die Instruktionen und ruft die Dispatch-Routine auf. Diese liest/modifiziert den Gast-Zustand 100 | \item Optimierungsmöglichkeiten des Interpreters: Ausführen einer einzigen Quellinstruktion benötigt ein Vielfaches "`multiple tens"' an Instruktionen auf dem Host \(\rightarrow\) extrem ineffizient 101 | \begin{enumerate} % TODO 102 | \item Threaded Interpretation: Ersetzt die Hauptschleife. Kopiere Dekoderlogik ans Ende von jeder Dispatch-Routine; verwende Sprungtabellen statt switch-case-Statements \(\rightarrow\) vermeidet teure Branches 103 | \item Predecoding: Aufbereitung der Quellinstruktionen (Opcode, Operanden, etc.) für einfachere Zugriffe auf die Instruktionen zur Laufzeit \(\rightarrow\) vereinfacht die Dekodierroutine 104 | \item Direct Threaded Interpretation (Kombination aus Erstgenannten): Speichere Adresse der Dispatch-Routine statt Opcode \(\rightarrow\) benötigt keine Sprungroutine und vermeidet Indirektionen 105 | \end{enumerate} 106 | \end{itemize} 107 | \item Dynamic Binary Translation (BDT) 108 | \begin{itemize} 109 | \item Benötigt keine Dispatch-Routinen; erlaubt Optimierungen der Ziel-Instruktionen 110 | \item Quellinstruktionen werden direkt in Zielinstruktionen umgewandelt 111 | \item Probleme bei Binary Translation 112 | \begin{itemize} 113 | \item Code Discovery Problem: Finden des Einsprungpunkts bei Quell-Instruktionen ggf. schwierig (Instruktionen und Opcodes unterschiedlich lange; u.U. Daten in \textit{Instruction Stream} eingebettet; Padding; indirekte Sprünge \(\rightarrow\) Sprungziel erst zur Laufzeit bekannt) 114 | \item Code Location Problem: Fehlerhafte SIP-TIP-Beziehung (Source/Target Instruction Pointer). Kann beispielsweise entstehen, wenn eine Quell-Instruktion auf mehrere Zielinstruktionen abgebildet wird 115 | \end{itemize} 116 | \item Lösung: Dynamic Translation 117 | \begin{itemize} 118 | \item Zunächst Interpretation mit Code Discovery 119 | \item Der Code wird schrittweise übersetzt und blockweise im Code-Cache gespeichert. Zusätzlich wird das IP-Mapping im \textit{SIP-To-TIP}-Cache gespeichert 120 | \item Problem dabei: Wie wird der Folgeblock identifiziert? \(\rightarrow\) speichere zusätzlich den SIP zur Folgeinstruktion. Dieser kann im SIP-to-TIP-Cache nachgeschlagen werden 121 | \item Optimierung: \textit{Translation Block Chaining} 122 | \begin{itemize} 123 | \item Vermeidet Rücksprünge zum Emulation Manager; der nächste Block wird direkt im Block davor gespeichert. Bei Sprüngen werden verschiedene mögliche Ziele gespeichert 124 | \item Unconditional Jump: Direkter Sprung zum nächsten Block 125 | \item Conditional Jump: Jeder Folgeblock wird separat gelinkt 126 | \item Indirect Jump: Immer zurück zum Emulation Manager 127 | \end{itemize} 128 | \end{itemize} 129 | \end{itemize} 130 | \end{itemize} 131 | \item \textbf{Code-Cache-Management} 132 | \begin{itemize} 133 | \item Herausforderungen: Variabel lange Blöcke; Abhängigkeiten zwischen Blöcken; Blöcke müssen bei Verdrängung aus dem Cache neu generiert werden \(\rightarrow\) unterscheiden sich von typischen Hardware-Caches wie CPU-Caches oder TLBs 134 | \item Ersetzungsstrategien 135 | \begin{itemize} 136 | \item Least Recently Used (LRU): Probleme durch Verwaltungsoverhead (Nutzungsverhalten der Blöcke); bei Verdrängung Aktualisierung der Verknüpfungen mit anderen Blöcken notwendig (Speicherung von Back-Pointern); variabel große Blöcke führen zu Cache-Fragmentierung 137 | \item Flush When Full (FwF) 138 | \begin{itemize} 139 | \item Vorteile: Einfach; Berücksichtigt Dependencies und Fragmentierung 140 | \item Nachteil: Regenerierung der gelöschten Blöcke teuer 141 | \item Defaulteinstellung bei \texttt{QEMU} mit 16 MB Cache 142 | \end{itemize} 143 | \item Preemptive Flush 144 | \begin{itemize} 145 | \item Viele Programme weisen Phasenverhalten auf (Initialisierung, schrittweise Berechnungen, etc.) \(\rightarrow\) Instruction Working Set wechselt 146 | \item Idee: Flush, wenn Phasenwechsel erkannt (anhand Burst neuer Instruktionen) 147 | \end{itemize} 148 | \item First In First Out (FIFO) 149 | \begin{itemize} 150 | \item Der/die älteste(n) Blöcke werden entfernt 151 | \item Vorteile: Berücksichtigt zeitliche Lokalität; kein Verwaltungsoverhead zum Nutzungsverhalten der Blöcke (siehe LRU) 152 | \item Nachteil: Back-Pointer notwendig 153 | \item Variante Coarse-Grained FIFO: Code-Cache wird partitioniert, es werden immer ganze Partitionen gelöscht; keine Verkettung zwischen Partitionen 154 | \end{itemize} 155 | \end{itemize} 156 | \end{itemize} 157 | \item \textbf{Gastarbeitsspeicherverwaltung} 158 | \begin{itemize} 159 | \item Gast erhält einen Teil des Adressbereichs des Hosts; zuverlässige Isolierung notwendig (Gast darf nicht auf den Speicher, den der Host für sich nutzt, zugreifen können) 160 | \item Runtime verwaltet Zuordnungstabelle 161 | \end{itemize} 162 | \item \textbf{Ausnahmebehandlung} 163 | \begin{itemize} 164 | \item Direkt: Interpreter erkennt Exceptions und springt zu einem \textit{Runtime Trap Handler} 165 | \item Indirekt: Host-ISA erkennt die Exception. Signal wird durch das Host-OS an den Runtime Handler weitergegeben (beispielsweise Division durch \texttt{0}) 166 | \end{itemize} 167 | \item \textbf{\texttt{SYSCALL}-Behandlung} 168 | \begin{itemize} 169 | \item Wrapper übersetzt Quell-System-Call zu Ziel-System-Call; eventuell muss zwischen Calling Conventions übersetzt werden 170 | \item Manche Calls können vom Gastsystem selbst behandelt werden (beispielsweise Signal Handler Registrierung, oder Speichermanagement) 171 | \end{itemize} 172 | \end{itemize} 173 | 174 | 175 | 176 | \section{System VMs} 177 | \begin{itemize} 178 | \item Ziel: Unterstützung mehrerer Gast-Betriebsssteme auf einem System 179 | \item Virtual Machine Monitor (VMM): "`Besitzer"' der Hardware-Ressourcen; läuft im privilegierten Modus (Gäste im Gastmodus); verwaltet Allokation/Zugriff auf die Ressourcen 180 | \item VMM wechselt zur Ausführung der Gäste zwischen diesen (vergleichbar mit Timesharing zwischen Anwendungen eines Betriebssystems). Gäste dürfen dazu weder selbst Timer-Interrupts setzen noch die echten Timer-Interrupt-Werte lesen (wird vom VMM emuliert), da der VMM den Host-Timer zum Wechseln zwischen VMs und dem Host verwendet wird (Probleme durch Manipulation: "`unfaire"' Verteilung von Rechenzeit, DoS-Angriffe) 181 | \item \textbf{State Management} 182 | \begin{itemize} 183 | \item Alle Gästen benötigen individuelle (exklusive oder versteckte) Hardware-Ressourcen wie beispielsweise Festplatten (können rein virtuell sein); alle nicht-exklusiven Ressourcen, die virtualisiert werden, müssen entsprechend verwaltet werden (Partitionierung oder Sharing) 184 | \item Wechsel zwischen den States mehrerer VMs 185 | \begin{itemize} 186 | \item Indirection: Zustand der Gäste wird im RAM des VMM vorgehalten; Pointer wechselt zwischen den Gästen. Beispielsweise gut geeignet für Page Directory; ungeeignet für Registersätze 187 | \item Copying: Zustand der Gäste wird jeweils aus dem RAM des VMM in den Register Block des Prozessors kopiert. Beispielsweise gut geeignet für Registersätze; ungeeignet für Page Directory 188 | \end{itemize} 189 | \end{itemize} 190 | \item \textbf{Virtualisierung von CPUs} 191 | \begin{itemize} 192 | \item Generelle Techniken 193 | \begin{itemize} 194 | \item Full Emulation: Immer möglich; ISA des Gasts muss nicht ISA des Hosts entsprechen; langsam 195 | \item Direct Native Execution: Nahezu native Ausführungsgeschwindigkeit; ISA des Gasts \textit{muss} der des Hosts entsprechen 196 | \end{itemize} 197 | \item Direct Native Execution 198 | \begin{itemize} 199 | \item \textit{Trap'n'emulate}: Gastinstruktionen werden direkt ausgeführt; "`Trap"' bei privilegierten Instruktionen, diese werden vom Dispatcher emuliert. Letzterer ruft die entsprechende \textit{Interpreterroutine} auf. Beispiele für pivilegierte Instruktionen: \texttt{IN}, \texttt{OUT}, \texttt{Write TLB} 200 | \item Aufgabenverteilung 201 | \begin{itemize} 202 | \item Dispatcher: Übergeordnete Komponente; entscheidet welche Komponente aufgerufen werden soll 203 | \item Allocator: Verwaltet Ressourcen, die sich die VMs teilen 204 | \item Interpreter Routines: Existiert pro privilegierter Instruktion; emuliert den Befehl auf virtuellen Ressourcen 205 | \end{itemize} 206 | \item Gastbetriebssystem: Da nur der VMM im Kernelmodus läuft "`fallen"' (trappen) alle privilegierten Instruktionen in den VMM Dispatcher 207 | \item Gastanwendungen: Da \texttt{SYSCALL} auf \texttt{x86}-Systemen keine privilegierte Instruktion ist muss der VMM diese speziell abfangen, damit sie korrekt emuliert werden kann 208 | \item Weitere wichtige Instruktionen: Instruction Types 209 | \begin{itemize} 210 | \item Definitionen 211 | \begin{itemize} 212 | \item Control sensitive instructions: Alle Instruktionen, welche die Ressourcenkonfiguration verändern. Beispiel: Page Directory Pointer (\texttt{CR3}) auf \texttt{x86} aktualisieren 213 | \item Behavior sensitive instructions: Alle Instruktionen, deren Verhalten/Ergebnis konfigurationsabhängig ist. Beispiel: Pop flags register (\texttt{POPF}) auf \texttt{x86} 214 | \item Privileged instructions: Alle Instruktionen, die trappen (müssen), wenn sie im User Mode ausgeführt werden. Beispiel: Load processor status word (\texttt{LPSW}) auf \texttt{System/370}. Vorsicht: Lehrstuhlspezifische Definition; schließt \texttt{SYSCALL} hier mit ein 215 | \item Innocuous instructions ("`harmlose"' Instruktionen): Weder control- noch behavior-sensitiv 216 | \end{itemize} 217 | \item \textit{Efficient Virtual Machines Theorem}: Alle sensitiven Instruktionen, die eine Teilmenge der privilegierten Instruktionen bilden, können effizient ausgeführt werden 218 | \item Critical Instructions 219 | \begin{itemize} 220 | \item Sensitiv aber nicht priviligiert. Bei \texttt{x86} gibt es beispielsweise 17 221 | \item Lösung: Kritische Instruktionen werden gepatcht. Dazu scannt der VMM den Code des Gasts vor der Ausführung und wandelt alle kritischen Instruktionen in Traps um 222 | \item Umsetzung mittels \textit{Dynamic-binary-translation}-Techniken: \textit{Instruction stream} wird in Blöcke aufgteilt und gepatcht. Am Ende des Blocks wird eine zusätzliche Trap eingefügt, damit der VMM die Kontrolle zurückerlangt 223 | \item Generelles Problem mit Traps: Sehr teuer 224 | \end{itemize} 225 | \end{itemize} 226 | \end{itemize} 227 | \end{itemize} 228 | \item \textbf{Virtualisierung von Arbeitsspeicher} 229 | \begin{itemize} 230 | \item Betriebssysteme gehen davon aus, die vollständige Kontrolle über den Speicher zu haben. Dies beinhaltet die Verwaltung und die Fähigkeit, jede virtuelle Page auf jeden physikalischen Frame abbilden zu können 231 | \item VMM muss allerdings die Kontrolle über den Speicher behalten, partitioniert den Adresseraum und übernimmt das Mapping [Page \(\rightarrow\) Frame]. TLBs verstärken das Problem, da diese bei einem Miss automatisch Frames nachschlagen 232 | \item Abstraktionsebenen 233 | \begin{itemize} 234 | \item Physikalischer Speicher des Hosts: "`Realer"' Arbeitsspeicher. Kann von VMM mehrfach vergeben werden 235 | \item Physikalischer Speicher des Gasts: Speicherabstraktion, die der Host dem Gast zur Verfügung stellt. Wird vom Gast als zusammenhängender, physikalischer Speicher wahrgenommen 236 | \item Virtueller Speicher des Gasts: Standard \(2^{32/64}\)-virtueller Adressraum 237 | \end{itemize} 238 | \item Page-Table-Typen 239 | \begin{itemize} 240 | \item Guest virtual page table: Einmal pro Gastprozess vorhanden; [Guest virtual \(\rightarrow\) Guest physical]; vom Gastsystem verwaltet; im RAM des Gasts gespeichert 241 | \item Guest physical page table: Einmal pro Gast vorhanden; [Guest physical \(\rightarrow\) Host physical]; vom VMM verwaltet; im RAM des Hosts gespeichert 242 | \item Shadow page table: Einmal pro Gastprozess; [Guest virtual \(\rightarrow\) Host physical]; vom VMM verwaltet; im RAM des VMM gespeichert. Problem dabei: VMM muss darauf achten, dass shadow page tables und guest physical page table konsistent bleiben. Dazu mappt der VMM OS page tables read-only in guest physical page tables 243 | \end{itemize} 244 | \item Speicherallokation 245 | \begin{itemize} 246 | \item Meist triviale Allokationsstrategien mit statischer Zuweisung ohne Swapping 247 | \item Mehrfachvergabe mit \textit{Balloon driver}: Nicht genutzter Speicher einer VM kann anderen VMs durch den VMM zur Verfügung gestellt werden 248 | \item Mehrfachvergabe mit Speicherdeduplitzierung: Gleiche Frames werden per \texttt{Copy-on-write} zusammengefasst 249 | \end{itemize} 250 | \end{itemize} 251 | \item \textbf{Virtualisierung von Input/Output} 252 | \begin{itemize} 253 | \item Schwierig zur virtualisieren, da viele verschiedenen Typen/Geräte mit unterschiedlichen Treibern vorhanden. Darüber hinaus müssen neue Geräte kompatibel sein 254 | \item Vorgehen: Erstellen einer virtuellen Version des Gerätes sowie Virtualisieren der I/O-Aktivität des Gerätes 255 | \item Gerätetypen 256 | \begin{itemize} 257 | \item Dedicated: Geräte müssen nicht virtualisiert werden, werden allerdings trotzdem vom VMM kontrolliert, da sie im privilegierten Modus laufen (beispielsweise Maus/Monitor/Tastertur) 258 | \item Partitioned: Es werden mehrere, kleinere, virtualisierte Versionen angelegt; VMM übersetzt zwischen virtualiserten und physikalischem Gerät (beispielsweise Festplatten) 259 | \item Shared: VMM verwaltet den virtuellen Status und übersetzt [virtuelle Anfrage \(\leftrightarrow\) physikalische Anfrage] (beispielsweise Netzwerkadapter) 260 | \item Spooled: Grobkörnig geshared (beispielsweise Drucker) 261 | \item Non-existent: Nur die virtuellen Versionen werden implementiert \(\rightarrow\) VMs auf dem selben Host können kommunizieren (beispielsweise dedizierte, virtuelle Netzwerkgeräte) 262 | \end{itemize} 263 | \item Reguläre Geräteanfragen 264 | \begin{enumerate} 265 | \item Betriebssystem verwaltet Geräteressourcen (Speicherallokation, serialisieren von Anfragen, etc.) 266 | \item Anwendungen führen Standard-I/O-Anfragen mit \texttt{SYSCALL} durch 267 | \item Betriebssystem konvertiert I/O-Anfragen zu Treiberanfragen 268 | \item Treiber erzeugt gerätespezifische I/O-Operationen 269 | \end{enumerate} 270 | \item \texttt{System-Call}-Level 271 | \begin{itemize} 272 | \item Gast trappt in VMM, dieser interpretiert den \texttt{SYSCALL} und erzeugt Treiberanfragen \(\rightarrow\) komplette I/O-Behandlung im VMM 273 | \item Problem: VMM muss alle I/O-\texttt{SYSCALL} aller VMs behandlen 274 | \end{itemize} 275 | \item Treiberschnittstelle (paravirtualisiert) 276 | \begin{itemize} 277 | \item Gast-Betriebssystem verfügt über Treiber-Stubs; generische I/O-Operationen werden an den VMM übergeben und von diesem in reale Treiberanfragen umgewandelt 278 | \item Probleme: VMM muss Zugang zu den realen Treibern sowie einen generischen Treiber für alle Gastbetriebssysteme haben 279 | \item Beispiel: \texttt{XEN} 280 | \end{itemize} 281 | \end{itemize} 282 | \end{itemize} 283 | -------------------------------------------------------------------------------- /algo2algorithmen.tex: -------------------------------------------------------------------------------- 1 | \section{Appendix A: Algorithmen und Erklärungen} 2 | 3 | Aufstellung und Erläuterung aller Algorithmen der Vorlesung Vorlesung "`Algorithmen II"' aus dem Wintersemester 2014.\footnote{\url{http://geom.ivd.kit.edu/ws14_algo2.php}} 4 | 5 | \subsection{Algorithmus von Ford und Fulkerson} 6 | \input{algo2/algo_ford-fulkerson} 7 | 8 | \subsubsection{Eingaben} 9 | \begin{itemize} 10 | \item Rationale Eingaben: Terminiert sicher für alle rationalen Eingaben 11 | \item Irrationale Kapazitäten: Muss nicht terminieren, da der Algorithmus unendliche lange laufen kann (und auch nicht gegen den maximalen Fluss konvergieren muss) oder ein falsches Ergebnis liefert\footnote{\url{http://www.cs.huji.ac.il/~nati/PAPERS/ALGORITHMS/zwick.pdf}} 12 | \end{itemize} 13 | 14 | \subsubsection{Korrektheit} 15 | \begin{itemize} 16 | \item Beweis von Ford und Fulkerson: Ein \(q-s\) - Fluss ist dann maximal, wenn es keinen augmentierenden (erhöhenden) Pfad gibt 17 | \item Während der Durchführung erhöht sich der Fluss in jedem Schritt 18 | \item Terminiert bei ganzzaligen Eingaben, da \(W_f\) immer um mindestens \(1\) erhöht wird und \(W_f \leq \sum k(q,V) < \infty\) 19 | \item Terminiert bei rationalen Eingaben, da der Fluss stets mindestens um \(\frac{1}{Hauptnenner}\) erhöht wird 20 | \end{itemize} 21 | 22 | \subsubsection{Laufzeit} 23 | \begin{itemize} 24 | \item Pro Schleifendurchlauf benötigt der Algorithmus \(\mathcal{O}(|V|+|E|)\) Zeit 25 | \item Insgesamt: \(\mathcal{O}(|E| \cdot max\{W_f~|~Fluss~in~F\})\), denn ein Pfad \(q \rightarrow^* s\) in \(|E|\) gefunden werden kann. 26 | \item Die Laufzeit hängt stark von der Anzahl der Schleifendurchläufe ab, da flussvergrößernde Pfade sehr ungünstig gewählt werden können. 27 | \end{itemize} 28 | 29 | 30 | \subsection{Algorithmus von Edmonds und Karp} 31 | Erhöht man den Fluß in Ford-Fulkerson immer längs eines kürzesten Pfads (Breitensuche), erhält man den \textit{Edmonds-Karp-Algorithmus}. 32 | 33 | \begin{itemize} 34 | \item Die Länge \(l_f x\) der kürzesten Pfade \(q \rightarrow^* s\) in \(G_f\) wächst monoton 35 | \item Terminiert für reelle Eingaben 36 | \end{itemize} 37 | 38 | \subsubsection{Laufzeit} 39 | \begin{itemize} 40 | \item In jedem Schritt verliert \(E_f\) eine Kante 41 | \item Wird die Gegenkante durch einen kürzesten Pfad erhöht, kommt diese wieder zurück \(\rightarrow l_fy\) ist um mindestens \(2\) gewachsen 42 | \item Da \(l_f y < |V|-1\) verliert \(E_f\) eine Kante maximal \(\frac{|V|}{2}\)-Mal \(\rightarrow\) Anzahl der Edmonds-Karp-Iterationen \(\in \mathcal{O}(|V| \cdot |E|)\) 43 | %\item Wird eine Kante rückwärts benutzt, wächst die Länge des Flusses um mindestens \(2\), weil gelten muss: $l(s \rightarrow^{\ast} x) \le l(s \rightarrow^{\ast} y)$.\\ 44 | %Wird $x \rightarrow y \rightarrow^{\ast} s$ hinzugefügt, gilt $\forall \text{ Wege } x \rightarrow^{\ast} s : l(x \rightarrow^{\ast} s) > l(y \rightarrow^{\ast} s)$.\\ 45 | %Wird $y \rightarrow x$ eingefügt, gilt die Abschätzung $l(s \rightarrow^{\ast} x) = l(s \rightarrow^{\ast} y)$ und es folgt $l(s \rightarrow^{\ast} y \rightarrow x \rightarrow^{\ast} s) \ge l(s \rightarrow^{\ast} x \rightarrow y \rightarrow^{\ast} s)+2$ 46 | \item Durch die Breitensuche (Worstcase-Laufzeit \(\mathcal{O}(|V|+|E|)\)) ergibt sich eine Gesamtlaufzeit von \(\mathcal{O}(|E|^2 \cdot |V|)\) 47 | \end{itemize} 48 | 49 | 50 | \subsection{Die Präfluss-Pusch-Methode} 51 | Jeder Knoten erhält zusätzlich eine Höhe und ein Reservoir, um vorübergehend beliebig viel Fluss speichern zu können. Letztere könnten nur bergab entleert werdern.\footnote{\url{http://de.wikipedia.org/wiki/Goldberg-Tarjan-Algorithmus}} 52 | 53 | \subsubsection{Pusch} 54 | \(Push(x,y)\) ist nur erlaubt, wenn Überschuss bei \(x\) vorhanden und \(h(x)-h(y) \geq 1\) ist. 55 | \input{algo2/algo_praeflusspusch_pusch} 56 | 57 | \subsubsection{Lifte} 58 | \(Lifte(x)\) ist nur erlaubt, wenn Überschuss bei \(x\) vorhanden und \(h(x) \leq \min_{((x,y) \in E_f}{h(y)}\) ist. 59 | \text{}\\ 60 | \input{algo2/algo_praeflusspusch_lifte} 61 | 62 | \subsubsection{Durchführung} 63 | \input{algo2/algo_praeflusspusch} 64 | 65 | \subsubsection{Korrektheit} 66 | \begin{itemize} 67 | \item Im Verlauf des Algorithmus bleibt \(h\) immer eine gültige Höhenfunktion, da alle erlaubten Operationen die Grundbedingungen des Flussnetzwerks nicht verletzen. 68 | \item Terminiert der Algorithmus, ist \(f\) maximal, da es keinen weiteren Pfad \(q \rightarrow^* s\) gibt (da ansonten gelten müsste: \(h(s) \geq h(q)-|V|+1=1\)) 69 | \end{itemize} 70 | 71 | \subsubsection{Laufzeit} 72 | \begin{itemize} 73 | \item \textit{Lifte} wird höchstens \(2 \cdot |V|^2\) aufgerufen 74 | \item Saturierendes \textit{Pusch}: Die Kante ist überbelegt, d.h. \(u(x) \geq k_f(x,y)\) 75 | \item Anzahl durchgeführte, saturierende \textit{Präfluss-Pusch-Operationen} \(< 2 \cdot |V| \cdot |E|\), da um ein saturierendes \textit{Pusch} erneut ausführen zu können, \(h(y)\) um mindestens \(2\) erhöht und ein \(Pusch(y,x)\) ausgeführt werden muss. 76 | \item Anzahl durchgeführte \textit{Pusch-} und \textit{Lifte}-Operationen \(\in \mathcal{O}(|V|^2\cdot |E|)\) 77 | \end{itemize} 78 | 79 | 80 | \subsection{"`An die Spitze"' Präfluss-Pusch-Algorithmus} 81 | Formalisierung bzw. Erweiterung des \textit{Präfluss-Pusch-Algorithmus}. 82 | \begin{itemize} 83 | \item Verwaltung einer Knotenliste \(L\) in der \(x\) vor \(y\) auftritt, falls \((x,y)\) puschbar ist 84 | \item Verwaltung einer Liste \(i_x\) von Nachbarknoten \(n_x\) pro Knoten 85 | \end{itemize} 86 | \input{algo2/algo_an-die-spitze_leere} 87 | \text{}\\ 88 | \input{algo2/algo_an-die-spitze} 89 | 90 | \subsubsection{Laufzeit} 91 | Faktoren, welche die Laufzeit beeinflussen: 92 | \begin{itemize} 93 | \item Anzahl Aufrufe von \(Leere(x)\) mit \(u(x) = 0\) 94 | \begin{itemize} 95 | \item Da \textit{Lifte} höchstens \(3\)-mal aufgerufen wird, folgt \(|Aufrufe(Leere)| < 2\cdot |V|^3\) 96 | \end{itemize} 97 | \item Anzahl der Aufrufe der Hauptschleife 98 | \begin{itemize} 99 | \item Höchstens \(\mathcal{O}(|V| \cdot |E||)\) Aufrufe von \textit{Lifte} und saturierendem \textit{Pusch} \(\rightarrow\) Gesamtaufwand \(\mathcal{O}(|V|^3)\) 100 | \end{itemize} 101 | \end{itemize} 102 | Laufzeit damit \(\in \mathcal{O}(|V|^3)\). 103 | 104 | 105 | 106 | \subsection{Paare (Paaren in bipartiten Graphen)} 107 | \input{algo2/algo_paare} 108 | 109 | \subsubsection{Laufzeit} 110 | Aufwand \(\in \mathcal{O}(|E|\cdot \sum f(q, V_1)) \subset \mathcal{O}(|E| \cdot |V_1|)\), da ein Pfad \(q \rightarrow^* s\) in \(|E|\) Schritten gefunden werden kann (siehe Laufzeit von \textit{Ford-Fulkerson}). 111 | 112 | \subsection{Quicksort (Sortieren durch stochastisches Teilen)} 113 | Zunächst wird die zu sortierende Liste in zwei Teillisten („linke“ und „rechte“ Teilliste) getrennt. Dazu wählt Quicksort ein sogenanntes Pivotelement aus der Liste aus. Alle Elemente, die kleiner als das Pivotelement sind, kommen in die linke Teilliste, und alle, die größer sind, in die rechte Teilliste. Die Elemente, die gleich dem Pivotelement sind, können sich beliebig auf die Teillisten verteilen. Nach der Aufteilung sind die Elemente der linken Liste kleiner oder gleich den Elementen der rechten Liste. 114 | 115 | Anschließend muss man also nur noch jede Teilliste in sich sortieren, um die Sortierung zu vollenden. Dazu wird der Quicksort-Algorithmus jeweils auf der linken und auf der rechten Teilliste ausgeführt. Jede Teilliste wird dann wieder in zwei Teillisten aufgeteilt und auf diese jeweils wieder der Quicksort-Algorithmus angewandt, und so fort. Diese Selbstaufrufe werden als Rekursion bezeichnet. Wenn eine Teilliste der Länge eins oder null auftritt, so ist diese bereits sortiert und es erfolgt der Abbruch der Rekursion.\footnote{\url{http://de.wikipedia.org/wiki/Quicksort\#Prinzip}} 116 | \text{}\\\\ 117 | \input{algo2/algo_quicksort} 118 | 119 | \subsubsection{Laufzeit} 120 | \begin{itemize} 121 | \item Aufwandsabschätzung anhand der in Schritt 3 durchgeführten Vergleiche 122 | \item Wahrscheinlichkeit, dass \(s_i\) und \(s_j\) verglichen werden steigt mit der Anzahl der Zwischenelemente (\(p_{ij}=\frac{2}{|j-i|+1}\)) 123 | \item Daraus ergibt sich ein Aufwand \(\in \mathcal{O}(nlogn)\) (Summe der Erwartungswerte der Einzelwahrscheinlichkeiten) 124 | \end{itemize} 125 | 126 | 127 | \subsection{Minimaler Schnitt} 128 | Ist \(E\) eine Folge in \(V^2\) heißt \((V,E)\) Multigraph, weil Kanten mehrfach vorkommen können. \(S \subset E\) heißt \textit{Schnitt} von \((V,E)\), wenn \((V, E \backslash S)\) unzusammenhängend ist, also mindestens zwei Komponenten hat. 129 | \text{}\\ 130 | \input{algo2/algo_schnitt} 131 | 132 | 133 | \subsection{Finde} 134 | Findet das \(k\)-kleinste Element in einer unsortierten Liste. 135 | \text{}\\ 136 | \input{algo2/algo_finde} 137 | 138 | \subsubsection{Laufzeit} 139 | \(\mathcal{O}(n)\) 140 | 141 | \subsection{Spielbaumauswertung} 142 | Binärer Spielbaum: Balancierter Binärbaum gerader Höhe \(2k\), mit Knotenwerten \(\in \{0,1\}\). Dies entspricht einem Spiel, bei dem zwei Spieler abwechselnd ihren Gewinn maximieren. 143 | 144 | Es gilt außerdem: 145 | \begin{itemize} 146 | \item \(Wert(x) = Wert(y) \downarrow Wert(z)\) 147 | \item \(a \downarrow b := a~NOR~b := \overline{a \vee b}\) 148 | \item \((a \downarrow b) \downarrow (c \downarrow d) = \overline{\overline{a \vee b} \vee \overline{c \vee d}} = (a \vee b) \wedge (c \vee d)\) 149 | \end{itemize} 150 | 151 | \subsubsection{Extrema} 152 | \begin{itemize} 153 | \item Minima: Werte der Nicht-Blatt-Knoten auf gerader Höhe 154 | \item Maxima: Werte der Nicht-Blatt-Knoten auf ungerader Höhe 155 | \end{itemize} 156 | 157 | \input{algo2/algo_wert} 158 | 159 | 160 | \subsection{BZR (Binäre Zerlegung des Raum)} 161 | Rekursive Zerlegung eines Polyeders des \(\mathbb{R}^3\) anhand einiger Polygone. Pro Iterationsschritt wird jeweils ein Polygon bestimmt (bevorzugt eines, das den Polyeder komplett zerlegt). Dieses teilt den Polyeder in einen linken und einen rechten Teilpolyeder, die jeweils weiter zerlegt werden. 162 | \text{}\\ 163 | \input{algo2/algo_brz} 164 | 165 | 166 | \subsection{Konstruktion konvexer Hüllen} 167 | Die konvexe Hülle einer Teilmenge ist die kleinste konvexe Menge, die die Ausgangsmenge enthält.\footnote{\url{http://de.wikipedia.org/wiki/Konvexe_Hülle}} 168 | 169 | \subsubsection{Annahmen} 170 | \begin{itemize} 171 | \item Die Reiehenfolge der \(p_i\) sei gleichverteilt zufällig 172 | \item Keine vier der Ebenen \(p_i^{*}\) schneiden sich in einem Punkt 173 | \item Jeder Knoten hat den Grad \(3\) 174 | \end{itemize} 175 | \input{algo2/algo_konvexe-huelle} 176 | \text{}\\ 177 | Gesamtlaufzeit \(\in \mathcal{O}(nlogn)\). 178 | 179 | 180 | \subsection{Pledge Startegie} 181 | \begin{itemize} 182 | \item Ziel: Finde einen Weg aus einem Labyrinth. 183 | \item Der Roboter kann erkennen, wenn er das Labyrinth verlassen hat. 184 | \item Bei jeder Drehung wird die Änderung zum Startwinkel \(\phi\) aktualisiert. 185 | \end{itemize} 186 | \input{algo2/algo_pledge} 187 | 188 | 189 | \subsection{Wanze} 190 | Findet ein Ziel in einer Umgebung mit Hindernissen. 191 | \text{}\\ 192 | \input{algo2/algo_wanze} 193 | 194 | \textit{Wanze} terminiert, da \(R\) das Ziel spätestens dann findet, wenn er alle \(P_i\) maximal einmal umlaufen hat (bei jedem Umlaufen verkleinert sich die Distanz zum Ziel). 195 | 196 | 197 | \subsection{Türsuche 1} 198 | Roboter steht vor einer langen Wand und sucht die Tür. 199 | \text{}\\ 200 | \input{algo2/algo_tuersuche-1} 201 | 202 | 203 | \subsubsection{Kompetitivität} 204 | Weglänge: Ist die Tür \(d = n + (0,1)\) Meter vom Ausgangspunkt entfernt, gilt:\newline 205 | \(w \geq 2 \cdot 1 + 2 \cdot 2 + ... + 2n +n = O(n^2) \rightarrow\) \textit{Türsuche 1} ist nicht kompetitiv. 206 | 207 | 208 | \subsection{Türsuche 2} 209 | Roboter steht vor einer langen Wand und sucht die Tür. 210 | 211 | \begin{algorithm}[H] 212 | \caption{Türsuche 2} 213 | \SetKwData{Left}{left}\SetKwData{This}{this}\SetKwData{Up}{up} 214 | \SetKwFunction{Union}{Union}\SetKwFunction{FindCompress}{FindCompress} 215 | \SetKwInOut{Input}{input}\SetKwInOut{Output}{output} 216 | 217 | $i \longleftarrow 1$ 218 | \BlankLine 219 | 220 | \While{Tür noch nicht gefunden}{ 221 | gehe $i$ Meter der Wand entlang\newline 222 | \tcc{ändert die Laufrichtung} 223 | gehe i Meter zurück\newline 224 | $i \longleftarrow 2i$\\ 225 | } 226 | \end{algorithm} 227 | 228 | \subsubsection{Kompetitivität} 229 | Weglänge: Ist die Tür \(d = 2^{n+\delta}\) Meter vom Ausgangspunkt entfernt, gilt:\newline 230 | \(w \leq 2 \sum\limits_{i=0}^{n+1} 2^i + d \leq 2 ^{n+3+\delta} + d \le 9 \cdot d \rightarrow\) \textit{Türsuche 2} ist 9-kompetitiv. 231 | 232 | 233 | \subsection{Sternsuche} 234 | Verallgemeinerung der \textit{Türsuche}: Roboter steht in der Mitte eines Kreuzes aus \(m\) Halbgeraden. 235 | \text{}\\ 236 | \input{algo2/algo_sternsuche} 237 | 238 | \subsubsection{Kompetitivität} 239 | Sternsuche ist kompetetiv mit dem Faktor \(c = 2m \left(\frac{m}{m-1}\right)^{m-1}+1\). 240 | 241 | 242 | \subsection{Simplex} 243 | Um \(z\) zu maximieren, machen wir sukzessiv neue \(y_i\) zu neuen Koordinaten, so dass der Ursprung von Ecke zu Ecke von \(s\) wandert und der Wert von \(z\) im Ursprung wächst. Dazu tauschen wir immer eine Koordinate von \(\overline{y}\) mit einer von \(\overline{\overline{y}}\). 244 | \text{}\\ 245 | \input{algo2/algo_simplex_austausch} 246 | \text{}\\ 247 | \input{algo2/algo_simplex} 248 | 249 | 250 | \subsection{Zufallsgesteuerte Optimierung} 251 | Optimierungsaufgaben bestehen aus 252 | \begin{enumerate} 253 | \item Suchraum $Q$, Teil des Zustandsraumes $Z$, 254 | \item Bewertungsfunktion $c: Z \rightarrow \mathbb{R}$, die jedem Zustand $q$ seine Kosten $c(q)$ zuweist, 255 | \item Eine Funktion $l: Z \rightarrow \mathbb{R}$, die für alle $q \in Q$ die Nebenbedingungen charakterisiert. 256 | \end{enumerate} 257 | 258 | \subsubsection{Definitionen} 259 | \begin{itemize} 260 | \item Gesucht wird ein \(q \in Q\) mit minimalen oder maximalen Kosten 261 | \item Eine Optimierungsaufgabe heißt kombinatorischen, wenn \(Q\) diskret ist 262 | \item Nebenbedingungen können vermieden werden, indem man \(c\) so umformuliert, dass \(q \not\in Q\) so schlecht bewertet werden, dass sie nicht als Lösung in Frage kommen: \(c'(q) = c(q) + \gamma \cdot l^2(q)\) 263 | \item \(q\) ist globales Optimum: \(\forall p \in Q~|~p \ne q: c(q) \le c(p)\) 264 | \item \(q\) ist lokales Optimum: \(\forall p \in Nachbar(q): c(q) \le c(p)\) 265 | \end{itemize} 266 | 267 | \subsubsection{Gradientenverfahren} 268 | Zustandsraum \(Z \in \mathbb{R}^n\), jeder Zustand ist ein Punkt \(x = [x_1, ... , X_n]^T\). 269 | Ausgehend vom Startpunk $x_0$ wird der Gradient der Kostenfunktion an der aktuellen Stelle berechnet: 270 | \[\Delta c(x_0) = \left[ \diffp{c}{{x_{1}}}, ... , \diffp{c}{{x_{n}}} \right]\] 271 | 272 | \begin{itemize} 273 | \item Die Nachfolger werden definiert durch \(x_{i+1} = x_i + h \cdot \delta c(x_i)\), wobei \(h > 0\) wenn \(c\) maximiert wird, bzw. \(h < 0\) wenn \(c\) minimiert wird 274 | \item Der Gradient ist die Richtung des steilsten Auf-/Abstiegs $\rightarrow$ Methode des steilsten Auf-/Abstiegs 275 | \item Gradientenverfahren sind deterministisch 276 | \item Es kann passieren, dass nur ein lokales Optimum gefunden wird \(\rightarrow\) nur anwenden, wenn es keine lokalen Optima/Minima gibt; Ableitung und Straftherme einfach zu berechnen sind 277 | \end{itemize} 278 | 279 | \subsubsection{Suchverfahren} 280 | Ist der Suchraum diskret, definiert man für alle \(q\) die Menge der direkten Nachbarn \(N(q) \subset Q \rightarrow\) man kann \(Q\) von einem Anfangszustand aus durchsuchen. 281 | 282 | Alle folgenden Algorithmen sind Suchverfahren. 283 | 284 | \paragraph{Simuliertes Tempern} 285 | \text{}\\ 286 | \input{algo2/algo_simuliertes-tempern} 287 | 288 | 289 | \paragraph{Schwellwert Algorithmus} 290 | \begin{itemize} 291 | \item Wähle zufälligen Nachbarn, gilt \(c(p) \geq c(q) - \sigma\), fahre fort mit \(q = p\) 292 | \item Schwellwert \(\sigma\) wird mit der Zeit kleiner 293 | \item Besser als Simuliertes Tempern, kann trotzdem in lokalem Maxima hängen bleiben 294 | \end{itemize} 295 | 296 | \paragraph{Sintflut Algorithmus} 297 | \begin{itemize} 298 | \item Starte mit $\sigma = 0$. Wähle zufälligen Nachbarn. Gilt $c(p) > \sigma$, fahre fort mit $q = p$ 299 | \item $\sigma$ wird mit der Zeit größer 300 | \item Besser als Simuliertes Tempern, kann trotzdem in lokalem Maxima hängen bleiben 301 | \end{itemize} 302 | 303 | \paragraph{Rekordjagt Algorithmus} 304 | \begin{itemize} 305 | \item Bisher höchster Wert (Rekord) wird gespeichert 306 | \item Akzeptanzbedingung: \(c(p) \geq Rekord - \sigma\) 307 | \item \(\sigma\) wird mit der Zeit abgesenkt 308 | \item Besser als Simuliertes Tempern, kann trotzdem in lokalem Maxima hängen bleiben 309 | \end{itemize} 310 | 311 | \subsubsection{Evolutionäre Algorithmen} 312 | \begin{itemize} 313 | \item Eine Population besteht aus Individuen 314 | \item Individuen haben einen Genotyp / Merkmalsvektor \(q \in \mathbb{R}^n\) und einen Phänotyp/Bewertungsfunktion \(c(q)\) 315 | \item Individuen können sich fortpflanzen. Haben sie zwei oder mehr Eltern $\rightarrow$ Kreuzung, haben sie einen Elter $\rightarrow$ Klon 316 | \item Die Größe der Population wird konstant gehalten 317 | \end{itemize} 318 | 319 | \paragraph{Plus oder $(\mu + \lambda)$ Strategie} 320 | \begin{itemize} 321 | \item Die Population \(Q\) ändert sich mit der Zeit, ihre Größe \(\mu = |Q|\) bleibt konstant 322 | \item Die \(\mu\) Individuen mit der besten Fitness \(c(q)\) und \(\lambda\) Nachkommen bilden die nächste Generation, \(\lambda\) Eltern sterben 323 | \item Eltern werden gleichverteilt aus \(Q\) gewählt 324 | \item Es wird nicht gekreuzt, sondern nur geklont und mutiert. Zumindest steht nichts davon im Skript, sollte aber möglich sein... 325 | \end{itemize} 326 | 327 | \paragraph{Mehrere Eltern} 328 | \text{ }\\Es kann auch mehrere Eltern geben, die Merkmalsvektoren werden entweder gemischt oder gemittelt. 329 | 330 | 331 | \paragraph{Allgemeine Strategie $((\mu, k, \lambda, p) - ES)$} 332 | \begin{itemize} 333 | \item \(\mu\): Populationsgröße - Für jede Generation konstant. 334 | \item \(\lambda\): Anzahl der Nachkommen pro Generation 335 | \item \(k\): Maximale Lebenszeit - \((k = 1)\) bei Komma-, \((k=\infty)\) bei Plus-Strategie 336 | \item \(p\): Anzahl der Eltern eines Individuums 337 | \end{itemize} 338 | 339 | \subsubsection{Genetische Algorithmen} 340 | Merkmale in binärem Merkmalsvektor gespeichert, starke Eltern pflanzen sich häufiger fort als schwache. 341 | 342 | \begin{itemize} 343 | \item Fortpflanzung: Jedes Individuum wird mit der Wahscheinlichkeit \(W(q) = \frac{c(q)}{\sum\limits_{p \in Q}c(p)}\) Elter. die \(\mu\) Individuen erzeugen \(\mu\) Nachkommen, nur diese überleben. 344 | \item Kreuzung: Von den \(\mu\) Nachkommen werden \(p\%\) einer Kreuzung unterzogen. Die Kreuzungspaare sind zufällig. 345 | \item Mutation: Jedes Bit des Merkmalsvektors wird mit einer sehr kleinen Wahscheinlichkeit \(p_m\) invertiert. 346 | \end{itemize} 347 | 348 | \paragraph{Schema-Theorem:} Merkmale werden häufiger reproduziert, wenn sie 349 | \begin{enumerate} 350 | \item durch weniger Bits dargestellt werden, 351 | \item diese Bits eng zusammenstehen (im Vektor), 352 | \item sie eine hohe Fitness bedeuten. 353 | \end{enumerate} 354 | 355 | \subsubsection{Vergleich: Evolutionsstrategien vs. Genetische Algorithmen} 356 | \begin{itemize} 357 | \item Evolutionsstrategien $\rightarrow$ konvergieren schneller, enden aber öfter in lokalem Max/Min.\\ 358 | \item Genetische Algorithmen $\rightarrow$ bevorzugen Kreuzung statt Mutation, größere Sprünge im Suchraum, finden öfter globales Optimum, konvergieren schlechter. 359 | \end{itemize} 360 | 361 | \subsubsection{Partikelschwarmoptimierung (P-S-O)} 362 | \input{algo2/algo_pso} 363 | 364 | 365 | \subsection{Algorithmus von de Casteljau} 366 | Der Algorithmus von de Casteljau ermöglicht die effiziente Berechnung einer beliebig genauen Näherungsdarstellung von Bézierkurven durch einen Polygonzug.\footnote{http://de.wikipedia.org/wiki/De-Casteljau-Algorithmus} 367 | 368 | Der de Casteljau-Algorithmus angewendet auf ein Polygon \(B_0^0\) ist die Konkatenation von \(B_0^1\) und \(B_1^1\): \(C(B_0^0,t) := B_0^1 B_1^1\). 369 | \text{}\\ 370 | \input{algo2/algo_de-casteljau} 371 | 372 | 373 | \subsection{Der Algorithmus von Lane und Riesenfeld (LR-Algorithmus)} 374 | Dient dazu, stückweise polynomielle Kurven (Splines) zu erzeugen. Dazu erzeugt er wie der \textit{de Casteljau-Algorithmus} eine Folge von Polygonen(Kontrollpolygone), welche den Grenzwert der Folge(Limeskurve) definieren. 375 | 376 | Im Gegensatz zum \textit{de Casteljau-Algorithmus} wird der \textit{LR-Algorithmus} meist für biinfinite Kontrollpolygone \(c_\mathbb{Z} := (c_i)_{i \in \mathbb{Z}} = (...,c_{-1},c_0,c_1,...)\) beschrieben. Hierbei können endliche Polygone als biinfinite aufgefasst werden, bei denen nur endlich viele Kontrollpunkte \(c_i\) von \(\mathbb{D}\) verschieden sind. 377 | \text{}\\ 378 | \input{algo2/algo_lr} 379 | 380 | 381 | \subsection{Naive Textsuche} 382 | Im Folgenden ist \(A\) ein Alphabet, \(t = t_1,...,t_n \in A^n\) ein Text und \(s = s_1,...,s_m \in A^m\) mit \(m 0\) (riskant) 150 | \item Portefeuille \(w = (w_1, w_2), w_1 + w_2 = 1\) 151 | \end{itemize} 152 | 153 | $\rightarrow$ \(\tilde{r}_r = w_1 \cdot r + w_2 \cdot \tilde{r}_2\) 154 | 155 | \begin{itemize} 156 | \item Welche Kombinationen sind durch Portefeuillebildung erreichbar? 157 | \item Welche Portefeuilles sind effizient? 158 | \end{itemize} 159 | Alle erreichbaren \(\mu-\sigma-Kombinationen\) liegen auf einer Geraden. 160 | Portefeuille, das Investor aus der Menge der effizienten als optimales auswählt, hängt von individueller Risikoeinstellung ab (Indifferenzkurven). 161 | 162 | \subsubsection{Aufteilung in \(N\) riskante Wertpapiere, \(N = 2\)} 163 | Die erreichbaren \(\mu-\sigma-Kombinationen\) liegen auf einer Hyperbel. 164 | Alle erreichbaren Portefeuilles, die nicht dominiert werden (oberhalb des \textit{globalen varianzminimalem Portfeuille}) sind effizient (oberhalb des Extrempunkts). 165 | 166 | \subsubsection{Zusammenfassung} 167 | \begin{itemize} 168 | \item Die \(\mu-\sigma-Kombinationen\) liegen auf einer Hyperbel, falls \(|\rho_{12}| < 1\), anderenfalls liegen sie auf einer Geraden 169 | \item Die effizienten Portefeuilles liegen oberhalb des GVMP 170 | \item Ohne Leerverkaufsbeschränkung ist das Risiko des GVMP immer kleiner als die Einzelrisiken $\rightarrow$ grundsätzliche Risikoreduktion durch Diversifikation 171 | \item Das optimale Portefeuille hängt von der individuellen Risikoeinstellung des Investors ab 172 | \end{itemize} 173 | 174 | \subsubsection{Aufteilung in \(N\) riskante Wertpapiere, \(N > 2\)} 175 | \begin{itemize} 176 | \item Die Menge der erreichbaren \(\mu-\sigma-Kombinationen\) bilden eine Fläche 177 | \item Der Rand ist durch die diejenigen \(\mu-\sigma-Kombinationen\) charakterisiert, die bei gegebenem \(\mu\) das kleinstmögliche \(\sigma\) aufweisen 178 | \item Der Teil des Rands oberhalb des GVMP bilden den effizienten Rand 179 | \end{itemize} 180 | 181 | 182 | \subsection{Index-Modelle} 183 | 184 | \subsubsection{Markowitz-Modell} 185 | Investor benötigt je nach Anlagespektrum viele Schätzwerte $\rightarrow$ erheblicher Schätzaufwand. 186 | 187 | Ziel im Folgenden: Durch Vorgabe einer Struktur hinsichtlich Risiken den Schätzaufwand reduzieren. 188 | 189 | \subsubsection{Single Index Modell} 190 | Aktienrendite wird an einen Faktor (Marktindex) gekoppelt. 191 | \[\tilde{r}_i = \alpha_i + \beta_i \cdot \tilde{r}_I + \tilde{\epsilon}_i\] 192 | 193 | \subsubsection{Strukturelle Annahmen} 194 | \begin{enumerate} 195 | \item Aktienindividuelle Störterme sind nicht systematisch verzerrt 196 | \item Aktienindividuelle Störterme sind unkorreliert zur Marktrendite 197 | \item Aktienindividuelle Störterme sind paarweise unkorreliert 198 | \end{enumerate} 199 | 200 | \begin{itemize} 201 | \item \(\beta_i^2 > 1\) $\rightarrow$ aggresive Aktie 202 | \item \(\beta_i^2 < 1\) $\rightarrow$ defensive Aktie 203 | \end{itemize} 204 | 205 | \subsubsection{Implikationen} 206 | \begin{itemize} 207 | \item Indexentwicklung einzige Quelle für Korrelationen zwischen Aktienrenditen 208 | \item Risiko einzelner Aktien kann in \textit{nicht diversifizierbares} und \textit{Residualrisiko} eingeteilt werden 209 | \item Anzahl der Parameter deutlich geringer als bei vollem Markowitz-Modell 210 | \item Portefeuille-Beta entspricht der gewichteten Summer der Einzel-Betas 211 | \item Restrisiko entspricht der gewichteten Summer der Einzelrestrisiken 212 | \item Restrisiko kann im Gegensatz zum Marktrisiko reduziert werden 213 | \end{itemize} 214 | 215 | 216 | \subsection{Capital Asset Pricing Modell} 217 | 218 | \subsubsection{Modellannahmen} 219 | \begin{enumerate} 220 | \item \textbf{Modellannahmen} 221 | \begin{enumerate} 222 | \item \textbf{Investoren} 223 | \begin{itemize} 224 | \item Wählen Portefeuille auf Basis von Erwartungswert und Varianz der Rendite 225 | \item Besitzen homogene Erwartungen bzgl. relevanter Entscheidungsparameter 226 | \item Besitzen den selben Anlagehorizont (im Folgenden 1 Jahr) 227 | \end{itemize} 228 | \item \textbf{Kapitalmärkte} 229 | \begin{itemize} 230 | \item Sind friktionslos bei vollkommener Konkurrenz 231 | \item Risikoloses Paper exisiert 232 | \item Bestehen aus handelbaren Wertpapieren bei festem Angebot 233 | \end{itemize} 234 | \end{enumerate} 235 | \item \textbf{Individualkalkül der Investoren} 236 | \begin{itemize} 237 | \item Jeder Investor optimiert gemäß Portefeuilletheorie 238 | \item Tangentialportefeuilles der einzelnen Anleger simmen in relativer Zusammensetzung der riskanten Instrumente überein 239 | \end{itemize} 240 | \end{enumerate} 241 | 242 | \subsubsection{Marktportefeuille} 243 | Portefeuille bestehend aus allen umlaufenden Aktien des betrachteten Marktes in den relativen Anteilen ihres Wertes. 244 | 245 | \subsubsection{Ergebnis im Gleichgewicht} 246 | \begin{itemize} 247 | \item Jeder Investor legt sein riskantes Vermögen in der gleichen Zusammensetzung wie das Marktportefeuille an 248 | \item Die risikolose Komponente wird durch den Grad der individuellen Risikoaversion bestimmt 249 | \end{itemize} 250 | 251 | \subsubsection{Kapitalmarktlinie} 252 | Alle effizienten Portefeuilles liegen auf einer Geraden (Capital Market Line). 253 | \begin{itemize} 254 | \item Marktpreis des Risikos gibt an, wieviel zusätzliche Rendite im Gleichgewicht für zusätzliches Risiko zu erwarten ist 255 | \item Das einzige effiziente Aktienportefeuille ist das Marktportefeuille 256 | \item Auf Basis von CAPM ist passive Handelsstrategie (Nachbilden des Marktportefeuilles) sinnvoll 257 | \end{itemize} 258 | 259 | \subsubsection{Zerlegung des Gesamtrisikos \(\sigma_i^2\) der einzelnen Aktie} 260 | \begin{itemize} 261 | \item Risikobeitrag zum Gesamtrisiko \(cov(\tilde{r}_i, \tilde{r}_M)\): Nicht diversifizierbares systematisches Risiko 262 | \item Unternehmensbezogenes Restrisiko \(\sigma_{\epsilon_i}^2\): Diversifizierbares unsystematisches Risiko. Übernahme dieses Risikos wird vom Markt nicht durch höhere erwartete Rendite vergütet 263 | \item Zerlegung: \(\sigma_i^2 = \beta_i^2 \cdot \sigma_M^2 + \sigma_{\epsilon_i}^2\) 264 | \end{itemize} 265 | $\rightarrow$ Anstatt \(\sigma_i\) ist \(cov(\tilde{r}_i, \tilde{r}_M)\) als Risikomaß relevant. 266 | 267 | \subsubsection{Zentrale Aussage des CAPM} 268 | Für alle Wertpapiere gilt eine lineare Beziehung zwischen erwarteter Rendite und Risiko. 269 | 270 | Der risikolose Zinssatz entspricht der erwarteten Rendite des Zero-Beta-Portefeuilles, da im CAPM nur systematisches Risiko vergütet wird. 271 | 272 | 273 | \subsection{Arbitrage Pricing Theory} 274 | \begin{itemize} 275 | \item Empirische Überprüfbarkeit des CAPM in Frage gestellt 276 | \item Alternative Bewertungstheorie des CAPM, die Marktportefeuille nicht benötigt 277 | \item \textbf{Prinzip} 278 | \begin{itemize} 279 | \item Anstatt \(\mu - \sigma - Optimierer\) zu unterstellen, renditegenerierter Prozess: \(\tilde{r}_i = \alpha_i + \beta_{i,1} \cdot \tilde{I}_1 + \alpha_2 + \beta_{i,2} \cdot \tilde{I}_2 + \dots + \alpha_i + \beta_{i,k} \cdot \tilde{I}_k + \tilde{\epsilon}_i\) 280 | \item Marktpreise der Faktorrisiken: \(\lambda_1, \dots, \lambda_k\) 281 | \item Falls risikoloses Papier existiert: \(\lambda_0 = r\) 282 | \end{itemize} 283 | \end{itemize} 284 | 285 | 286 | \subsection{Performancemessung} 287 | Wie kann die Performance 288 | \begin{itemize} 289 | \item eines Portefeuilles (Handelsstrategie)\\ 290 | bzw 291 | \item einer Fondinvestition 292 | \end{itemize} 293 | gemessen und beurteilt werden? 294 | 295 | \subsubsection{Anwendung} 296 | \begin{itemize} 297 | \item leistungsgerechte Vergütung des Fondsmanager 298 | \item Grundlage für zukünftige Investitionsentscheidungen 299 | \end{itemize} 300 | 301 | \subsubsection{Performancemessung auf Basis der Rendite} 302 | \begin{itemize} 303 | \item Wenig aussagekräftig, da sie sowohl auf Zufall, Übernahme von (hohen) Risiken oder besonderen Fähigkeiten des Fondsmanager beruhen kann 304 | \item Besser: Risikoadjustierte Rendite oder Analyse auf Basis langer Zeitreihen 305 | \end{itemize} 306 | 307 | \subsubsection{Sharpe-Ratio} 308 | Idee: Investoren präferieren das Wertpapier, bei dem sich durch Kombination mit dem risikolosen die beste Rendite/Risikokombination erreichen lässt. 309 | 310 | \subsubsection{Jensen's Alpha} 311 | Idee: Vertikaler Abstand der erzielten Durchschnittsrendite von der Gleichgewichtsrendite gemäß eingegangenem Risiko auf der Wertpapiermarktlinie. 312 | 313 | Berücksichtigt allerding nicht, dass gewünschtes Risiko durch Mischung aus riskant und risikolos erzeugt werden kann. 314 | 315 | \subsubsection{Treynor-Maß} 316 | Idee: Mittlere Überrendite pro Einheit systematisches Risiko. 317 | 318 | 319 | 320 | \section{Investitionsentscheidungen auf Rentenmärkten} 321 | 322 | \subsection{Renditekennziffern} 323 | Analyse festverzinslicher Wertpapiere erfolgt i.A. auf Basis verschiedener Kennziffern, die im Grundsatz Ertrag und Risiko des Wertpapiers quantifizieren. 324 | 325 | \subsubsection{Nullkuponanleihe} 326 | Eine Nullkuponanleihe ist eine Sonderform des verzinslichen Wertpapiers. Dabei gibt es keinen Kupon (d. h. keine laufende Zinszahlung) und nur eine Auszahlung am Ende der Laufzeit der Anleihe. Der Gewinn für den Anleger besteht damit nur in der Differenz zwischen dem Erwerbskurs und dem Rückzahlungspreis bzw. Verkaufskurs.\footnote{\url{http://de.wikipedia.org/wiki/Nullkuponanleihe}} 327 | 328 | \subsubsection{Yield to maturity} 329 | Die Effektivverzinsung (Yield to Maturity, YtM) errechnet sich aus der Diskontierung der zukünftigen Cash Flows (Kupon und Nominalbetrag) mit einem einheitlichen Diskontierungsfaktor. Ergebnis der Diskontierung ist der heutige Kurs.\footnote{\url{http://de.wikipedia.org/wiki/Yield_To_Maturity}} 330 | 331 | \subsubsection{Plain Vanilla Zinsswaps} 332 | \begin{itemize} 333 | \item Vereinbarung zweier Parteien, Zinszahlungen zu tauschen 334 | \item Eine Partei zahlt Zinsen bezogen auf festen Zinssatz (Swapsatz) und festgelegten Nominalbetrag (Swapkäufer, Fix Payer) 335 | \item Zweite Partei zahlt Zinsen bezogen auf variablen Zinssatz und denselben Nominalbetrag (Swapverkäufer, Fix Receiver) 336 | \end{itemize} 337 | 338 | \begin{tabularx}{\columnwidth}{l|X|X|X|c|l} 339 | & \(t=0\) & \(t=1\) & \(t=1\) & \(\dots\) & \(t=T\) \\ 340 | \hline 341 | Fix Payer zahlt & \(0\) & \(s(0,T)\) & \(s(0,T)\) & \(\dots\) & \(s(0,T)\) \\ 342 | Fix Receiver zahlt & \(0\) & \(L(0)\) & \(\tilde{L}(1)\) & \(\dots\) & \(\tilde{L}(T-1)\) 343 | \end{tabularx} 344 | 345 | Alle Änderungen innerhalb einer Periode wirken sich erst auf die folgende Periode aus. 346 | 347 | \subsubsection{Zusammenfassung} 348 | \begin{itemize} 349 | \item Interne Renditen von Kuponanleihen 350 | \begin{itemize} 351 | \item Hängen von der Kuponhöhe ab 352 | \item Eine Anlageentscheidung aufgrund der internen Rendite ist wenig sinnvoll 353 | \item Vielmehr ist zu prüfen, ob die Kuponanleihe relativ zur Zinsstrukturkurve fair bewertet ist 354 | \end{itemize} 355 | \end{itemize} 356 | 357 | 358 | \subsection{Duration} 359 | Die Duration ist eine Sensitivitätskennzahl, die die durchschnittliche Kapitalbindungsdauer einer Geldanlage in einem festverzinslichen Wertpapier bezeichnet. Genauer genommen und allgemein formuliert ist die Duration der gewichtete Mittelwert der Zeitpunkte, zu denen der Anleger Zahlungen aus einem Wertpapier erhält.\footnote{\url{http://de.wikipedia.org/wiki/Duration}} 360 | 361 | Prinzipiell basiert das Risikomaß Duration auf der Grundidee, dass das Zinsrisiko direkt mit der Restlaufzeit zusammenhängt. So ist das Risiko umso höher, je länger eine Anleihe läuft.\footnote{\url{http://finance.wiwi.tu-dresden.de/Wiki-fi/index.php/Duration}} 362 | \begin{itemize} 363 | \item Macaulay-Duration: Zeitgewichtete diskontierte Zahlungen pro Preiseinheit, relatives Maß für die Wertänderung 364 | \item EUR-Duration: Änderung eines Wertpapierpreises bei einer Zinsänderung von einem Prozentpunkt, Maß für die absolute Preisänderung 365 | \end{itemize} 366 | 367 | 368 | 369 | \section{Appendix A: Begrifflichkeiten} 370 | 371 | \subsubsection{Festverzinslicher Titel} 372 | Schuldrechtlicher Anspruch auf 373 | \begin{itemize} 374 | \item Zahlung eines zeitabhängigen Entgelts (Zinsen) 375 | \item Rückzahlung des überlassenen Kapitals 376 | \item Beispiele: Darlehen, Anleihe 377 | \end{itemize} 378 | 379 | \subsubsection{Anleihen} 380 | \begin{itemize} 381 | \item Werden in homogene Teile zerstückelt und verbrieft (Homogenität ermöglicht Börsenhandel) 382 | \item Werden typischerweise am Sekundärmarkt gehandelt 383 | \item Besitzen unterschiedliche Ausstattungsmerkmale (Art der Verzinsung/Rückzahlung, Rückzahlungskurs, Laufzeit) 384 | \end{itemize} 385 | 386 | \subsubsection{Termingeschäfte} 387 | \begin{itemize} 388 | \item Terminpreis einer Nullkuponanleihe \(F(0, S, T)\): Zum Zeitpunkt \(0\) vereinbarter Preis über den unbedingten Kauf einer in \(T\) fälligen Nullkuponanleihe im Zeitpunkt \(S\) 389 | \end{itemize} 390 | 391 | \subsubsection{Zinsen} 392 | \begin{itemize} 393 | \item Kassazins (spot price): Zinssatz für eine Kapitalanlage, deren Laufzeit sofort beginnt 394 | \item Terminzins (forward rate): Zinssatz, der für einen zukünftigen Zeitpunkt gilt 395 | \end{itemize} 396 | 397 | 398 | 399 | \section{Appendix B: Formelsammlung} 400 | 401 | \subsection{Portefeuilletheorie} 402 | 403 | \subsubsection{Rendite einer Aktie} 404 | \[\tilde{r} = \frac{\tilde{S} (1) + D - S(0)}{S(0)},~\mu_i = \frac{E[S_i(1)]}{S_i(0)} - 1,~\sigma_i = \frac{Std[S_i(1)]}{S_i(0)}\] 405 | 406 | \subsubsection{Portefeuillerendite} 407 | Gewichtete Summe der Einzelrenditen. Gewichtung am Wertanteil \(w_i\) am Gesamtwert des Portefeuilles. 408 | 409 | \subsubsection{Erwartete Portefeuillerendite} 410 | \[\mu_w = \sum_{i=1}^{N} w_i \cdot \mu_i\] 411 | 412 | \subsubsection{Varianz der Portefeuillerendite} 413 | \[\sigma_w^2 = \sum_{i=1}^{N}\sum_{j=1}^{N} w_i \cdot w_j \cdot \rho_{ij} \cdot \sigma_i \cdot \sigma_j\] 414 | 415 | \subsubsection{Erreichbare \(\mu-\sigma-Kombinationen\)} 416 | \[\mu_w = r + \frac{\mu_2 - r}{\sigma_2} \cdot \sigma_w \] 417 | 418 | \subsubsection{Berechnung der Geradengleichung der effizienten Linie \(\mu_w(\sigma_w)\)} 419 | \[\vec{\mu}_x = \vec{\mu} - \vec{r}\] 420 | \[V = \begin{pmatrix} \sigma_1^2 & 0 \\ 0 & \sigma_2^2 \\ \end{pmatrix}\] 421 | \[\vec{w}_M = V^{-1} \cdot \vec{\mu}_x\] 422 | \[\mu_M = w_M^T \cdot \vec{\mu}_x - r\] 423 | \[\sigma_M = \sqrt{\vec{w}_M^T \cdot V \cdot \vec{w}_M}\] 424 | 425 | \subsubsection{Aufteilung in \(N\) riskante Wertpapiere, \(N = 2\), Bestimmung des GVMP} 426 | \[\tilde{r}_w = w_1 \cdot \tilde{r}_1 + w_2 + \tilde{r}_2\] 427 | \[\mu_w = w_1 \cdot \mu_1 + w_2 \cdot \mu_2\] 428 | \[\sigma_w = \sqrt{w_1^2 \cdot \sigma_1^2 + 2 \cdot \sigma_1 \cdot \sigma_2 \cdot \rho_{12} \cdot w_1 \cdot w_2 + w_2^2 \cdot \sigma_2^2}\] 429 | \[w_1 = \frac{\sigma_2^2-\sigma_1 \cdot \sigma_2 \cdot \rho_{12}}{\sigma_1^2-2 \cdot \sigma_1 \cdot \sigma_2 \cdot \rho_{12} + \sigma_2^2}\] 430 | \[w_2 = \frac{\sigma_1^2 - \sigma_1 \cdot \sigma_2 \cdot \rho_{12}}{\sigma_1^2 - 2 \cdot \sigma_1 \cdot \sigma_2 \cdot \rho_{12} + \sigma_2^2}\] 431 | \[\sigma_w^2 = \frac{\sigma_1^2 \cdot \sigma_2^2 \cdot (1 - \rho_{12}^2)}{\sigma_1^2 - 2 \cdot \sigma_1 \cdot \sigma2 \cdot \rho_{12} + \sigma_2^2}\] 432 | \[\sigma_w = \sqrt{Var[r_w]} = \frac{1}{S(0)} \cdot \sqrt{Var[S(1)]} \] 433 | 434 | \subsubsection{Single Index Modell} 435 | \[\mu_i = \alpha_i + \beta_i \cdot \mu_I\] 436 | \[\sigma_i^2 = \beta_i^2 \cdot \sigma_I^2 + \tilde{\sigma}_{\epsilon_i}\] 437 | \[co(v\tilde{r}_i, \tilde{r_j}) = \beta_i \cdot \beta_j \cdot \sigma_I^2\] 438 | 439 | 440 | \subsection{Capital Asset Pricing Modell} 441 | \[\mu_w = r + \frac{\mu_M - r}{\sigma_M} \cdot \sigma_w = r + (\mu_M - r) \cdot \beta_j\] 442 | \[\beta_w = \frac{\sigma_w}{\sigma_M} = \frac{cov(r_w, r_M)}{\sigma_M^2} = \frac{\sigma_w \cdot \sigma_M \cdot \rho_{wM}}{\sigma_M^2} \] 443 | 444 | Aus negativer Korrelation folgt, dass \(\beta_w\) negativ ist, woraus wiederum folgt, dass \(\mu_w < r\). 445 | 446 | \subsubsection{Systematisches Risiko} 447 | CAPM ohne systematisches Risiko: \(\beta_{Pf} \stackrel{!}{=} 0\) 448 | 449 | 450 | \subsection{Arbitrage Pricing Model} 451 | 452 | \subsubsection{Rendite} 453 | \[\tilde{r}_i = \alpha_i + \beta_{i,1} \cdot \tilde{I}_1 + \alpha_2 + \beta_{i,2} \cdot \tilde{I}_2 + \dots + \alpha_i + \beta_{i,k} \cdot \tilde{I}_k + \tilde{\epsilon}_i\] 454 | 455 | 456 | \subsection{Performancemessung} 457 | 458 | \subsubsection{Sharp-Ratio} 459 | \[Sharp-Ratio = \frac{Mittlere~Ueberrendite}{Gesamtrisiko} = \frac{\overline{\mu} - r}{\sigma}\] 460 | 461 | \subsubsection{Jensen's Alpha} 462 | \[\alpha = (\overline{\mu} - r) - (\mu_M - r) \cdot \beta\] 463 | 464 | \subsubsection{Treynor-Maß} 465 | \[Treynor-Mass = \frac{Mittlere~Ueberrendite}{systematisches~Risiko} = \frac{\overline{\mu} - r}{\beta}\] 466 | 467 | 468 | \subsection{Anleihen} 469 | 470 | \subsubsection{Begriffe} 471 | \begin{itemize} 472 | \item Diskontfaktor: \(b(0,T)\) 473 | \item Effektivzins oder Kassazins: \(y(0,T)\) 474 | \item Arbitagefrei: Die Diskontstrukturkurve \(b(0,T)\) ist monoton fallend 475 | \end{itemize} 476 | 477 | \subsubsection{Nullkuponanleihe} 478 | \[Barwert = \frac{Nennwert}{(1+i)^t} \iff i = \sqrt[t]{\frac{Nennwert}{Barwert}} -1\] 479 | 480 | \subsubsection{Rendite einer Kuponanleihe} 481 | \[P(0) = \sum_{t=1}^{T} \frac{C}{(1+y(0,t))^t} + \frac{RZK}{(1+y(0,T))^T}\] 482 | 483 | \subsubsection{Berechnung Diskontfaktor} 484 | \[b(0,T) = \frac{1}{(1+y(0,T))^T}\] 485 | 486 | \subsubsection{Berechnung Swapsatz} 487 | Der Swapsatz entspricht dem Kupon einer zu pari notierenden Kuponanleihe. 488 | \[1 = \sum_{t=1}^{T} \frac{s(0,T)}{(1+y(0,t))^t} + \frac{1}{(1+y(0,T))^T}\] 489 | 490 | \subsubsection{Terminzinssatz} 491 | \[(1+f(0,S,T))^{T-S} = \frac{(1+y(0,T))^T}{(1+y(0,S))^S}\] 492 | 493 | 494 | \subsection{Duration} 495 | \[P(0) = \sum_{t=1}^{T} \frac{c \cdot 100}{(1+y(0,t))^t} + \frac{RZK}{(1+y(0,T))^T}\] 496 | 497 | \subsubsection{Macaulay Duration} 498 | \[D^{Mac} = \frac{\sum_{t=1}^{T} t \cdot \frac{c \cdot 100}{(1+z)^t} + \frac{T \cdot RZK}{(1+z)^T}}{P(0)} \] 499 | 500 | \subsubsection{EUR Duration} 501 | \[D^{EUR} = D^{Mac} \cdot \frac{1}{1+z} \cdot P(0) \] 502 | 503 | --------------------------------------------------------------------------------