implementatie functies in Clean

diff --git a/appendix.tex b/appendix.tex
new file mode 100644 (file)
index 0000000..3bacb77
--- /dev/null
+++ b/appendix.tex
@@ -0,0 +1 @@
+\lstinputlisting[language=Clean, lastline=100]{functions.icl}
\ No newline at end of file

diff --git a/functions.icl b/functions.icl
new file mode 100644 (file)
index 0000000..8250323
--- /dev/null
+++ b/functions.icl
@@ -0,0 +1,122 @@
+implementation module roll
+
+import StdInt, StdList
+
+d :: [Int] -> [Int]
+d [] = []
+d [a:rest] = rest
+
+e :: [Int] Int -> [Int]
+e [] a = [a]
+e [b] a = [a] ++ [b]
+
+add :: [Int] -> [Int]
+add [] = []
+add [a] = [a]
+add [a:b:rest] = [b+a:rest]
+
+sub :: [Int] -> [Int]
+sub [] = []
+sub [a] = [a]
+sub [a:b:rest] = [b-a:rest]
+
+mul :: [Int] -> [Int]
+mul [] = []
+mul [a] = [a]
+mul [a:b:rest] = [b*a:rest]
+
+div :: [Int] -> [Int]
+div [] = []
+div [a] = [a]
+div [a:b:rest] = [b/a:rest]
+
+modc :: [Int] -> [Int]
+modc[] = []
+modc[a] = [a]
+modc[a:b:rest] = [modulo b a:rest]
+
+dup :: [Int] -> [Int]
+dup[] = []
+dup[a:rest] = [a:a:rest]
+
+notc :: [Int] -> [Int]
+notc[] = []
+notc[0:rest] = [1:rest]
+notc[_:rest] = [0:rest]
+
+gre :: [Int] -> [Int]
+gre[] = []
+gre[a] = [a]
+gre[a:b:rest]
+|a >= b = [0:rest]
+|otherwise = [1:rest]
+
+roll :: [Int] -> [Int]
+roll [] = []
+roll [a] = [a]
+roll [a:b:rest]
+|modulo a b == 0 = rest
+|b <= 0 = rest
+|b > length rest = rest
+|a == 1 = roll1 [b:rest]
+|a > 0 = roll ([a-1] ++ [b] ++ roll1 [b:rest])
+|a < 0 = roll ([modulo a b] ++ [b:rest])
+
+pointer :: [Int] -> [Int]
+pointer [] = []
+pointer [a:rest] = rest
+
+//outnum_s :: stack_output  stack -> stack_output
+outnum_s :: [Int] [Int] -> [Int]
+outnum_s _ [] = []
+outnum_s _ [a:rest] = rest
+
+outnum_so :: [Int] [Int] -> [Int]
+outnum_so so [] = so
+outnum_so so [a:rest] = add_to_s a so
+
+//innum_s :: stack_input  stack -> stack
+innum_s :: [Int] [Int] -> [Int]
+innum_s [] _ = []
+innum_s [a:rest] s = add_to_s a s
+
+innum_si :: [Int] [Int] -> [Int]
+innum_si [] s = []
+innum_si [a:rest] s = rest
+
+//help functions
+roll1 :: [Int] -> [Int]
+roll1 [1:rest] = rest
+roll1 [b:c:d:rest] = [d] ++ roll1[b-1:c:rest]
+
+modulo :: Int Int -> Int
+modulo a b
+|a<0 = modulo (a+b) b
+|a<b = a
+|otherwise = modulo (a-b) b
+
+add_to_s :: a [a] -> [a]
+add_to_s a [] = [a]
+add_to_s a b = b ++ [a]
+
+x = 5
+y = 1
+stack = []
+so = []
+si = []
+
+Start = start51
+
+start21 = (notc(gre(sub(push 1(push 1(notc(sub(push 1(roll(push 1(push 3(dup(roll(push 1(push 2[2,1])))))))))))))))
+start22 = roll(push 1(push 2(pop(roll(push 2(push 3(sub(push 1(roll(push 1(push 3(dup(roll(push 1(push 2(pop(roll(push 1(push 2(mul(roll(push 1(push 4(dup(roll(push 2(push 3(dup[1,2]))))))))))))))))))))))))))))
+start23 = pointer(notc(gre(sub(push 1(push 1(notc(sub(push 1(roll(push 1(push 3(dup(roll(push 1(push 2(push 1 (push 2 stack)))))))))))))))))
+
+start51 = (notc(gre(sub(push 1(push 1(notc(sub(push 1(roll(push 1(push 3(dup(roll(push 1(push 2[120,1])))))))))))))))
+start52 = roll(push 1(push 2(pop(roll(push 2(push 3(sub(push 1(roll(push 1(push 3(dup(roll(push 1(push 2(pop(roll(push 1(push 2(mul(roll(push 1(push 4(dup(roll(push 2(push 3(dup[60,2]))))))))))))))))))))))))))))
+start53 = pointer(notc(gre(sub(push 1(push 1(notc(sub(push 1(roll(push 1(push 3(dup(roll(push 1(push 2[60,2])))))))))))))))
+start54 = roll(push 1(push 2(pop(roll(push 2(push 3(sub(push 1(roll(push 1(push 3(dup(roll(push 1(push 2(pop(roll(push 1(push 2(mul(roll(push 1(push 4(dup(roll(push 2(push 3(dup[20,3]))))))))))))))))))))))))))))
+start55 = pointer(notc(gre(sub(push 1(push 1(notc(sub(push 1(roll(push 1(push 3(dup(roll(push 1(push 2[20,3])))))))))))))))
+start56 = roll(push 1(push 2(pop(roll(push 2(push 3(sub(push 1(roll(push 1(push 3(dup(roll(push 1(push 2(pop(roll(push 1(push 2(mul(roll(push 1(push 4(dup(roll(push 2(push 3(dup[5,4]))))))))))))))))))))))))))))
+start57 = pointer(notc(gre(sub(push 1(push 1(notc(sub(push 1(roll(push 1(push 3(dup(roll(push 1(push 2[5,4])))))))))))))))
+start58 = roll(push 1(push 2(pop(roll(push 2(push 3(sub(push 1(roll(push 1(push 3(dup(roll(push 1(push 2(pop(roll(push 1(push 2(mul(roll(push 1(push 4(dup(roll(push 2(push 3(dup[1,5]))))))))))))))))))))))))))))
+start59 = pointer(notc(gre(sub(push 1(push 1(notc(sub(push 1(roll(push 1(push 3(dup(roll(push 1(push 2(push y (push x stack)))))))))))))))))

