% !TEX program = xelatex
\documentclass{article}
\usepackage{../styles/style}
\usepackage{../styles/langs}
\usepackage{disclaimer}
\usepackage{tikz}
\usepackage{pgf}
\usepackage{pgfplots}
\usepackage{stackengine}
%% \usepackage{accents}
\newcommand\barbelow[1]{\stackunder[1.2pt]{#1}{\raisebox{-4mm}{\boldmath$\uparrow$}}}
\usepackage{ulem}

\begin{document}

% BF IDE
% https://www.microsoft.com/en-us/p/brainf-ck/9nblgggzhvq5
  
\section*{Core Part 3 (Scala, 3 Marks)}

\mbox{}\hfill\textit{``[Google’s MapReduce] abstraction is inspired by the}\\
\mbox{}\hfill\textit{map and reduce primitives present in Lisp and many}\\
\mbox{}\hfill\textit{other functional languages.''}\smallskip\\
\mbox{}\hfill\textit{ --- Dean and Ghemawat, who designed this concept at Google}
\bigskip

\IMPORTANTNONE{}

\noindent
Also note that the running time of each part will be restricted to a
maximum of 30 seconds on my laptop.  

\DISCLAIMER{}

\subsection*{Reference Implementation}

This Scala assignment comes with two reference implementations in
form of \texttt{jar}-files. 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
  postfix.jar} and then query any function from the
\texttt{postfix.scala} file (similarly for file \texttt{postfix2.scala}). As
usual you have to prefix the calls with \texttt{C3a} and
\texttt{C3b}, respectively.


\begin{lstlisting}[xleftmargin=1mm,numbers=none,basicstyle=\ttfamily\small]
$ scala -cp postfix.jar

scala> C3a.syard(C3a.split("( 5 + 7 ) * 2"))
val res0: C3a.Toks = List(5, 7, +, 2, *)
\end{lstlisting}%$


\subsection*{Hints}

\noindent
\textbf{For Core Part 3:} useful operations for determining
whether a string is a number are \texttt{.forall} and \texttt{.isDigit}.
One way to calculate the the power operation is to use \texttt{.pow}
on \texttt{BigInt}s, like \texttt{BigInt(n).pow(m).toInt}.
\bigskip


\subsection*{Core Part (3 Marks, files postfix.scala, postfix2.scala)}

The \emph{Shunting Yard Algorithm} has been developed by Edsger Dijkstra,
an influential computer scientist who developed many well-known
algorithms. This algorithm transforms the usual infix notation of
arithmetic expressions into the postfix notation, sometimes also
called reverse Polish notation.

Why on Earth do people use the postfix notation? It is much more
convenient to work with the usual infix notation for arithmetic
expressions. Most modern pocket calculators (as opposed to the ones used 20
years ago) understand infix notation. So why on Earth? \ldots{}Well,
many computers under the hood, even nowadays, use postfix notation
extensively. For example if you give to the Java compiler the
expression $1 + ((2 * 3) + (4 - 3))$, it will generate the Java Byte
code

\begin{lstlisting}[language=JVMIS,numbers=none]
ldc 1 
ldc 2 
ldc 3 
imul 
ldc 4 
ldc 3 
isub 
iadd 
iadd
\end{lstlisting}

\noindent
where the command \texttt{ldc} loads a constant onto the stack, and \texttt{imul},
\texttt{isub} and \texttt{iadd} are commands acting on the stack. Clearly this
is the arithmetic expression in postfix notation.\bigskip

\noindent
The shunting yard algorithm processes an input token list using an
operator stack and an output list. The input consists of numbers,
operators ($+$, $-$, $*$, $/$) and parentheses, and for the purpose of
the assignment we assume the input is always a well-formed expression
in infix notation.  The calculation in the shunting yard algorithm uses
information about the
precedences of the operators (given in the template file). The
algorithm processes the input token list as follows:

\begin{itemize}
\item If there is a number as input token, then this token is
  transferred directly to the output list. Then the rest of the input is
  processed.
\item If there is an operator as input token, then you need to check
  what is on top of the operator stack. If there are operators with
  a higher or equal precedence, these operators are first popped off
  from the stack and moved to the output list. Then the operator from the input
  is pushed onto the stack and the rest of the input is processed.
\item If the input is a left-parenthesis, you push it on to the stack
  and continue processing the input.
\item If the input is a right-parenthesis, then you pop off all operators
  from the stack to the output list until you reach the left-parenthesis.
  Then you discharge the $($ and $)$ from the input and stack, and continue
  processing the input list.
\item If the input is empty, then you move all remaining operators
  from the stack to the output list.  
\end{itemize}  

\subsubsection*{Tasks (file postfix.scala)}

\begin{itemize}
\item[(1)] Implement the shunting yard algorithm described above. The
  function, called \texttt{syard}, takes a list of tokens as first
  argument. The second and third arguments are the stack and output
  list represented as Scala lists. The most convenient way to
  implement this algorithm is to analyse what the input list, stack
  and output list look like in each step using pattern-matching. The
  algorithm transforms for example the input

  \[
  \texttt{List(3, +, 4, *, (, 2, -, 1, ))}
  \]

  into the postfix output

  \[
  \texttt{List(3, 4, 2, 1, -, *, +)}
  \]  
  
  You can assume the input list is always a  list representing
  a well-formed infix arithmetic expression.\hfill[1 Mark]

\item[(2)] Implement a compute function that takes a postfix expression
  as argument and evaluates it generating an integer as result. It uses a
  stack to evaluate the postfix expression. The operators $+$, $-$, $*$
  are as usual; $/$ is division on integers, for example $7 / 3 = 2$.
  \hfill[1 Mark]
\end{itemize}

\subsubsection*{Task (file postfix2.scala)}

\begin{itemize}
\item[(3/4)] Extend the code in (1) and (2) to include the power
  operator.  This requires proper account of associativity of
  the operators. The power operator is right-associative, whereas the
  other operators are left-associative.  Left-associative operators
  are popped off if the precedence is bigger or equal, while
  right-associative operators are only popped off if the precedence is
  bigger.\hfill[1 Marks]
\end{itemize}

\end{document}


%%% Local Variables: 
%%% mode: latex
%%% TeX-master: t
%%% End: