// code examples from Scala by Example, chapter 4, 
// factorial is in a file by itself

def sumInts(a: Int, b: Int): Int =
  if (a > b) 0 else a + sumInts(a + 1, b)


def square(x: Int): Int = x * x
def sumSquares(a: Int, b: Int): Int =
  if (a > b) 0 else square(a) + sumSquares(a + 1, b)


def powerOfTwo(x: Int): Int = if (x == 0) 1 else 2 * powerOfTwo(x - 1)
def sumPowersOfTwo(a: Int, b: Int): Int =
  if (a > b) 0 else powerOfTwo(a) + sumPowersOfTwo(a + 1, b)


//======================================================================
//
// first simplification

def sum(f: Int => Int, a: Int, b: Int): Int =
  if (a > b) 0 else f(a) + sum(f, a + 1, b)

def id(x: Int): Int = x


def sumInts2(a: Int, b: Int): Int = sum(id, a, b)
def sumSquares2(a: Int, b: Int): Int = sum(square, a, b)
def sumPowersOfTwo2(a: Int, b: Int): Int = sum(powerOfTwo, a, b)


//======================================================================
//
// using anonymous functions

def sumInts3(a: Int, b: Int): Int = sum((x: Int) => x, a, b)
def sumSquares3(a: Int, b: Int): Int = sum((x: Int) => x * x, a, b)


//======================================================================
//
// new syntax for a function generating function with appropriate parameters


def sum2(f: Int => Int): (Int, Int) => Int = {
  def sumF(a: Int, b: Int): Int =
    if (a > b) 0 else f(a) + sumF(a + 1, b)
  sumF
}


def sumInts4 = sum2(x => x)
def sumSquares4 = sum2(x => x * x)
def sumPowersOfTwo4 = sum2(powerOfTwo)


//======================================================================
//
// new syntax for a function generating function with appropriate parameters
// now simplify that function function generating function as well

def sum3(f: Int => Int)(a: Int, b: Int): Int =
  if (a > b) 0 else f(a) + sum3(f)(a + 1, b)

val sumInts5 = sum3(x => x) _
val sumSquares5 = sum3(x => x * x) _
val sumPowersOfTwo5 = sum3(powerOfTwo) _


//======================================================================
//
// fixed-point, ala sqrt from c4
// 


val tolerance = 0.0001
def abs(x: Double) = if (x > 0) x else -x
def isCloseEnough(x: Double, y: Double) = abs((x - y) / x) < tolerance

def fixedPoint(f: Double => Double)(firstGuess: Double) = {
  def iterate(guess: Double): Double = {
    val next = f(guess)
    println(next)
    if (isCloseEnough(guess, next)) next
    else iterate(next)
  }
  iterate(firstGuess)
}


def infiniteSqrt(x: Double) = fixedPoint(y => x / y)(1.0)


def sqrt(x: Double) = fixedPoint(y => (y + x/y) / 2)(1.0)



def averageDamp(f: Double => Double)(x: Double) = (x + f(x)) / 2

def sqrt2(x: Double) = fixedPoint(averageDamp(y => x/y))(1.0)

def sqrt3(x: Double) = {
  val positiveRoot = fixedPoint(averageDamp(y => x/y))(1.0)
  (positiveRoot, -positiveRoot)
}