meer faculteit

diff --git a/an_arit_expr.tex b/an_arit_expr.tex
index 1e15a60..a87fc92 100644 (file)
--- a/an_arit_expr.tex
+++ b/an_arit_expr.tex
@@ -40,8 +40,8 @@ operatoren bestaan die niet voorkomen in \textit{Piet} en deze moeten dus
 herschreven worden. De operatoren die herschreven worden zijn: $=, \leq,
 \wedge\\
 \begin{array}{ll}
-       a \wedge b      & a+b>1\\
-       a = b           & \neg(a-b>0)\\
+       a \wedge b      & a*b\\
+       a = b           & not(a-b)>0\\
        a \leq b        & \neg(a>b)
 \end{array}$\\
 \textbf{While} $3=2\wedge 3\leq 4$\\

diff --git a/an_faculteit.tex b/an_faculteit.tex
index eab5607..2bb5491 100644 (file)
--- a/an_faculteit.tex
+++ b/an_faculteit.tex
@@ -14,35 +14,66 @@ do (
 
 In \textit{Piet} ziet dit er als volgt uit...
 \begin{lstlisting}[title=Faculteit in \textit{Piet'}]
-push 5      // x is vanaf nu variabele 1
-push 1      // y is vanaf nu variabele 2
+push 5      // x:=5
+push 1      // y:=1
 
 MARKERING A:
-Un(1)       // variabele x wordt klaargezet
-push 1      // de waarde 1 wordt klaargezet
-sub         // subtractie om straks gelijkheid te kunnen bepalen
-push 1      // de waarde 1 word gepushed om 0 te maken
-dup         // de waarde 1 staat er nu twee keer op
-sub         // 0 staat op de stack om groterdan relatie te bepalen
-push 2      // klaarmaken om de bovenste twee te swappen
-push 1      // idem
-roll        // swappen
-gre         // als x>0 dan ligt 1 op de stack anders 0
-not         // als x=0 dan ligt 1 op de stack anders 0
-pointer     // als x=0 dan draait de DP niet en gaat het programma naar pad A
-            // als x$\neq$ dan draait de DP en gaat het programma naar pad B
+            // Un(2)
+            // $\neg$(x=1) $\equiv$ \neg(x-1)>0)
+
+
+            // x-1
+            // Twee waardes ervoor gepushed dus $n=n+2$
+            // Un(3)
+push 3      //
+push 1      //
+roll        //
+dup         //
+push 4      //
+push 1      //
+roll        //
+push 1      //
+sub         //
+not         // $\neg(x-1)$
+
+push 1      // zet $0$ op de stack
+push 1
+sub
+
+gre         // $\neg(x-1)>0$ oftewel x=1
+
+pointer     // als x=0 dan draait de DP niet en gaat het programma naar pad B
+            // als x$\neq$ dan draait de DP en gaat het programma naar pad A
 
 PAD A:
 skip        //een oneindig aantal witte blokken, y is nu x!
 
 PAD B:
-Bin(1, 2)   // x en y worden klaargezet om y opnieuw te assignen
-mul         // x*y ligt boven op de stack
-Ass(2)      // x*y wordt geassigned aan y
-Un(1)       // x wordt klaargezet
-push 1      // 1 wordt klaargezet
-sub         // x-1 ligt op de stack
-Ass(1)      // x-1 wordt geassigned aan x
+            // y:=y*x
+            // Bin(1, 2)
+dup         // Un(1)
+push 3      // Un(2+1)
+push 2      //
+roll        //
+dup         //
+push 5      //
+push 1      //
+roll        //
+mul         // x*y
+push 3      // Ass(2)
+push 2
+roll
+pop
+push 2
+push 1
+roll
+            // x:=x-1
+dup         // Un(1)
+push 1      // 
+sub         // x-1
+push 2      // Ass(1)
+push 1
+roll
+pop         
             // nu gaat het programma weer via een wit pad naar markering A
-
 \end{lstlisting}

diff --git a/an_variabelen.tex b/an_variabelen.tex
index 7c2ef97..b386acf 100644 (file)
--- a/an_variabelen.tex
+++ b/an_variabelen.tex
@@ -8,10 +8,14 @@ algorithmen op te kunnen rakelen. Binnen de algorithmen wordt $n$ gebruikt als
 diepte van de variabele(beginnende bij $1$) en $m$ als het aantal variabelen op
 de stack bij aanvang van het opvragen.
 
+\subsubsection{Unair vaste waarde}
+Bij het opvragen van een vaste waar
+$Get(n)$
+
 \subsubsection{Unair}
 Als er een operator uitgevoerd wordt die slechts \'e\'en waarde vraagt van de
 stack hoeft er slechts \'e\'en waarde boven aan de stack gezet te worden en dit
-gaat met de volgende operaties:\\
+gaat met de volgende operaties bij $n>1$:\\
 push $n$, push $n-1$, roll, dup, push $n+1$, push $1$, roll
 \begin{table}[H]
        \centering
@@ -32,8 +36,11 @@ push $n$, push $n-1$, roll, dup, push $n+1$, push $1$, roll
           &    &       &       &       &       & 3     &       \\\hline
        \end{tabular}
 \end{table}
+Voor $n=1$ voldoen de volgende operaties:\\
+dup\\
 Dit algorithme beschrijven we als $Un(n)$ voor later gebruik.
 
+
 \subsubsection{Binair}
 Als er een operator uitgevoerd wordt die twee waardes vraagt van de stack
 worden deze boven elkaar boven op de stack gekopieert met de volgende
@@ -69,7 +76,7 @@ werk omdat \textit{Piet} alle variabelen in een stack bewaard. Net als bij het
 opvragen hebben de variabelen een nummer in plaats van een naam. Bij een
 toewijzing wordt de waarde, $m$, bovenop de stack toegewezen aan de variabele
 met de diepte, $n$, gerekend zonder de waarde bovenop de stack mee te tellen.
-En dat gaat met de volgende operaties:\\
+En dat gaat met de volgende operaties voor $n>1$:\\
 push $m$, push $n+1$, push $n$, roll, pop, push $n$, push $1$, roll
 \begin{table}[H]
        \centering
@@ -91,6 +98,9 @@ push $m$, push $n+1$, push $n$, roll, pop, push $n$, push $1$, roll
        \end{tabular}
 \end{table}
 
+Voor $n=1$ voldoen de volgende operaties:\\
+push $2$, push $1$, roll, pop
+
 \begin{landscape}
 \subsubsection{Groot voorbeeld}
 We wijzen variabele $5$ de waarde van variabele $3$ $+$ variabele $2$ toe.