diff --git a/project.tex b/project.tex
index 1b0c600..85110fd 100644 (file)
--- a/project.tex
+++ b/project.tex
@@ -71,4 +71,7 @@
 \section{Planning}
 \input{planning.tex}
 
 \section{Planning}
 \input{planning.tex}
 

+\section{Appendix}
+\input{appendix.tex}
+

 \end{document}
 \end{document}

diff --git a/semantics.tex b/semantics.tex
index 5ab8dc4..dfa4fc7 100644 (file)
--- a/semantics.tex
+++ b/semantics.tex
@@ -18,111 +18,101 @@ op een niet terminerende transitie.\\
 
 \subsection{Semantiekbeschrijving}
 
 
 \subsection{Semantiekbeschrijving}
 

+Om de semantiekregels te kunnen beschrijven maken we gebruik van hulpfuncties. Hieronder staat het type van de functies en een korte beschrijving.
+De implementatie van deze functies staat in de appendix bij het aangegeven regelnummer.\\
+
+delete functie (d, r. 5):\\

 Om het bovenste element van een stack weg te kunnen gooien gebruiken we de volgende 
 functie:\\
 $$\mathcal{D} : Stack \rightarrow Stack$$
 Om het bovenste element van een stack weg te kunnen gooien gebruiken we de volgende 
 functie:\\
 $$\mathcal{D} : Stack \rightarrow Stack$$

-$$\mathcal{D} [\:] = [\:]$$
-$$\mathcal{D} [a:rest] = [rest] $$

 Deze functie haalt het bovenste element van de stack en gooit deze weg.\\
 
 Deze functie haalt het bovenste element van de stack en gooit deze weg.\\
 

+extend functie (e, r. 9):\\

 Om een stack uit te kunnen breiden met een element gebruiken we de volgende 
 functie:\\
 $$\mathcal{E} : Stack\rightarrow (\mathbb{Z} \rightarrow Stack)$$\\
 Deze functie neemt een stack en een integer en voegt de integer toe bovenop de 
 stack.\\
 
 Om een stack uit te kunnen breiden met een element gebruiken we de volgende 
 functie:\\
 $$\mathcal{E} : Stack\rightarrow (\mathbb{Z} \rightarrow Stack)$$\\
 Deze functie neemt een stack en een integer en voegt de integer toe bovenop de 
 stack.\\
 

