====== Lab 2. Scala syntax and function definition ======

** Objectives: **
  * get yourself familiar with Scala syntax basics
  * practice writing **tail-recursive** functions as an alternative to imperative **loops** 
  * keep your code clean and well-structured.

** Create a new Scala worksheet to write your solutions **

**2.1.** Write a tail-recursive function that computes the factorial of a natural number. Start from the code stub below:

<code scala>
def fact (n: Int): Int = {
   def aux_fact(i: Int, acc: Int): Int = 
       if (???) acc
       else ???
   ???
}
</code>


**2.2.** Implement a tail-recursive function that computes the greatest common divisor of a natural number:

<code scala>
def gcd(a: Int, b: Int): Int = ???
</code>


**2.3.** Write a tail-recursive function takes an integer $math[n] and computes the value $math[1 + 2^2 + 3^2 + ... + (n-1)^2 + n^2]. (Hint: use inner functions).

<code scala>
def sumSquares(n: Int): Int = ???
</code>

**2.4.** Write a function which computes the sum of all natural numbers within a range. Use **two styles** to write this function: direct recursion, and tail recursion.
<code scala>
def sumNats(start: Int, stop: Int): Int = ???
def tailSumNats(start: Int, stop: Int): Int = ???
</code>

**2.5.** (!) Write a function which takes an initial value $math[x] and a range of values $math[x_0, x_1, \ldots, x_n] and computes $math[((x - x_0) - x_1) - \ldots x_n]. Use the most appropriate **type of recursion** for this task.

<code scala>
def subtractRange(x: Int, start: Int, stop: Int): Int = ???
</code>

**2.6.** (!) Write a function which takes an initial value $math[x] and a range of values $math[x_0, x_1, \ldots, x_n] and computes $math[x_0 - (x_1 - (x_2 - (\ldots - (x_n - x)\ldots )]. Use the most appropriate **type of recursion** for this task.


===== Newton's Square Root method =====

A very fast way to numerically compute $math[\sqrt{a}], often used as a standard //sqrt(.)// implementation, relies on Newton's Square Root approximation. The main idea relies on starting with an estimate (often 1), and incrementally improving the estimate. More precisely:
  * Start with $math[x_0 = 1].
  * Compute $math[x_{n+1} = \displaystyle\frac{1}{2}(x_n+\frac{a}{x_n})]

**2.4.** Implement the function ''improve'' which takes an estimate $math[x_n] of $math[\sqrt{a}] and improves it (computes $math[x_{n+1}]).
<code scala>
def improve(xn: Double, a: Double): Double = ???
</code>

**2.5.** Implement the function ''nthGuess'' which starts with $math[x_0 = 1] and computes the nth estimate $math[x_n] of $math[\sqrt{a}]:
<code scala>
def nth_guess(n: Int, a: Double): Double = ???
</code>

Note that:
  * for smaller $math[a], there is no need to compute $math[n] estimations as $math[(x_n)_n] converges quite fast to $math[\sqrt{a}]. 
 
**2.6.** Thus, implement the function ''acceptable'' which returns ''true'' iff $math[\mid x_n^2 - a \mid \leq 0.001]. (Hint, google the ''abs'' function in Scala. Don't forget to import ''scala.math._'').
<code scala>
  def acceptable(xn: Double, a: Double): Boolean = ???
</code>

**2.7.** Implement the function ''mySqrt'' which computes the square root of an integer ''a''. Modify the previous implementations to fit the following code structure:
<code scala>
def mySqrt(a: Double): Double = {
   def improve(xn: Double): Double = ???
   def acceptable(xn: Double): Boolean = ???
   
   def tailSqrt(estimate: Double): Double = ???
   
   ???
}
</code>

**2.8. (!) **  Try out your code for: ''2.0e50'' (which is $math[2.0\cdot 10^{50}]) or ''2.0e-50''. The code will likely take a very long time to finish. The reason is that $math[xn^2 - a] will suffer from rounding error which may be larger than 0.001. Can you find a different implementation for the function ''acceptable'' which takes that into account? (Hint: the code is just as simple as the original one).