diff --git a/numerical_methods/false_position.cpp b/numerical_methods/false_position.cpp
index aebd154bb..f4554aa2d 100644
--- a/numerical_methods/false_position.cpp
+++ b/numerical_methods/false_position.cpp
@@ -4,7 +4,12 @@
  * method](https://en.wikipedia.org/wiki/Regula_falsi), also known as the Secant
  * method
  *
- * Given two points \f$a\f$ and \f$b\f$ such that \f$f(a)<0\f$ and
+ * \details
+ * First, multiple intervals are selected with the interval gap provided. 
+ * Separate recursive function called for every root.
+ * Roots are printed Separatelt.
+ *
+ * For an interval [a,b] \f$a\f$ and \f$b\f$ such that \f$f(a)<0\f$ and
  * \f$f(b)>0\f$, then the \f$(i+1)^\text{th}\f$ approximation is given by: \f[
  * x_{i+1} = \frac{a_i\cdot f(b_i) - b_i\cdot f(a_i)}{f(b_i) - f(a_i)}
  * \f]
@@ -13,62 +18,112 @@
  * continued till a close enough approximation is achieved.
  *
  * \see newton_raphson_method.cpp, bisection_method.cpp
+ *
+ * \author Unknown author
+ * \author [Samruddha Patil](https://github.com/sampatil578)
  */
-#include <cmath>
-#include <cstdlib>
-#include <iostream>
-#include <limits>
+#include <cmath>      /// for math operations
+#include <iostream>   /// for io operations
 
-#define EPSILON \
-    1e-6  // std::numeric_limits<double>::epsilon()  ///< system accuracy limit
-#define MAX_ITERATIONS 50000  ///< Maximum number of iterations to check
-
-/** define \f$f(x)\f$ to find root for
+/**
+ * @namespace numerical_methods
+ * @brief Numerical methods
  */
-static double eq(double i) {
-    return (std::pow(i, 3) - (4 * i) - 9);  // origial equation
+namespace numerical_methods {
+/**
+ * @namespace false_position
+ * @brief Functions for [False Position]
+ * (https://en.wikipedia.org/wiki/Regula_falsi) method.
+ */
+namespace false_position {
+/**
+* @brief This function gives the value of f(x) for given x.
+* @param x value for which we have to find value of f(x).
+* @return value of f(x) for given x.
+*/  
+static float eq(float x) {
+    return (x*x-x);  // original equation
 }
 
-/** get the sign of any given number */
-template <typename T>
-int sgn(T val) {
-    return (T(0) < val) - (val < T(0));
+/**
+* @brief This function finds root of the equation in given interval i.e. (x1,x2).
+* @param x1,x2 values for an interval in which root is present.
+  @param y1,y2 values of function at x1, x2 espectively.
+* @return root of the equation in the given interval.
+*/  
+static float regula_falsi(float x1,float x2,float y1,float y2){
+    float diff = x1-x2;
+    if(diff<0){
+        diff= (-1)*diff;
+    }
+    if(diff<0.00001){          
+        if (y1<0) {
+            y1=-y1;
+        }
+        if (y2<0) {
+            y2=-y2;
+        }
+        if (y1<y2) {
+            return x1;
+        }
+        else {
+            return x2;
+        }
+    }
+    float x3=0,y3=0;
+    x3 = x1 - (x1-x2)*(y1)/(y1-y2);
+    y3 = eq(x3);
+    return regula_falsi(x2,x3,y2,y3);
 }
 
-/** main function */
+/**
+* @brief This function prints roots of the equation.
+* @param root which we have to print. 
+* @param count which is count of the root in an interval [-range,range].
+*/  
+void printRoot(float root, const int16_t &count){
+    if(count==1){
+        std::cout << "Your 1st root is : " << root << std::endl;
+    }
+    else if(count==2){
+        std::cout << "Your 2nd root is : " << root << std::endl;
+    }
+    else if(count==3){
+        std::cout << "Your 3rd root is : " << root << std::endl;
+    }
+    else{
+        std::cout << "Your "<<count<<"th root is : " << root << std::endl;
+    }
+}
+}  // namespace false_position
+}  // namespace numerical_methods
+
+
+/**
+* @brief Main function
+* @returns 0 on exit
+*/
 int main() {
-    double a = -1, b = 1, x, z, m, n, c;
-    int i;
-
-    // loop to find initial intervals a, b
-    for (int i = 0; i < MAX_ITERATIONS; i++) {
-        z = eq(a);
-        x = eq(b);
-        if (sgn(z) == sgn(x)) {  // same signs, increase interval
-            b++;
-            a--;
-        } else {  // if opposite signs, we got our interval
-            break;
+    float a=0, b=0,i=0,root=0;
+    int16_t count=0;
+    float range = 100000;        //Range in which we have to find the root. (-range,range)
+    float gap = 0.5;          // interval gap. lesser the gap more the accuracy
+    a = numerical_methods::false_position::eq((-1)*range);
+    i=((-1)*range + gap);
+    //while loop for selecting proper interval in provided range and with provided interval gap.
+    while(i<=range){
+        b = numerical_methods::false_position::eq(i);
+        if(b==0){
+            count++;
+            numerical_methods::false_position::printRoot(i,count);
         }
-    }
-
-    std::cout << "\nFirst initial: " << a;
-    std::cout << "\nSecond initial: " << b;
-
-    for (i = 0; i < MAX_ITERATIONS; i++) {
-        m = eq(a);
-        n = eq(b);
-
-        c = ((a * n) - (b * m)) / (n - m);
-
-        a = c;
-        z = eq(c);
-
-        if (std::abs(z) < EPSILON) {  // stoping criteria
-            break;
+        if(a*b<0){
+            root = numerical_methods::false_position::regula_falsi(i-gap,i,a,b);
+            count++;
+            numerical_methods::false_position::printRoot(root,count);
         }
+        a=b;
+        i+=gap;
     }
-
-    std::cout << "\n\nRoot: " << c << "\t\tSteps: " << i << std::endl;
     return 0;
 }