--- a/cws/cw05.tex Thu Dec 06 13:15:28 2018 +0000
+++ b/cws/cw05.tex Thu Dec 06 13:52:50 2018 +0000
@@ -30,6 +30,54 @@
\DISCLAIMER{}
+\subsection*{Reference Implementation}
+
+As usual, this Scala assignment comes with a reference implementation in form of
+two \texttt{jar}-files. You can download them from KEATS. This allows you to run any
+test cases on your own computer. For example you can call Scala on the command line with the
+option \texttt{-cp bf.jar} and then query any function from the
+\texttt{bf.scala} template file. You have to
+prefix the calls with \texttt{CW10a} and \texttt{CW10b}, respectively. For example
+
+
+\begin{lstlisting}[language={},xleftmargin=1mm,numbers=none,basicstyle=\ttfamily\small]
+$ scala -cp bf.jar
+scala> import CW10a._
+scala> run(load_bff("sierpinski.bf"))
+ *
+ * *
+ * *
+ * * * *
+ * *
+ * * * *
+ * * * *
+ * * * * * * * *
+ * *
+ * * * *
+ * * * *
+ * * * * * * * *
+ * * * *
+ * * * * * * * *
+ * * * * * * * *
+ * * * * * * * * * * * * * * * *
+ * *
+ * * * *
+ * * * *
+ * * * * * * * *
+ * * * *
+ * * * * * * * *
+ * * * * * * * *
+ * * * * * * * * * * * * * * * *
+ * * * *
+ * * * * * * * *
+ * * * * * * * *
+ * * * * * * * * * * * * * * * *
+ * * * * * * * *
+ * * * * * * * * * * * * * * * *
+ * * * * * * * * * * * * * * * *
+* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+\end{lstlisting}%$
+
\subsection*{Part 1 (6 Marks)}
@@ -38,9 +86,10 @@
programming language. But remember, some serious companies have built
their business on
Scala.\footnote{\url{https://en.wikipedia.org/wiki/Scala_(programming_language)\#Companies}}
-And there are far, far more esoteric languages out there. One is
-called \emph{brainf***}. You are asked in this part to implement an
-interpreter and compiler for this language.
+I claim functional programming is not a fad. And there are far, far
+more esoteric languages out there. One is called \emph{brainf***}. You
+are asked in this part to implement an interpreter for
+this language.
Urban M\"uller developed brainf*** in 1993. A close relative of this
language was already introduced in 1964 by Corado B\"ohm, an Italian
@@ -52,7 +101,7 @@
be implemented in brainf***. It just takes a lot of determination and
quite a lot of memory resources. Some relatively sophisticated sample
programs in brainf*** are given in the file \texttt{bf.scala}, including
-a brainf*** program for the Sierpinski triangle and Mandelbot set.\bigskip
+a brainf*** program for the Sierpinski triangle and the Mandelbrot set.\bigskip
\noindent
As mentioned above, brainf*** has 8 single-character commands, namely
@@ -76,18 +125,18 @@
\begin{center}
\begin{verbatim}
- ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++
- ..+++.>>.<-.<.+++.------.--------.>>+.>++.
+ ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.++
+ +++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
\end{verbatim}
\end{center}
\noindent
-This one prints out Hello World\ldots{}obviously.
+This one prints out Hello World\ldots{}obviously ;o)
\subsubsection*{Tasks (file bf.scala)}
\begin{itemize}
-\item[(1)] Write a function that takes a file name as argument and
+\item[(1)] Write a function that takes a file name as an argument
and requests the corresponding file from disk. It returns the
content of the file as a String. If the file does not exists,
the function should return the empty string.\\
@@ -182,22 +231,22 @@
\hfill[2 Marks]
-\item[(4)] Write a recursive function \texttt{run} that executes a
+\item[(4)] Write a recursive function \texttt{compute} that runs a
brainf*** program. It takes a program, a program counter, a memory
pointer and a memory as arguments. If the program counter is outside
- the program string, the execution stops and \texttt{run} returns the
+ the program string, the execution stops and \texttt{compute} returns the
memory. If the program counter is inside the string, it reads the
corresponding character and updates the program counter \texttt{pc},
memory pointer \texttt{mp} and memory \texttt{mem} according to the
rules shown in Figure~\ref{comms}. It then calls recursively
- \texttt{run} with the updated data. The most convenient way to
- implement the rules in \texttt{run} is to use pattern-matching
- and calculating a triple consisting of the new \texttt{pc},
+ \texttt{compute} with the updated data. The most convenient way to
+ implement the brainf**k rules in Scala is to use pattern-matching
+ and to calculate a triple consisting of the updated \texttt{pc},
\texttt{mp} and \texttt{mem}.
- Write another function \texttt{start} that calls \texttt{run} with a
+ Write another function \texttt{run} that calls \texttt{compute} with a
given brainfu** program and memory, and the program counter and memory pointer
- set to~$0$. Like \texttt{run} it returns the memory after the execution
+ set to~$0$. Like \texttt{compute}, it returns the memory after the execution
of the program finishes. You can test your brainf**k interpreter with the
Sierpinski triangle or the Hello world programs (they seem to be particularly
useful for debugging purposes), or have a look at
@@ -208,7 +257,7 @@
\begin{figure}[p]
\begin{center}
- \begin{tabular}{|@{}p{0.8cm}|l|}
+ \begin{tabular}{|@{\hspace{0.5mm}}p{0.8cm}|l|}
\hline
\hfill\texttt{'>'} & \begin{tabular}[t]{@{}l@{\hspace{2mm}}l@{}}
$\bullet$ & $\texttt{pc} + 1$\\
@@ -266,7 +315,7 @@
\end{tabular}
\end{center}
\caption{The rules for how commands in the brainf*** language update the program counter \texttt{pc},
- memory pointer \texttt{mp} and memory \texttt{mem}.\label{comms}}
+ the memory pointer \texttt{mp} and the memory \texttt{mem}.\label{comms}}
\end{figure}
\end{itemize}\bigskip