+add functie (add, r. 13):\\

 Om de bovenste twee elementen van een stack op te tellen gebruiken we de volgende 
 functie:\\
 $$\mathcal{ADD} : Stack \rightarrow Stack$$
 Om de bovenste twee elementen van een stack op te tellen gebruiken we de volgende 
 functie:\\
 $$\mathcal{ADD} : Stack \rightarrow Stack$$

-$$\mathcal{ADD} [\:] = [\:]$$
-$$\mathcal{ADD} [a] = [a] $$
-$$\mathcal{ADD} [a:b:rest] = [b+a:rest] $$\\

 Deze functie haalt de bovenste twee waarden van de stack, telt ze bij elkaar op, en stopt 
 het resultaat bovenop de stack.\\
 
 Deze functie haalt de bovenste twee waarden van de stack, telt ze bij elkaar op, en stopt 
 het resultaat bovenop de stack.\\
 

+subtract functie (sub, r. 18)\\

 Om de bovenste twee elementen van een stack van elkaar af te trekken gebruiken we 
 de volgende functie:\\
 $$\mathcal{SUB} : Stack \rightarrow Stack$$
 Om de bovenste twee elementen van een stack van elkaar af te trekken gebruiken we 
 de volgende functie:\\
 $$\mathcal{SUB} : Stack \rightarrow Stack$$

-$$\mathcal{SUB} [\:] = [\:]$$
-$$\mathcal{SUB} [a] = [a] $$
-$$\mathcal{SUB} [a:b:rest] = [b-a:rest] $$\\

 Deze functie haalt de bovenste twee elementen van de stack, trekt de bovenste 
 Deze functie haalt de bovenste twee elementen van de stack, trekt de bovenste 

-waarde van de tweede bovenste waarde af, en stopt het resultaat bovenop de stack.
+waarde van de tweede bovenste waarde af, en stopt het resultaat bovenop de stack.\\

 
 

+multiply functie (mul, r. 23):\\

 Om de bovenste twee elementen van een stack te vermenigvuldigen gebruiken we de 
 volgende functie:\\
 $$\mathcal{MUL} : Stack \rightarrow Stack$$
 Om de bovenste twee elementen van een stack te vermenigvuldigen gebruiken we de 
 volgende functie:\\
 $$\mathcal{MUL} : Stack \rightarrow Stack$$

-$$\mathcal{MUL} [\:] = [\:]$$
-$$\mathcal{MUL} [a] = [a] $$
-$$\mathcal{MUL} [a:b:rest] = [b*a:rest] $$\\

 Deze functie haalt de bovenste twee elementen van de stack, vermenigvuldigt ze, 
 en stopt het resultaat bovenop de stack.\\
 
 Deze functie haalt de bovenste twee elementen van de stack, vermenigvuldigt ze, 
 en stopt het resultaat bovenop de stack.\\
 

+division functie (div, r. 28):\\

 Om de geheeltallige deling van de bovenste twee elementen van de stack bovenop de 
 stack te krijgen gebruiken we de volgende functie:\\
 $$\mathcal{DIV} : Stack \rightarrow Stack$$
 Om de geheeltallige deling van de bovenste twee elementen van de stack bovenop de 
 stack te krijgen gebruiken we de volgende functie:\\
 $$\mathcal{DIV} : Stack \rightarrow Stack$$

-$$\mathcal{DIV} [\:] = [\:]$$
-$$\mathcal{DIV} [a] = [a] $$
-$$\mathcal{DIV} [a:b:rest] = [b/a:rest] $$\\

 Deze functie haalt de bovenste twee elementen van de stack, berekent de 
 geheeltallige deling van de tweede bovenste waarde door de bovenste waarde, 
 en stopt het resultaat bovenop de stack.\\
 
 Deze functie haalt de bovenste twee elementen van de stack, berekent de 
 geheeltallige deling van de tweede bovenste waarde door de bovenste waarde, 
 en stopt het resultaat bovenop de stack.\\
 

-Om    gebruiken we de
-volgende functie:\\
+modulo functie (modc, r. 33):\\
+Om  de tweede bovenste waarde modulo de bovenste waarde te berekenen 
+gebruiken we de volgende functie:\\

 $$\mathcal{MOD} : Stack \rightarrow Stack$$
 $$\mathcal{MOD} : Stack \rightarrow Stack$$

