Fehler korrigiert - danke an Vincent Schnitzbauer

documents/Programmierparadigmen/C.tex

@@ -15,7 +15,7 @@ definiert. Die wichtigsten davon sind:
 
 \section{Datentypen}\xindex{Datentypen}
 Die grundlegenden C-Datentypen sind
-\begin{table}[htp]
+\begin{table}[H]
     \centering
     \begin{tabular}{|l|l|}
     \hline
@@ -78,7 +78,7 @@ In C gibt es keinen direkten Support für Booleans.
 \section{Syntax}
 
 \subsection{Logische Operatoren}
-\begin{table}[h]
+\begin{table}[H]
     \centering 
     \begin{tabular}{CCCC}
     UND    & ODER     & Wahr  & Falsch \\ \hline\hline

documents/Programmierparadigmen/Haskell.tex

@@ -64,7 +64,7 @@ Zu lesen ist die Deklaration wie folgt:
 
 \todo[inline]{Gibt es Funktionsdeklarationen, die bis auf Wechsel des Namens und der Reihenfolge äquivalent sind?}
 
-\subsection{if / else}\xindex{Haskell!if@\texttt{if}}
+\subsection{if / else}\xindex{Haskell!if@\texttt{if}}%
 Das folgende Beispiel definiert den Binomialkoeffizienten (vgl. \cref{bsp:binomialkoeffizient}):
 
 \inputminted[numbersep=5pt, tabsize=4]{haskell}{scripts/haskell/binomialkoeffizient.hs}

documents/Programmierparadigmen/MPI.tex

@@ -109,7 +109,7 @@ Empfangen einer Nachricht (blockierend)
 \inputminted[numbersep=5pt, tabsize=4]{c}{scripts/mpi/mpi-reduce.c}
 Führt eine globale Operation \textbf{op} aus; der Prozeß \enquote{root} erhält das Resultat.
 
-\textbf{Parameter}
+\textbf{Input-Parameter}
 \begin{itemize}
     \item \textbf{sendbuf}: Startadresse des Sendepuffers
     \item \textbf{count}: Anzahl der Elemente im Sendepuffer
@@ -118,13 +118,18 @@ Führt eine globale Operation \textbf{op} aus; der Prozeß \enquote{root} erhäl
     \item \textbf{root}: Rang des Root-Prozesses in comm, der das Ergebnis haben soll
     \item \textbf{comm}: Kommunikator (handle)
 \end{itemize}
+
+\textbf{Output-Parameter}
+\begin{itemize}
+    \item \textbf{recvbuf}: Adresse des Puffers, in den das Ergebnis abgelegt wird (nur für \texttt{root} signifikant)
+\end{itemize}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \goodbreak
 \rule{\textwidth}{0.4pt}\xindex{MPI\_Alltoall@\texttt{MPI\_Alltoall}}%
 \inputminted[numbersep=5pt, tabsize=4]{c}{scripts/mpi/mpi-alltoall.c}
 Teilt Daten von jedem Prozeß einer Gruppe an alle anderen auf.
 
-\textbf{Parameter}
+\textbf{Input-Parameter}
 \begin{itemize}
     \item \textbf{sendbuf}: Startadresse des Sendepuffers 
     \item \textbf{sendcount}: Anzahl der Elemente im Sendepuffer
@@ -134,6 +139,11 @@ Teilt Daten von jedem Prozeß einer Gruppe an alle anderen auf.
     \item \textbf{comm}: Kommunikator (handle)
 \end{itemize}
 
+\textbf{Output-Parameter}
+\begin{itemize}
+    \item \textbf{recvbuf}: Anfangsadresse des Empfangspuffers
+\end{itemize}
+
 \textbf{Beispiel}
 \inputminted[numbersep=5pt, tabsize=4]{c}{scripts/mpi/mpi-alltoall-example.c}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -157,9 +167,9 @@ angegebenen Kommunikators.
 \inputminted[numbersep=5pt, tabsize=4]{c}{scripts/mpi/mpi-scatter.c}
 Verteilt Daten vom Prozess \texttt{root} unter alle anderen Prozesse in der Gruppe, so daß, soweit möglich, alle Prozesse gleich große Anteile erhalten.
 
