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;
}