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 <iostream>
using namespace std;
class gfg {
    /*Returns the square root of n. Note that the function */
public:
    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()
{
    gfg g;
    int n = 50;
    cout << "Square root of " << n << " is " << g.squareRoot(n);
    getchar();
}

chevron_right


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 <iostream>
using namespace std;
  
class gfg {
  
    /* Returns the square root of 
   n. Note that the function
   will not work for numbers 
   which are not perfect 
   squares*/
public:
    float squareRoot(float n)
    {
        /* We are using n itself as an initial 
          approximation.  This can definitely be
          improved */
        float x = n;
        float y = 1;
  
        while (x > y) {
            x = (x + y) / 2;
            y = n / x;
        }
        return x;
    }
};
  
/* Driver code*/
int main()
{
    gfg g;
    int n = 49;
    cout << "Square root of " << n << " is " << g.squareRoot(n);
    getchar();
}
  
// This code is edited by Dark_Dante_

chevron_right


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.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.




My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :


6


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