-\textbf{Parameter}
+\textbf{Input-Parameter}
 \begin{itemize}
-    \item \textbf{sendbuf}: Anfangsadresse des Sendepuffers (Wert ist lediglich für 'root' signifikant) 
+    \item \textbf{sendbuf}: Anfangsadresse des Sendepuffers (Wert ist lediglich für \texttt{root} signifikant) 
     \item \textbf{sendcount}: Anzahl der Elemente, die jeder Prozeß geschickt bekommen soll (integer) 
     \item \textbf{sendtype}: Typ der Elemente in sendbuf (handle) (vgl. \cpageref{sec:MPI-Datatypes})
     \item \textbf{recvcount}: Anzahl der Elemente im Empfangspuffer. Meist ist es günstig, recvcount = sendcount zu wählen. 
@@ -167,6 +177,11 @@ Verteilt Daten vom Prozess \texttt{root} unter alle anderen Prozesse in der Grup
     \item \textbf{root}: Rang des Prozesses in comm, der die Daten versendet
     \item \textbf{comm}: Kommunikator (handle)
 \end{itemize}
+
+\textbf{Output-Parameter}
+\begin{itemize}
+    \item \textbf{recvbuf}: Adresse des Empfangsbuffers; auch \texttt{root} findet seinen Anteil an Daten nach der Operation dort
+\end{itemize}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \goodbreak
 \rule{\textwidth}{0.4pt}\xindex{MPI\_Allgather@\texttt{MPI\_Allgather}}%
@@ -196,17 +211,22 @@ Sammelt Daten, die in einer Prozeßgruppe verteilt sind, ein und verteilt das Re
 \inputminted[numbersep=5pt, tabsize=4]{c}{scripts/mpi/mpi-gather.c}
 Sammelt Daten, die in einer Prozeßgruppe verteilt sind, ein.
 
-\textbf{Parameter}
+\textbf{Input-Parameter}
 \begin{itemize}
-    \item \textbf{sendbuf}: Startadresse des Sendepuffers 
+    \item \textbf{sendbuf}: Startadresse des Sendepuffers
     \item \textbf{sendcount}: Anzahl der Elemente im Sendepuffer
-    \item \textbf{sendtype}: Datentyp der Elemente des Sendepuffers (handle) 
-    \item \textbf{recvcount}: Anzahl der Elemente, die jeder einzelne Prozeß sendet (nur für 'root' signifikant) 
-    \item \textbf{recvtype}: Typ der Elemente im Empfangspuffer (handle) (nur für 'root' signifikant) (vgl. \cpageref{sec:MPI-Datatypes})
+    \item \textbf{sendtype}: Datentyp der Elemente des Sendepuffers (handle)
+    \item \textbf{recvcount}: Anzahl der Elemente, die jeder einzelne Prozeß sendet (nur für \texttt{root} signifikant) 
+    \item \textbf{recvtype}: Typ der Elemente im Empfangspuffer (handle) (nur für \texttt{root} signifikant) (vgl. \cpageref{sec:MPI-Datatypes})
     \item \textbf{root}: Rang des empfangenden Prozesses in \texttt{comm}
     \item \textbf{comm}: Kommunikator (handle)
 \end{itemize}
 
+\textbf{Output-Parameter}
+\begin{itemize}
+    \item \textbf{recvbuf}: Adresse des Empfangspuffers (nur für \texttt{root} signifikant)
+\end{itemize}
+
 \textbf{Beispiel}
 \inputminted[numbersep=5pt, tabsize=4]{c}{scripts/mpi/mpi-reduce-example.c}
 

documents/Programmierparadigmen/Programmiertechniken.tex

