False Position Method

In numerical analysis, the false position method or regula falsi method is a root-finding algorithm that combines features from thebisection method and the secant method.

Like the bisection method, the false position method starts with two pointsa₀ and b₀ such that f(a₀) and f(b₀) are of opposite signs, which implies by the intermediate value theorem that the function f has a root in the interval [a₀, b₀]. The method proceeds by producing a sequence of shrinking intervals [a_k, b_k] that all contain a root of f.

At iteration number k, the number

is computed. As explained below, c_k is the root of the secant line through (a_k, f(a_k)) and (b_k, f(b_k)). If f(a_k) and f(c_k) have the same sign, then we set a_k+1 = c_k and b_k+1 =b_k, otherwise we set a_k+1 = a_kand b_k+1 = c_k. This process is repeated until the root is approximated sufficiently well.

The above formula is also used in the secant method, but the secant method always retains the last two computed points, while the false position method retains two points which certainly bracket a root. On the other hand, the only difference between the false position method and the bisection method is that the latter uses c_k = (a_k + b_k) /  

EXAMPLE CODE

#include 
#include 
  
double f(double x)
{
    return cos(x) - x*x*x;
}
 
double FalsiMethod(double s, double t, double e, int m)
{
    int n,side=0;
    double r,fr,fs = f(s),ft = f(t);
 
    for (n = 1; n <= m; n++)
    {
        r = (fs*t - ft*s) / (fs - ft);
        if (fabs(t-s) < e*fabs(t+s)) break;
        fr = f(r);
 
        if (fr * ft > 0)
        {
          t = r; ft = fr;
          if (side==-1) fs /= 2;
          side = -1;
        }
        else if (fs * fr > 0)
        {
          s = r;  fs = fr;
          if (side==+1) ft /= 2;
          side = +1;
        }
        else break;
    }
    return r;
}
 
int main(void)
{
    printf("%0.15f\n", FalsiMethod(0, 1, 5E-15, 100));
    return 0;
}