// UNFINISHED BUSINESS from Lecture 1

//====================================

// for measuring time

def time_needed[T](n: Int, code: => T) = {

  val start = System.nanoTime()

  for (i <- (0 to n)) code

  val end = System.nanoTime()

  (end - start) / 1.0e9

}

val list = (1 to 1000000).toList

time_needed(10, for (n <- list) yield n + 42)

time_needed(10, for (n <- list.par) yield n + 42)

// Just for "Fun": Mutable vs Immutable

//=======================================

//

// - no vars, no ++i, no +=

// - no mutable data-structures (no Arrays, no ListBuffers)

// Q: Count how many elements are in the intersections of two sets?

def count_intersection(A: Set[Int], B: Set[Int]) : Int = {

  var count = 0

  for (x <- A; if B contains x) count += 1 

  count

}

val A = (1 to 1000).toSet

val B = (1 to 1000 by 4).toSet

count_intersection(A, B)

// but do not try to add .par to the for-loop above

//propper parallel version

def count_intersection2(A: Set[Int], B: Set[Int]) : Int = 

  A.par.count(x => B contains x)

count_intersection2(A, B)

val A = (1 to 1000000).toSet

val B = (1 to 1000000 by 4).toSet

time_needed(100, count_intersection(A, B))

time_needed(100, count_intersection2(A, B))

// For-Comprehensions Again

//==========================

// the first produces a result, while the second does not

for (n <- List(1, 2, 3, 4, 5)) yield n * n

for (n <- List(1, 2, 3, 4, 5)) println(n)

// Higher-Order Functions

//========================

// functions can take functions as arguments

def even(x: Int) : Boolean = x % 2 == 0

def odd(x: Int) : Boolean = x % 2 == 1

val lst = (1 to 10).toList

lst.filter(x => even(x))

lst.filter(even(_))

lst.filter(even)

lst.count(even)

lst.find(_ > 8)

val ps = List((3, 0), (3, 2), (4, 2), (2, 0), (1, 1), (1, 0))

ps.sortBy(_._1)

ps.sortBy(_._2)

ps.maxBy(_._1)

ps.maxBy(_._2)

// maps

//=====

def square(x: Int): Int = x * x

val lst = (1 to 10).toList

lst.map(square)

// this is actually what for is defined at in Scala

lst.map(n => square(n))

for (n <- lst) yield square(n)

// this can be iterated

lst.map(square).filter(_ > 4)

lst.map(square).filter(_ > 4).map(square)

// lets define our own functions

// type of functions, for example f: Int => Int

def my_map_int(lst: List[Int], f: Int => Int) : List[Int] = {

  if (lst == Nil) Nil

  else f(lst.head) :: my_map_int(lst.tail, f)

}

my_map_int(lst, square)

// same function using pattern matching: a kind

// of switch statement on steroids (see more later on)

def my_map_int(lst: List[Int], f: Int => Int) : List[Int] = lst match {

  case Nil => Nil

  case x::xs => f(x)::my_map_int(xs, f)

}

// other function types

//

// f1: (Int, Int) => Int

// f2: List[String] => Option[Int]

// ... 

def sumOf(f: Int => Int, lst: List[Int]): Int = lst match {

  case Nil => 0

  case x::xs => f(x) + sumOf(f, xs)

}

def sum_squares(lst: List[Int]) = sumOf(square, lst)

def sum_cubes(lst: List[Int])   = sumOf(x => x * x * x, lst)

sum_squares(lst)

sum_cubes(lst)

// lets try it factorial

def fact(n: Int) : Int = ...

def sum_fact(lst: List[Int]) = sumOf(fact, lst)

sum_fact(lst)

// Map type

//==========

// Note the difference between map and Map

def factors(n: Int) : List[Int] =

  ((1 until n).filter { divisor =>

      n % divisor == 0

    }).toList

var ls = (1 to 10).toList

val facs = ls.map(n => (n, factors(n)))