@@ -3,7 +3,7 @@
 \section{Rekursion}
 \index{Rekursion|(}
 
-\begin{definition}[rekursive Funktion]\xindex{Funktion!rekursive}
+\begin{definition}[rekursive Funktion]\xindex{Funktion!rekursive}%
     Eine Funktion $f: X \rightarrow X$ heißt rekursiv definiert,
     wenn in der Definition der Funktion die Funktion selbst wieder
     steht.

documents/Programmierparadigmen/Prolog.tex

@@ -56,7 +56,7 @@ die beiden Terme bereits identisch sind.
 
 Weitere Informationen: \url{http://stackoverflow.com/a/8220315/562769}
 
-\subsection{! (Cut)}\xindex{"! (Cut, Prolog)}
+\subsection{! (Cut)}\xindex{"! (Cut, Prolog)}%
 Das \texttt{!} wird in Prolog als \textit{cut} bezeichnet. Ein Cut verhindert
 Backtracking nach dem cut.
 

documents/Programmierparadigmen/Scala.tex

@@ -115,8 +115,8 @@ Im Gegensatz zu anderen Objekten / Traits hat das Companion Object zugriff auf
 die Klasse.
 
 \section{actor}
-\begin{definition}[Aktor]\xindex{Aktor}\index{actor|see{Aktor}}
-    Ein \textit{Aktor} ist ein Prozess, der Nebenläufig zu anderen Aktoren
+\begin{definition}[Aktor]\xindex{Aktor}\index{actor|see{Aktor}}%
+    Ein \textit{Aktor} ist ein Prozess, der nebenläufig zu anderen Aktoren
     läuft. Er kommuniziert mit anderen Aktoren, indem er Nachrichten austauscht.
 \end{definition}
 

documents/Programmierparadigmen/Typinferenz.tex

@@ -58,15 +58,15 @@ Bei solchen Ableitungen sind häufig viele Typen möglich. So kann der Ausdruck
 \[\lambda x.\ 2\]
 folgenderweise typisiert werden:
 \begin{itemize}
-	\item $\vdash(\lambda x.\ 2): \text{bool} \rightarrow int$
-	\item $\vdash(\lambda x.\ 2): \text{int} \rightarrow int$
-	\item $\vdash(\lambda x.\ 2): \text{Char} \rightarrow int$
-	\item $\vdash(\lambda x.\ 2): \alpha \rightarrow int$
+	\item $\vdash(\lambda x.\ 2): \text{bool} \rightarrow \text{int}$
+	\item $\vdash(\lambda x.\ 2): \text{int} \rightarrow \text{int}$
+	\item $\vdash(\lambda x.\ 2): \text{Char} \rightarrow \text{int}$
+	\item $\vdash(\lambda x.\ 2): \alpha \rightarrow \text{int}$
 \end{itemize}
 
 In der letzten Typisierung stellt $\alpha$ einen beliebigen Typen dar.
 
-Wichtig ist , dass man sich von unten nach oben arbeitet.
+Wichtig ist, dass man sich von unten nach oben vorarbeitet.
 
 \begin{beispiel}[Typinferenz\footnotemark]
     Typisieren Sie den Term
@@ -90,6 +90,8 @@ Wichtig ist , dass man sich von unten nach oben arbeitet.
 			   &\\
 		\APP:  &\frac{\Gamma \vdash t_1: \tau_2 \rightarrow \tau\;\;\; \Gamma \vdash t_2: \tau_2}{\Gamma \vdash t_1 t_2: \tau} \\
 	\end{align*}
+
+    wobei $t_1, t_2$ immer $\lambda$-Terme bezeichnet.
 \end{definition}
 \footnotetext{WS 2013 / 2014, Folie 192}
 

documents/Programmierparadigmen/X10.tex

@@ -49,7 +49,7 @@ Eine Besonderheit sind sog. \textit{Constrianed types}\xindex{types!constrained}
 \inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/x10/constrained-type-example.x10}
 
 \subsection{Logische Operatoren}
-\begin{table}[h]
+\begin{table}[H]
     \centering 
     \begin{tabular}{CCCC}
     UND    & ODER     & Wahr  & Falsch \\ \hline\hline