# A real-world functional programming example in Scala

This is an excerpt from the Scala Cookbook (partially modified for the internet). This is Recipe 9.9, “A real-world functional programming example in Scala.”

## Problem

Understanding functional programming concepts is one thing; putting them into practice in a real project is another. You’d like to see a real example of functional programming in Scala.

## Solution

To demonstrate some of the functional programming (FP) techniques that I introduced earlier in this chapter, the following example shows one way to implement Newton’s Method, a mathematical method that can be used to solve the roots of equations.

As you can see from the code, the method named `newtonsMethod` takes functions as its first two parameters. It also takes two other `Double` parameters, and returns a `Double`. The two functions that are passed in should be the original equation (`fx`) and the derivative of that equation (`fxPrime`).

The method `newtonsMethodHelper` also takes two functions as parameters, so you can see how the functions are passed from `newtonsMethod` to `newtonsMethodHelper`. Here is the complete source code for this example:

```object NewtonsMethod {

def main(args: Array[String]) {
driver
}

/**
* A "driver" function to test Newton's method.
* Start with (a) the desired f(x) and f'(x) equations,
* (b) an initial guess and (c) tolerance values.
*/
def driver {
// the f(x) and f'(x) functions
val fx = (x: Double) => 3*x + math.sin(x) - math.pow(math.E, x)
val fxPrime = (x: Double) => 3 + math.cos(x) - math.pow(Math.E, x)
val initialGuess = 0.0
val tolerance = 0.00005
// pass f(x) and f'(x) to the Newton's Method function, along with
// the initial guess and tolerance
val answer = newtonsMethod(fx, fxPrime, initialGuess, tolerance)
}

/**
* Newton's Method for solving equations.
* @todo check that |f(xNext)| is greater than a second tolerance value
* @todo check that f'(x) != 0
*/
def newtonsMethod(fx: Double => Double,
fxPrime: Double => Double,
x: Double,
tolerance: Double): Double = {
var x1 = x
var xNext = newtonsMethodHelper(fx, fxPrime, x1)
while (math.abs(xNext - x1) > tolerance) {
x1 = xNext
println(xNext) // debugging (intermediate values)
xNext = newtonsMethodHelper(fx, fxPrime, x1)
}
xNext
}

/**
* This is the "x2 = x1 - f(x1)/f'(x1)" calculation
*/
def newtonsMethodHelper(fx: Double => Double,
fxPrime: Double => Double,
x: Double): Double = {
x - fx(x) / fxPrime(x)
}
}```

## Discussion

As you can see, a majority of this code involves defining functions, passing those functions to methods, and then invoking the functions from within a method.

The method name newtonsMethod will work for any two functions `fx` and `fxPrime`, where `fxPrime` is the derivative of `fx` (within the limits of the “to do” items that are not implemented).

To experiment with this example, try changing the functions `fx` and `fxPrime`, or implement the `@todo` items in `newtonsMethod`.

The algorithm shown comes from an old textbook titled Applied Numerical Analysis, by Gerald and Wheatley, where the approach was demonstrated in pseudocode.