The Babylonian Method: Examples

Recall that our algorithm for computing

consists of finding the sequence of numbers

Starting with = 1, here are a few iterations of the method in three particular cases. These were pasted in from a spreadsheet, using 15 decimal digit accuracy.

         square root of 4        square root of 10         square root of 867
  
                                                       
  
  n=0    1                       1                         1
  n=1    2.5                     5.5                     434
  n=2    2.05                    3.6590909090909091      217.99884792626728
  n=3    2.000609756097561       3.1960050818746471      110.987966582159869
  n=4    2.0000000929222947      3.1624556228038901       59.399812124146244
  n=5    2.0000000000000022      3.1622776651756748       36.99790894285632
  n=6    2                       3.1622776601683793       30.215832867705786
  n=7    2                       3.1622776601683793       29.454699522639371
  n=8                                                     29.444865370901943
  n=9                                                     29.44486372867096
  n=10                                                    29.444863728670914
  n=11                                                    29.444863728670914

Notice how quickly the iterations stabilize. We get the square root of 10, correct to at least 7 places, after only 5 iterations. That wouldn't be so very hard to do using paper and pencil, if necessary. It's a piece of cake using a pocket calculator.

Of course, if we want greater accuracy (more decimal places), we'll need more iterations. Also, the better our initial guess, the faster the method will stabilize (in the desired number of decimal places).

Notice, too, that in each of our examples, the sequence decreases for . Using induction, it's not hard to show that this is true in general (assuming that both and are positive). Thus, in this case, the algorithm always converges.

The questions that remain to be answered are: Why is the limit ? And, if so, how fast does the algorithm converge?

As a matter of curiosity, our initial guess need not be positive. Starting with a negative "seed" will lead to (the "other" square root of ).

    another square root of 10
          using x_0 = -1
  
         
  
  n=0   -1
  n=1   -5.5
  n=2   -3.6590909090909091
  n=3   -3.1960050818746471
  n=4   -3.1624556228038901
  n=5   -3.1622776651756748
  n=6   -3.1622776601683793
  n=7   -3.1622776601683793

Even more curious is what happens when you try to apply the method using a negative value of

. This leads to a simple example of what is now commonly known as chaos.

         square root of -10 (?)
  
         
  
  n=0    1
  n=1   -4.5
  n=2   -1.1388888888888889
  n=3    3.8207994579945799
  n=4    0.60177307769841596
  n=5   -8.0078932741715988
  n=6   -3.3795626912948585
  n=7   -0.21029998763649647
  n=8   23.6704101295732
  n=9   11.6239708710134581
  n=10   5.3818398290282722
  n=11   1.7618695973658489
  n=12  -1.9569596785675161
  n=13   1.5765038196846133
  n=14  -2.383323025510703
  n=15   0.9062496585297875
  n=16  -5.0641186289136399

Because of these last two examples, we will henceforth make the blanket assumption that

and

are both postive.

Take some time out to try a few examples of your own. A spreadsheet can make quick work of iterative calculations of this type.

When you're ready to proceed, check out the proof that the Babylonian method converges (when we start with > 0 and ), or stay in the dark.

Neal Carothers - carother@bgnet.bgsu.edu