-$$\mathcal{MOD} [\:] = [\:]$$
-$$\mathcal{MOD} [a] = [a] $$
-$$\mathcal{MOD} [a:b:rest] = [b \: mod \: a:rest] $$\\
-Deze functie haalt de bovenste twee elementen van de stack, berekent het resultaat van de tweede bovenste 
-waarde modulo de bovenste waarde, en stopt dit bovenop de stack.\\
+Deze functie haalt de bovenste twee elementen van de stack, berekent het 
+resultaat van de tweede bovenste waarde modulo de bovenste waarde, en 
+stopt dit bovenop de stack.\\

 
 

+duplicate functie (dup, r. 38):\\

 Om het bovenste element van een stack te dupliceren gebruiken we de 
 volgende functie:\\
 $$\mathcal{DUP} : Stack \rightarrow Stack$$
 Om het bovenste element van een stack te dupliceren gebruiken we de 
 volgende functie:\\
 $$\mathcal{DUP} : Stack \rightarrow Stack$$

-$$\mathcal{DUP} [\:] = [\:]$$
-$$\mathcal{DUP} [a:rest] = [a:a:rest] $$\\
-Deze functie haalt stopt een kopie van de bovenste waarde bovenop de stack.\\
+Deze functie haalt de bovenste waarde van de stack en stopt een kopie 
+en de bovenste waarde bovenop de stack.\\

 
 

-Om de   gebruiken we de 
+not functie (notc, r. 42):\\
+Om de not van de bovenste waarde te berekenen gebruiken we de 

 volgende functie:\\
 volgende functie:\\

-$$\mathcal{NOT} : Stack \rightarrow Stack$$
-$$\mathcal{NOT} [\:] = [\:]$$
-$$\mathcal{NOT} [0:rest] = [1:rest]$$
-$$\mathcal{NOT} [\_:rest] = [0:rest] $$\\
-
+$$\mathcal{NOT} : Stack \rightarrow Stack$$\\

 Deze functie neemt het bovenste element van de stack en stopt 0 bovenaan de 
 stack als deze waarde niet gelijk is aan 0 en 1 als deze waarde gelijk is aan 0.\\
 
 Deze functie neemt het bovenste element van de stack en stopt 0 bovenaan de 
 stack als deze waarde niet gelijk is aan 0 en 1 als deze waarde gelijk is aan 0.\\
 

-Om   gebruiken we de 
-volgende functie:\\
-$$\mathcal{GRE} : Stack \rightarrow Stack$$
-$$\mathcal{GRE} [\:] = [\:]$$
-$$\mathcal{GRE} [a] = [a] $$
-$$\mathcal{GRE} [a:b:rest]$$
-$$\qquad \qquad | \: a \geq b =  [0:rest]$$
-$$\qquad \qquad | \: a < b =  [1:rest]$$\\
-
-$$\mathcal{ROLL} : Stack \rightarrow Stack$$
-$$\mathcal{ROLL} [\:] = [\:]$$
-$$\mathcal{ROLL} [a] = [a] $$
-$$\mathcal{ROLL} [a:b:rest]$$
-$$\qquad \qquad | modulo \: a \: b == 0 = rest$$
-$$\qquad \qquad | b <= 0 = rest$$
-$$\qquad \qquad | b > length rest = rest$$
-$$\qquad \qquad | a == 1 = roll1 [b:rest]$$
-$$\qquad \qquad | a > 0 = roll([a-1] ++ [b] ++ roll1 [b:rest]$$
-$$\qquad \qquad | a < 0 = roll(modulo \: a \: b] ++ [b:rest])$$
-
-$$\mathcal{ROLL}1 : Stack \rightarrow Stack$$
-$$\mathcal{ROLL}1 [1:rest] = [rest]$$
-$$\mathcal{ROLL}1 [b:c:d:rest] = [d] ++ \mathcal{ROLL}1 [b-1:c:rest]$$
-
-
+greater functie (gre, r. 47):\\
+Om kijken of de tweede bovenste waarde groter is dan de bovenste waarde 
+gebruiken we de volgende functie:\\
+$$\mathcal{GRE} : Stack \rightarrow Stack$$\\
+Deze functie haalt de bovenste twee waarden van de stack en stopt een 1 bovenop 
+de stack als de tweede bovenste waarde groter is dan de bovenste waarde. Anders 
+word een 0 bovenop de stack gestopt.\\
+
+roll functie (roll, r. 54):\\
+Om de stack te rollen gebruiken we de volgende functie:\\
+$$\mathcal{ROLL} : Stack \rightarrow Stack$$\\

 Deze functie haalt de bovenste twee elementen van de stack en stopt 1 bovenop 
 de stack als het tweede bovenste element een hogere waarde heeft als dat van het 
 bovenste element. Anders word 1 bovenop de stack gestopt.\\ 
 
 Deze functie haalt de bovenste twee elementen van de stack en stopt 1 bovenop 
 de stack als het tweede bovenste element een hogere waarde heeft als dat van het 
 bovenste element. Anders word 1 bovenop de stack gestopt.\\ 
 

