part are due on 16 November at 11pm, and the third part on 23 November

Make sure the files you submit can be processed by just calling

\texttt{scala <<filename.scala>>}.\bigskip

\textbf{Important:} Do not use any mutable data structures in your

submissions! They are not needed. This means you cannot use 

\texttt{ListBuffer}s, for example. Do not use \texttt{return} in your

code! It has a different meaning in Scala, than in Java.

Do not use \texttt{var}! This declares a mutable variable. Make sure the

functions you submit are defined on the ``top-level'' of Scala, not

inside a class or object. Also note that the running time of

each part will be restricted to a maximum of 360 seconds on my laptop.

\subsection*{Disclaimer}

It should be understood that the work you submit represents

your own effort. You have not copied from anyone else. An

exception is the Scala code I showed during the lectures or

uploaded to KEATS, which you can freely use.\bigskip

\newpage

  $1$ million. \hfill[2 Marks]

\item 1 to 1 million where $837,799$ takes 525 steps

\end{itemize}\bigskip

\subsection*{Part 2 (4 Marks)}

This part is about list processing---it's a variant of

``buy-low-sell-high'' in Scala. It uses the online financial data

service from Yahoo.\bigskip 

\noindent

\textbf{Tasks (file trade.scala):}

\begin{itemize}

\item[(1)] Given a list of prices for a commodity, for example

\[

\texttt{List(28.0, 18.0, 20.0, 26.0, 24.0)}

\]

\noindent

you need to write a function that returns a pair of indices for when

to buy and when to sell this commodity. In the example above it should

return the pair $\texttt{(1, 3)}$ because at index $1$ the price is lowest and

then at index $3$ the price is highest. Note the prices are given as

lists of \texttt{Double}s.\newline \mbox{} \hfill[1 Mark]

\item[(2)] Write a function that requests a comma-separated value (CSV) list

  from the Yahoo websevice that provides historical data for stock

  indices. For example if you query the URL

\begin{center}

\url{http://ichart.yahoo.com/table.csv?s=GOOG}

\end{center}

\noindent where \texttt{GOOG} stands for Google's stock market symbol,

then you will receive a CSV-list of the daily stock prices since

Google was listed. You can also try this with other stock market

symbols, for instance AAPL, MSFT, IBM, FB, YHOO, AMZN, BIDU and so

on. 

This function should return a List of strings, where each string

is one line in this CVS-list (representing one day's

data). Note that Yahoo generates its answer such that the newest data

is at the front of this list, and the oldest data is at the end.

\hfill[1 Mark]

\item[(3)] As you can see, the financial data from Yahoo is organised in 7 columns,

for example

{\small\begin{verbatim}

Date,Open,High,Low,Close,Volume,Adj Close

2016-11-04,750.659973,770.359985,750.560974,762.02002,2126900,762.02002

2016-11-03,767.25,769.950012,759.030029,762.130005,1914000,762.130005

2016-11-02,778.200012,781.650024,763.450012,768.700012,1872400,768.700012

2016-11-01,782.890015,789.48999,775.539978,783.609985,2404500,783.609985

....

\end{verbatim}}

\noindent

Write a function that ignores the first line (the header) and then

extracts from each line the date (first column) and the Adjusted Close

price (last column). The Adjusted Close price should be converted into

a \texttt{Double}. So the result of this function is a list of pairs where the

first components are strings (the dates) and the second are doubles

(the adjusted close prices).\newline\mbox{}\hfill\mbox{[1 Mark]}

\item[(4)] Write a function that takes a stock market symbol as

  argument (you can assume it is a valid one, like GOOG or AAPL). The

  function calculates the \underline{dates} when you should have

  bought the corresponding shares (lowest price) and when you should

  have sold them (highest price).\hfill\mbox{[1 Mark]}

\textbf{Test Data:}

In case of Google, the financial data records 3077 entries starting

from 2004-08-19 until 2016-11-04 (which is the last entry on the day

when I prepared the course work...namely on 6 November; remember stock

markets are typically closed on weekends and no financial data is

produced then; also I did not count the header line). The lowest

shareprice for Google was on 2004-09-03 with \$49.95513 per share and the

highest on 2016-10-24 with \$813.109985 per share.\bigskip

\subsection*{Advanced Part 3 (3 Marks)}

Since the question about Mr Drumb's business acumen remains, let's do a

quick back-of-the-envelope calculation in Scala whether his claim has

any merit. Let's suppose we are given \$100 in 1978 and we follow a

really dumb investment strategy, namely:

  some companies went bust or de-listed).

\item We do this for 38 years until January 2016 and check what would

\end{itemize}\medskip  

\item[(1.a)] Write a function that queries the Yahoo financial data

  service and obtains the first trade (adjusted close price) of a

  stock symbol and a year. A problem is that normally a stock exchange

  is not open on 1st of January, but depending on the day of the week

  on a later day (maybe 3rd or 4th). The easiest way to solve this

  problem is to obtain the whole January data for a stock symbol as

  CSV-list and then select the earliest entry in this list. For this

  you can specify a date range with the Yahoo service. For example if

  you want to obtain all January data for Google in 2000, you can form

  the query:\mbox{}\\[-8mm]

  \begin{center}\small

    \mbox{\url{http://ichart.yahoo.com/table.csv?s=GOOG&a=0&b=1&c=2000&d=1&e=1&f=2000}}

  \end{center}

  For other companies and years, you need to change the stock symbol

  (\texttt{GOOG}) and the year \texttt{2000} (in the \texttt{c} and

  \texttt{f} argument of the query). Such a request might fail, if the

  company does not exist during this period. For example, if you query

  for Google in January of 1980, then clearly Google did not exists yet.

  Therefore you are asked to return a trade price as

  \texttt{Option[Double]}.

\item[(1.b)] Write a function that takes a portfolio (a list of stock symbols),

  a years range and gets all the first trading prices for each year. You should

  organise this as a list of lists of \texttt{Option[Double]}'s. The inner lists

  are for all stock symbols from the portfolio and the outer list for the years.

  For example for Google and Apple in years 2010 (first line), 2011

  (second line) and 2012 (third line) you obtain:

  List(List(Some(313.062468), Some(27.847252)), 

       List(Some(301.873641), Some(42.884065)),

       List(Some(332.373186), Some(53.509768)))

\end{verbatim}\hfill[1 Mark]

  List(List(Some(-0.03573991820699504), Some(0.5399747522663995))

          List(Some(0.10103414428290529), Some(0.24777742035415723)))

  Both did OK in 2011.\hfill\mbox{[1 Mark]}

  received in our running example

  $50 * -0.03573991820699504 + $50 * 0.5399747522663995

                                         = $25.211741702970222

  the new balances and then re-invested into our portfolio.\mbox{}\hfill\mbox{[1 Mark]}

Facebook, Amazon and Baidu; and another for listed real-estate companies, whose

names I have never heard of. Following the dumb investment strategy

from 1978 until 2016 would have turned a starting balance of \$100

into \$23,794 for real estate and a whopping \$524,609 for blue chips.\medskip

equally well, if not much better.

About rounding errors: \url{https://www.youtube.com/watch?v=pQs_wx8eoQ8}

(PBS Infinity Series).