Find root of a number using Newton’s method
Given an integer N and a tolerance level L, the task is to find the square root of that number using Newton’s Method.
Examples:
Input: N = 16, L = 0.0001
Output: 4
42 = 16Input: N = 327, L = 0.00001
Output: 18.0831
Newton’s Method:
Let N be any number then the square root of N can be given by the formula:
root = 0.5 * (X + (N / X)) where X is any guess which can be assumed to be N or 1.
- In the above formula, X is any assumed square root of N and root is the correct square root of N.
- Tolerance limit is the maximum difference between X and root allowed.
Approach: The following steps can be followed to compute the answer:
- Assign X to the N itself.
- Now, start a loop and keep calculating the root which will surely move towards the correct square root of N.
- Check for the difference between the assumed X and calculated root, if not yet inside tolerance then update root and continue.
- If the calculated root comes inside the tolerance allowed then break out of the loop.
- Print the root.
Below is the implementation of the above approach:
C++
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std; // Function to return the square root of // a number using Newtons method double squareRoot(double n, float l) { // Assuming the sqrt of n as n only double x = n; // The closed guess will be stored in the root double root; // To count the number of iterations int count = 0; while (1) { count++; // Calculate more closed x root = 0.5 * (x + (n / x)); // Check for closeness if (abs(root - x) < l) break; // Update root x = root; } return root; } // Driver code int main() { double n = 327; float l = 0.00001; cout << squareRoot(n, l); return 0; } |
chevron_right
filter_none
Java
// Java implementation of the approach class GFG { // Function to return the square root of // a number using Newtons method static double squareRoot(double n, double l) { // Assuming the sqrt of n as n only double x = n; // The closed guess will be stored in the root double root; // To count the number of iterations int count = 0; while (true) { count++; // Calculate more closed x root = 0.5 * (x + (n / x)); // Check for closeness if (Math.abs(root - x) < l) break; // Update root x = root; } return root; } // Driver code public static void main (String[] args) { double n = 327; double l = 0.00001; System.out.println(squareRoot(n, l)); } } // This code is contributed by AnkitRai01 |
chevron_right
filter_none
Python3
# Python3 implementation of the approach # Function to return the square root of # a number using Newtons method def squareRoot(n, l) : # Assuming the sqrt of n as n only x = n # To count the number of iterations count = 0 while (1) : count += 1 # Calculate more closed x root = 0.5 * (x + (n / x)) # Check for closeness if (abs(root - x) < l) : break # Update root x = root return root # Driver code if __name__ == "__main__" : n = 327 l = 0.00001 print(squareRoot(n, l)) # This code is contributed by AnkitRai01 |
chevron_right
filter_none
C#
// C# implementation of the approach using System; class GFG { // Function to return the square root of // a number using Newtons method static double squareRoot(double n, double l) { // Assuming the sqrt of n as n only double x = n; // The closed guess will be stored in the root double root; // To count the number of iterations int count = 0; while (true) { count++; // Calculate more closed x root = 0.5 * (x + (n / x)); // Check for closeness if (Math.Abs(root - x) < l) break; // Update root x = root; } return root; } // Driver code public static void Main() { double n = 327; double l = 0.00001; Console.WriteLine(squareRoot(n, l)); } } // This code is contributed by AnkitRai01 |
chevron_right
filter_none
Output:
18.0831
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.