+pointer functie (pointer, r. 65):\\
+
+out number functie (outnum, r. 74):\\
+
+in number functie (innum, r. 83):\\
+
+
+
+
+
+(switch, outchar, inchar)\\
+
+

 Met behulp van deze gedefinieerde functies kunnen we nu de volgende semantiekregels opstellen:\\
 
 $
 Met behulp van deze gedefinieerde functies kunnen we nu de volgende semantiekregels opstellen:\\
 
 $


@@ -153,22 +143,28 @@ $
 {[greater_{sos}]} \qquad
 \langle greater, s_i, s_o, s\rangle \Rightarrow
 \langle s_i, s_o, \mathcal{GRE}(s)\rangle\\
 {[greater_{sos}]} \qquad
 \langle greater, s_i, s_o, s\rangle \Rightarrow
 \langle s_i, s_o, \mathcal{GRE}(s)\rangle\\

+{[pointer_{sos}]} \qquad
+\langle pointer, s_i, s_o, s\rangle \Rightarrow
+\langle s_i, s_o, \mathcal{D}(s)\rangle\\

 {[push_{sos}]} \qquad
 \langle push \: n, s_i, s_o, s\rangle \Rightarrow
 \langle s_i, s_o, \mathcal{E}(n,s)\rangle\\
 {[roll_{sos}]} \qquad
 \langle roll, s_i, s_o, s\rangle \Rightarrow
 \langle s_i, s_o, \mathcal{ROLL}(s)\rangle\\
 {[push_{sos}]} \qquad
 \langle push \: n, s_i, s_o, s\rangle \Rightarrow
 \langle s_i, s_o, \mathcal{E}(n,s)\rangle\\
 {[roll_{sos}]} \qquad
 \langle roll, s_i, s_o, s\rangle \Rightarrow
 \langle s_i, s_o, \mathcal{ROLL}(s)\rangle\\

-{[inchar_{sos}]} \qquad
-\langle inchar, s_i, s_o, s\rangle \Rightarrow
-\langle s_i, s_o, s\rangle\\

 {[innum_{sos}]} \qquad
 \langle innum, s_i, s_o, s\rangle \Rightarrow
 {[innum_{sos}]} \qquad
 \langle innum, s_i, s_o, s\rangle \Rightarrow

+\langle \mathcal{INN_{SI}}(s_i), s_o, \mathcal{INN_S}(s)\rangle\\
+{[outnum_{sos}]} \qquad
+\langle outnum, s_i, s_o, s\rangle \Rightarrow
+\langle s_i, \mathcal{OUTN_{SO}}(s_o),\mathcal{OUTN_S}(s)\rangle\\
+{[inchar_{sos}]} \qquad
+\langle inchar, s_i, s_o, s\rangle \Rightarrow

 \langle s_i, s_o, s\rangle\\
 {[outchar_{sos}]} \qquad
 \langle outchar, s_i, s_o, s\rangle \Rightarrow
 \langle s_i, s_o, s\rangle\\
 \langle s_i, s_o, s\rangle\\
 {[outchar_{sos}]} \qquad
 \langle outchar, s_i, s_o, s\rangle \Rightarrow
 \langle s_i, s_o, s\rangle\\

-{[outnum_{sos}]} \qquad
-\langle outnum, s_i, s_o, s\rangle \Rightarrow
+{[switch_{sos}]} \qquad
+\langle switch, s_i, s_o, s\rangle \Rightarrow

 \langle s_i, s_o, s\rangle\\
 $
 \langle s_i, s_o, s\rangle\\
 $