scala - when testing for convergence using successive approximation technique, why does this code divide by the guess twice? -

while working through coursera class on scala ran code below (from question asked here sudipta deb.)

package src.com.sudipta.week2.coursera import scala.math.abs import scala.annotation.tailrec  object fixedpoint {   println("welcome scala worksheet")       //> welcome scala worksheet    val tolerance = 0.0001                          //> tolerance  : double = 1.0e-4   def iscloseenough(x: double, y: double): boolean = {     abs((x - y) / x) / x < tolerance   }                                               //> iscloseenough: (x: double, y: double)boolean   def fixedpoint(f: double => double)(firstguess: double): double = {     @tailrec     def iterate(guess: double): double = {       val next = f(guess)       if (iscloseenough(guess, next)) next       else iterate(next)     }     iterate(firstguess)   }                                               //> fixedpoint: (f: double => double)(firstguess: double)double    def myfixedpoint = fixedpoint(x => 1 + x / 2)(1)//> myfixedpoint: => double   myfixedpoint                                    //> res0: double = 1.999755859375    def squareroot(x: double) = fixedpoint(y => (y + x / y) / 2)(1)                                                   //> squareroot: (x: double)double   squareroot(2)                                   //> res1: double = 1.4142135623746899    def calculateaverate(f: double => double)(x: double) = (x + f(x)) / 2                                                   //> calculateaverate: (f: double => double)(x: double)double   def mynewsquareroot(x: double): double = fixedpoint(calculateaverate(y => x / y))(1)                                                   //> mynewsquareroot: (x: double)double   mynewsquareroot(2)                              //> res2: double = 1.4142135623746899 } 

my puzzlement concerns iscloseenough function.

i understand guesses large numbers, difference between guess , large value function returns potentially big time, may never converge. conversely, if guess small, , if f(x) produces small converge quickly. dividing through guess this:

  def iscloseenough(x: double, y: double): boolean = {     abs((x - y) / x) / x < tolerance   }                                                

makes perfect sense. (here 'x' guess, , y f_of_x.)

my question why why solution given divide guess twice ?

wouldn't undo benefits of dividing through guess first time ?

as example... let's current guess , value returned function given current x shown below:

import math.abs var guess=.0000008f var f_of_x=.00000079999f 

and lets' tolerance

var tolerance=.0001 

these numbers pretty close, , indeed, if divide through x once, see result less tolerance.

( abs(guess  -  f_of_x) / guess)   res3: float = 1.2505552e-5 

however, if divide through x twice result greater tolerance, suggest need keep iterating.. seems wrong since guess , observed f(x) close.

scala> ( abs(guess  -  f_of_x) / guess) / guess res11: float = 15.632331 

thanks in advance can provide.

you right, not make sense. further, second division outside of absolute value rendering inequality true negative x.

perhaps got confused testing quadratic convergence.