misc

documents/Programmierparadigmen/Lambda.tex

@@ -101,14 +101,16 @@ Die Funktionsapplikation sei linksassoziativ. Es gilt also:
 
 Die Call-By-Name Auswertung wird in Funktionen verwendet.
 
+Haskell verwendet die Call-By-Name Auswertungsreihenfolge zusammen mit \enquote{sharing}. Dies nennt man Lazy Evaluation.
+\todo[inline]{Was ist sharing?}
+
 \begin{definition}[Call-By-Value]\xindex{Call-By-Value}%
     In der Call-By-Value Auswertung wird der linkeste Redex reduziert, der
     nicht von einem $\lambda$ umgeben ist und dessen Argument ein Wert ist.
 \end{definition}
 
 Die Call-By-Value Auswertungsreihenfolge wird in C und Java verwendet.
-Auch in Haskell werden arithmetische Ausdrücke in der Call-By-Name Auswertungsreihenfolge
-reduziert.
+Auch in Haskell werden arithmetische Ausdrücke in der Call-By-Name Auswertungsreihenfolge reduziert.
 
 \section{Church-Zahlen}
 Im $\lambda$-Kalkül lässt sich jeder mathematische Ausdruck darstellen, also 
@@ -120,52 +122,63 @@ darstellt. Dafür dürfen wir nur Variablen und $\lambda$ verwenden. Eine Mögli
 das zu machen sind die sog. \textit{Church-Zahlen}.
 
 Dabei ist die Idee, dass die Zahl angibt wie häufig eine Funktion $f$ auf eine
-Variable $x$ angewendet wird. Also:
+Variable $z$ angewendet wird. Also:
 \begin{itemize}
-    \item $0 := \lambda f~x. x$
-    \item $1 := \lambda f~x. f x$
-    \item $2 := \lambda f~x. f (f x)$
-    \item $3 := \lambda f~x. f (f (f x))$
+    \item $0 := \lambda f~z. z$
+    \item $1 := \lambda f~z. f z$
+    \item $2 := \lambda f~z. f (f z)$
+    \item $3 := \lambda f~z. f (f (f z))$
 \end{itemize}
 
 Auch die gewohnten Operationen lassen sich so darstellen.
 
 \begin{beispiel}[Nachfolger-Operation]
     \begin{align*}
-        \succ :&= \lambda n f z. f (n f x)\\
-        &= \lambda n. (\lambda f  (\lambda x f (n f x)))
+        \succ :&= \lambda n f z. f (n f z)\\
+               &= \lambda n. (\lambda f  (\lambda z f (n f z)))
     \end{align*}
     Dabei ist $n$ die Zahl. 
 
     Will man diese Funktion anwenden, sieht das wie folgt aus:
     \begin{align*}
-        \succ 1 &= (\lambda n f x. f(n f x)) 1\\
-                      &= (\lambda n f x. f(n f x)) \underbrace{(\lambda f~x. f x)}_{n}\\
-                      &= \lambda f x. f (\lambda f~x. f x) f x\\
-                      &= \lambda f x. f (f x)\\
+    \succ 1&= (\lambda n f z. f(n f z)) 1\\
+           &= (\lambda n f z. f(n f z)) \underbrace{(\lambda f~z. f z)}_{n}\\
+           &= \lambda f z. f (\lambda f~z. f z) f z\\
+           &= \lambda f z. f (f z)\\
            &= 2
     \end{align*}
 \end{beispiel}
 
 \begin{beispiel}[Addition]
     \begin{align*}
-        \text{+} : &= \lambda m n f x. m f (n f x)
+        \text{plus} &:= \lambda m n f z. m f (n f z)
     \end{align*}
     Dabei ist $m$ der erste Summand und $n$ der zweite Summand.
 \end{beispiel}
 
 \begin{beispiel}[Multiplikation]
-    %\[\text{\cdot} := \lambda m n.m(n f) \]
+    \begin{align*}
+     \text{times} :&= \lambda m n f. m~s~(n~f~z)\\
+                   &\overset{\eta}{=} \lambda m n f z. n (m s) z
+    \end{align*}
     Dabei ist $m$ der erste Faktor und $n$ der zweite Faktor.
 \end{beispiel}
 
 \begin{beispiel}[Potenz]
-    %\[\text{\cdot} := \text{TODO}\]
+    \begin{align*}
+     \text{exp} :&= \lambda b e. eb\\
+                   &\overset{\eta}{=} \lambda b e f z. e b f z
+    \end{align*}
     Dabei ist $b$ die Basis und $e$ der Exponent.
 \end{beispiel}
 
-\section{Weiteres}
+\section{Church-Booleans}
+\begin{definition}[Church-Booleans]\xindex{Church-Booleans}%
+    \texttt{True} wird zu $c_{\text{true}} := \lambda t. \lambda f. t$.\\
+    \texttt{False} wird zu $c_{\text{false}} := \lambda t. \lambda f. f$.
+\end{definition}
 
+\section{Weiteres}
 \begin{satz}[Satz von Curch-Rosser]
     Wenn zwei unterschiedliche Terme $a$ und $b$ äquivalent sind, d.h. mit Reduktionsschritten beliebiger Richtung ineinander transformiert werden können, dann gibt es einen weiteren Term $c$, zu dem sowohl $a$ als auch $b$ reduziert werden können.
 \end{satz}

