Babylonian method for square root

Algorithm:
This method can be derived from (but predates) Newton–Raphson method.


1 Start with an arbitrary positive start value x (the closer to the 
   root, the better).
2 Initialize y = 1.
3. Do following until desired approximation is achieved.
  a) Get the next approximation for root using average of x and y
  b) Set y = n/x

Implementation:

C

filter_none

edit
close

play_arrow

link
brightness_4
code

#include<stdio.h>
  
/*Returns the square root of n. Note that the function */
float squareRoot(float n)
{
  /*We are using n itself as initial approximation
   This can definitely be improved */
  float x = n;
  float y = 1;
  float e = 0.000001; /* e decides the accuracy level*/
  while(x - y > e)
  {
    x = (x + y)/2;
    y = n/x;
  }
  return x;
}
  
/* Driver program to test above function*/
int main()
{
  int n = 50;
  printf ("Square root of %d is %f", n, squareRoot(n));
  getchar();
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

class GFG {
      
    /*Returns the square root of n.
    Note that the function */
    static float squareRoot(float n)
    {
          
        /*We are using n itself as 
        initial approximation This 
        can definitely be improved */
        float x = n;
        float y = 1;
          
        // e decides the accuracy level
        double e = 0.000001;
        while(x - y > e)
        {
            x = (x + y)/2;
            y = n/x;
        }
        return x;
    }
      
    /* Driver program to test
    above function*/
    public static void main(String[] args)
    {
        int n = 50;
          
        System.out.printf ("Square root of "
                + n + " is " + squareRoot(n));
    }
}
  
// This code is contriubted by
// Smitha DInesh Semwal

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Returns the square root of n.
# Note that the function 
def squareRoot(n):
  
    # We are using n itself as
    # initial approximation This
    # can definitely be improved 
        x = n
        y = 1
          
        # e decides the accuracy level
        e = 0.000001
        while(x - y > e):
      
            x = (x + y)/2
            y = n/x
      
        return x
  
# Driver program to test 
# above function
n = 50
  
print("Square root of", n, "is",
              round(squareRoot(n), 6))
  
# This code is contributed by 
# Smitha Dinesh Semwal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# Porgram for Babylonian 
// method of square root
using System;
  
class GFG {
      
    // Returns the square root of n.
    // Note that the function
    static float squareRoot(float n)
    {
          
        // We are using n itself as 
        // initial approximation This 
        // can definitely be improved 
        float x = n;
        float y = 1;
          
        // e decides the 
        // accuracy level
        double e = 0.000001;
        while(x - y > e)
        {
            x = (x + y)/2;
            y = n/x;
        }
        return x;
    }
      
    // Driver Code
    public static void Main()
    {
        int n = 50;
        Console.Write ("Square root of "
                       + n + " is " + squareRoot(n));
    }
}
  
// This code is contriubted by nitin mittal.

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
  
// Returns the square root of n.
// Note that the function
function squareRoot($n)
{
      
    // We are using n itself
    // as initial approximation
    // This can definitely be
    // improved
    $x = $n;
    $y = 1;
      
    /* e decides the 
       accuracy level */
    $e = 0.000001; 
    while($x - $y > $e)
    {
        $x = ($x + $y)/2;
        $y = $n / $x;
    }
    return $x;
}
  
// Driver Code
{
    $n = 50;
    echo "Square root of $n is ", squareRoot($n);
}
  
// This code is contributed by nitin mittal.
?>

chevron_right


Output :

Square root of 50 is 7.071068

Example:

n = 4 /*n itself is used for initial approximation*/
Initialize x = 4, y = 1
Next Approximation x = (x + y)/2 (= 2.500000), 
y = n/x  (=1.600000)
Next Approximation x = 2.050000,
y = 1.951220
Next Approximation x = 2.000610,
y = 1.999390
Next Approximation x = 2.000000, 
y = 2.000000
Terminate as (x - y) > e now.

If we are sure that n is a perfect square, then we can use following method. The method can go in infinite loop for non-perfect-square numbers. For example, for 3 the below while loop will never terminate.

C



filter_none

edit
close

play_arrow

link
brightness_4
code

// C program for Babylonian 
// method for square root
#include<stdio.h>
  
/* Returns the square root of 
   n. Note that the function
   will not work for numbers 
   which are not perfect 
   squares*/
unsigned int squareRoot(int n)
{
    int x = n;
    int y = 1;
    while(x > y)
    {
        x = (x + y) / 2;
        y = n / x;
    }
    return x;
}
  
// Driver Code
int main()
{
    int n = 49;
    printf("root of %d is %d", n, squareRoot(n));
    getchar();
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for Babylonian 
// method for square root
import java .io.*;
  
public class GFG {
      
    /* Returns the square root of 
    n. Note that the function
    will not work for numbers 
    which are not perfect 
    squares*/
    static long squareRoot(int n)
    {
        int x = n;
        int y = 1;
        while(x > y)
        {
            x = (x + y) / 2;
            y = n / x;
        }
        return (long)x;
    }
      
    // Driver Code
    static public void main (String[] args)
    {
        int n = 49;
        System.out.println( "root of "
        + n + " is " + squareRoot(n));
    }
}
  
// This code is contributed by anuj_67.

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# python3 program for Babylonian 
# method for square root
  
# Returns the square root of n.
# Note that the function
# will not work for numbers 
# which are not perfect squares
  
def squareRoot(n):
    x = n;
    y = 1;
    while(x > y):
        x = (x + y) / 2;
        y = n / x;
    return x;
  
# Driver Code
n = 49;
print("root of", n, "is", squareRoot(n));
  
# This code is contributed by mits.

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for Babylonian 
// method for square root
  
using System;
  
public class GFG {
      
    /* Returns the square root of 
    n. Note that the function
    will not work for numbers 
    which are not perfect 
    squares*/
    static uint squareRoot(int n)
    {
        int x = n;
        int y = 1;
        while(x > y)
        {
            x = (x + y) / 2;
            y = n / x;
        }
        return (uint)x;
    }
      
    // Driver Code
    static public void Main ()
    {
        int n = 49;
        Console.WriteLine( "root of "
        + n + " is " + squareRoot(n));
    }
}
  
// This code is contributed by anuj_67.

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program for Babylonian 
// method for square root
  
/* Returns the square root of
   n. Note that the function
   will not work for numbers 
   which are not perfect 
   squares */
function squareRoot( $n)
{
    $x = $n;
    $y = 1;
    while($x > $y)
    {
        $x = ($x + $y) / 2;
        $y =$n / $x;
    }
    return $x;
}
  
// Driver Code
$n = 49;
echo " root of ",$n, " is "
          , squareRoot($n);
            
// This code is contributed by anuj_67.
?>

chevron_right



Output :

 root of 49 is 7


References;

http://en.wikipedia.org/wiki/Square_root
http://en.wikipedia.org/wiki/Babylonian_method#Babylonian_method

Asked by Snehal

Please write comments if you find any bug in the above program/algorithm, or if you want to share more information about Babylonian method.



My Personal Notes arrow_drop_up



Article Tags :
Practice Tags :


1


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.