facs.find(_._1 == 4)

// works for lists of pairs

facs.toMap

facs.toMap.get(4)

facs.toMap.getOrElse(4, Nil)

val facsMap = facs.toMap

val facsMap0 = facsMap + (0 -> List(1,2,3,4,5))

facsMap0.get(0)

val facsMap4 = facsMap + (1 -> List(1,2,3,4,5))

facsMap.get(1)

facsMap4.get(1)

val ls = List("one", "two", "three", "four", "five")

ls.groupBy(_.length)

ls.groupBy(_.length).get(3)

//

// operations on options

// a function that turns strings into numbers (similar to .toInt)

Integer.parseInt("1234")

def get_me_an_int(s: String) : Option[Int] = 

val lst = List("12345", "foo", "5432", "bar", "x21", "456")

lst.map(get_me_an_int)

lst.map(get_me_an_int).flatten.sum

val sum = lst.flatMap(get_me_an_int).sum

List(5,6,7,8,9).indexOf(10)

// remember?

  case "December" => "It's winter"

  case "January" | "February" => "It's unfortunately winter"

// Silly: fizz buzz

abstract class Colour

case object Red extends Colour 

case object Green extends Colour 

case object Blue extends Colour

def fav_colour(c: Colour) : Boolean = c match {

  case Red   => false

  case Green => true

  case Blue  => false 

fav_colour(Green)

// ... a bit more useful: Roman Numerals

abstract class RomanDigit 

case object I extends RomanDigit 

case object V extends RomanDigit 

case object X extends RomanDigit 

case object L extends RomanDigit 

case object C extends RomanDigit 

case object D extends RomanDigit 

case object M extends RomanDigit 

type RomanNumeral = List[RomanDigit] 

def RomanNumeral2Int(rs: RomanNumeral): Int = rs match { 

  case Nil => 0

  case M::r    => 1000 + RomanNumeral2Int(r)  

  case C::M::r => 900 + RomanNumeral2Int(r)

  case D::r    => 500 + RomanNumeral2Int(r)

  case C::D::r => 400 + RomanNumeral2Int(r)

  case C::r    => 100 + RomanNumeral2Int(r)

  case X::C::r => 90 + RomanNumeral2Int(r)

  case L::r    => 50 + RomanNumeral2Int(r)

  case X::L::r => 40 + RomanNumeral2Int(r)

  case X::r    => 10 + RomanNumeral2Int(r)

  case I::X::r => 9 + RomanNumeral2Int(r)

  case V::r    => 5 + RomanNumeral2Int(r)

  case I::V::r => 4 + RomanNumeral2Int(r)

  case I::r    => 1 + RomanNumeral2Int(r)

RomanNumeral2Int(List(I,V))             // 4

RomanNumeral2Int(List(I,I,I,I))         // 4 (invalid Roman number)

RomanNumeral2Int(List(V,I))             // 6

RomanNumeral2Int(List(I,X))             // 9

RomanNumeral2Int(List(M,C,M,L,X,X,I,X)) // 1979

RomanNumeral2Int(List(M,M,X,V,I,I))     // 2017

// another example

//=================

// Once upon a time, in a complete fictional country there were Persons...

case object King extends Person

case object Clown extends Person

  case King => "His Majesty the King"

  case (King, _) => true

  case (Peer(_,_,_), Clown) => true

  case (Knight(_), Clown) => true

  case (Clown, Peasant(_)) => true

                  King, 

                  Clown)

// Tail recursion

//================

def fact(n: Long): Long = 

  if (n == 0) 1 else n * fact(n - 1)

fact(10)              //ok

fact(10000)           // produces a stackoverflow

def factT(n: BigInt, acc: BigInt): BigInt =

  if (n == 0) acc else factT(n - 1, n * acc)

factT(10, 1)

factT(100000, 1)

// there is a flag for ensuring a function is tail recursive

import scala.annotation.tailrec

@tailrec