documents/Programmierparadigmen/Prolog.tex

@@ -10,7 +10,7 @@ In Prolog definiert man Terme.
 \section{Erste Schritte}
 \subsection{Hello World}
 Speichere folgenden Quelltext als \texttt{hello-world.pl}:
-\inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=hello-world.hs]{prolog}{scripts/prolog/hello-world.hs}
+\inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=hello-world.hs]{prolog}{scripts/prolog/hello-world.pl}
 
 Kompiliere ihn mit \texttt{gplc hello-world.pl}. Es wird eine
 ausführbare Datei erzeugt.

documents/Programmierparadigmen/Symbolverzeichnis.tex

@@ -10,11 +10,25 @@ $\emptyset\;\;\;$ Leere Menge\\
 $\epsilon\;\;\;$ Das leere Wort\\
 $\alpha, \beta\;\;\;$ Reguläre Ausdrücke\\
 $L(\alpha)\;\;\;$ Die durch $\alpha$ beschriebene Sprache\\
-$L(\alpha | \beta) = L(\alpha) \cup L(\beta)$\\
-$L(\alpha \cdot \beta) = L(\alpha) \cdot L(\beta)$\\
-$\alpha^+ = L(\alpha)^+$ TODO: Was ist $L(\alpha)^+$\\
-$\alpha^* = L(\alpha)^*$ TODO: Was ist $L(\alpha)^*$\\
+$\begin{aligned}[t]
+    L(\alpha | \beta)    &= L(\alpha) \cup L(\beta)\\
+    L(\alpha \cdot \beta)&= L(\alpha) \cdot L(\beta)
+\end{aligned}$\\
+$L^0 := \Set{\varepsilon}\;\;\;$ Die leere Sprache\\
+$L^{n+1} := L^n \circ L \text{ für } n \in \mdn_0\;\;\;$ Potenz einer Sprache\\
+$\begin{aligned}[t]
+    \alpha^+ &=& L(\alpha)^+ &=& \bigcup_{i \in \mdn} L(\alpha)^i\\
+    \alpha^* &=& L(\alpha)^* &=& \bigcup_{i \in \mdn_0} L(\alpha)^i
+\end{aligned}$
+
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Reguläre Ausdrücke                                                %
+% Logik                                                             %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section*{Logik}
+$\mathcal{M} \models \varphi\;\;\;$ Im Modell $\mathcal{M}$ gilt das Prädikat $\varphi$.\\
+$\psi \vdash \varphi\;\;\;$ Die Formel $\varphi$ kann aus der Menge der Formeln $\psi$ hergeleitet werden.\\
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Weiteres                                                          %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\section*{Weiteres}
 $\bot\;\;\;$ Bottom\\

documents/Programmierparadigmen/Vorwort.tex

@@ -24,10 +24,6 @@ Anregungen, Verbesserungsvorschläge und Ergänzungen können per
 Pull-Request gemacht werden oder mir per Email an info@martin-thoma.de
 geschickt werden.
 
-\section*{Was ist Programmierparadigmen?}
-
-TODO
-
 \section*{Erforderliche Vorkenntnisse}
 Grundlegende Kenntnisse vom Programmieren, insbesondere mit Java,
 wie sie am KIT in \enquote{Programmieren} vermittelt werden, werden

documents/Programmierparadigmen/X10.tex

@@ -1,7 +1,22 @@
-\chapter{X10}
-\index{X10|(}
+%!TEX root = Programmierparadigmen.tex
+\chapter{X10}\index{X10|(}%
+X10 ist eine objektorientierte Programmiersprache, die 2004 bei IBM entwickelt
+wurde.
+
+\section{Erste Schritte}
+Als erstes sollte man x10 von \url{http://x10-lang.org/x10-development/building-x10-from-source.html?id=248} herunterladen.
+
+Dann kann man die bin/x10c++ zum erstellen von ausführbaren Dateien nutzen.
+Der Befehl \texttt{x10c++ hello-world.x10} erstellt eine ausführbare Datei namens
+\texttt{a.out}.
+
+\inputminted[numbersep=5pt, tabsize=4, frame=lines, label=hello-world.x10]{cpp}{scripts/x10/hello-world.x10}
+
 \section{Syntax}
 \section{Beispiele}
 
+\section{Weitere Informationen}
+\begin{itemize}
+    \item \url{http://x10-lang.org/}
+\end{itemize}
 \index{X10|)}
-

documents/Programmierparadigmen/scripts/x10/hello-whole-world.x10

@@ -0,0 +1,15 @@
+import x10.io.Console;
+
+class HelloWholeWorld {
+    public static def main(args:Rail[String]):void {
+        if (args.size < 1) {
+            Console.OUT.println("Usage: HelloWholeWorld message");
+            return;
+        }
+
+        finish for (p in Place.places()) {
+            at (p) async Console.OUT.println(here+" says hello and "+args(0));
+        }
+        Console.OUT.println("Goodbye");
+    }
+}

documents/Programmierparadigmen/scripts/x10/hello-world.x10

@@ -0,0 +1,6 @@
+// file HelloWorld.x10
+public class HelloWorld {
+    public static def main(args: Array[String](1)){
+        x10.io.Console.OUT.println("Hello, World");
+    }
+}