TheAlgorithms-C-Plus-Plus/numerical_methods/false_position.cpp

/**
 * \file
 * \brief Solve the equation \f$f(x)=0\f$ using [false position
 * method](https://en.wikipedia.org/wiki/Regula_falsi), also known as the Secant
 * method
 *
 * \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]
 * For the next iteration, the interval is selected
 * as: \f$[a,x]\f$ if \f$x>0\f$ or \f$[x,b]\f$ if \f$x<0\f$. The Process is
 * 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>      /// for math operations
#include <iostream>   /// for io operations

/**
 * @namespace numerical_methods
 * @brief Numerical methods
 */
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
}

/**
* @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);
}

/**
* @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() {
    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);
        }
        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;
    }
    return 0;
}