# Program for Method Of False Position

Given a function f(x) on floating number x and two numbers ‘a’ and ‘b’ such that f(a)*f(b) < 0 and f(x) is continuous in [a, b]. Here f(x) represents algebraic or transcendental equation. Find root of function in interval [a, b] (Or find a value of x such that f(x) is 0).

```Input: A function of x, for example x3 – x2 + 2.
And two values: a = -200 and b = 300 such that
f(a)*f(b) < 0, i.e., f(a) and f(b) have
opposite signs.
Output: The value of root is : -1.00
OR any other value close to root.
```

We strongly recommend to refer below post as a prerequisite of this post.
Solution of Algebraic and Transcendental Equations | Set 1 (The Bisection Method)

In this post The Method Of False Position is discussed. This method is also known as Regula Falsi or The Method of Chords.

Similarities with Bisection Method:

1. Same Assumptions: This method also assumes that function is continuous in [a, b] and given two numbers 'a' and 'b' are such that f(a) * f(b) < 0.
2. Always Converges: like Bisection, it always converges, usually considerably faster than Bisection--but sometimes very much more slowly than Bisection.

Differences with Bisection Method:
It differs in the fact that we make a chord joining the two points [a, f(a)] and [b, f(b)]. We consider the point at which the chord touches the x axis and named it as c.

Steps:

1. Write equation of the line connecting the two points.
```y – f(a) =  ( (f(b)-f(a))/(b-a) )*(x-a)

Now we have to find the point which touches x axis.
For that we put y = 0.

so x = a - (f(a)/(f(b)-f(a))) * (b-a)
x = (a*f(b) - b*f(a)) / (f(b)-f(a))

This will be our c that is c = x. ```
2. If f(c) == 0, then c is the root of the solution.
3. Else f(c) != 0
1. If value f(a)*f(c) < 0 then root lies between a and c. So we recur for a and c
2. Else If f(b)*f(c) < 0 then root lies between b and c. So we recur b and c.
3. Else given function doesn't follow one of assumptions.

Since root may be a floating point number and may converge very slow in worst case, we iterate for a very large number of times such that the answer becomes closer to the root. Following is the implementation.

## C++

 `// C++ program for implementation of Bisection Method for ` `// solving equations ` `#include ` `using` `namespace` `std; ` `#define MAX_ITER 1000000 ` ` `  `// An example function whose solution is determined using ` `// Bisection Method. The function is x^3 - x^2  + 2 ` `double` `func(``double` `x) ` `{ ` `    ``return` `x*x*x - x*x + 2; ` `} ` ` `  `// Prints root of func(x) in interval [a, b] ` `void` `regulaFalsi(``double` `a, ``double` `b) ` `{ ` `    ``if` `(func(a) * func(b) >= 0) ` `    ``{ ` `        ``cout << ``"You have not assumed right a and b\n"``; ` `        ``return``; ` `    ``} ` ` `  `    ``double` `c = a;  ``// Initialize result ` ` `  `    ``for` `(``int` `i=0; i < MAX_ITER; i++) ` `    ``{ ` `        ``// Find the point that touches x axis ` `        ``c = (a*func(b) - b*func(a))/ (func(b) - func(a)); ` ` `  `        ``// Check if the above found point is root ` `        ``if` `(func(c)==0) ` `            ``break``; ` ` `  `        ``// Decide the side to repeat the steps ` `        ``else` `if` `(func(c)*func(a) < 0) ` `            ``b = c; ` `        ``else` `            ``a = c; ` `    ``} ` `    ``cout << ``"The value of root is : "` `<< c; ` `} ` ` `  `// Driver program to test above function ` `int` `main() ` `{ ` `    ``// Initial values assumed ` `    ``double` `a =-200, b = 300; ` `    ``regulaFalsi(a, b); ` `    ``return` `0; ` `} `

## Java

 `// java program for implementation  ` `// of Bisection Method for ` `// solving equations ` `import` `java.io.*; ` ` `  `class` `GFG { ` ` `  `    ``static` `int` `MAX_ITER = ``1000000``; ` ` `  `    ``// An example function whose  ` `    ``// solution is determined using ` `    ``// Bisection Method. The function ` `    ``// is x^3 - x^2 + 2 ` `    ``static` `double` `func(``double` `x) ` `    ``{ ` `        ``return` `(x * x * x - x * x + ``2``); ` `    ``} ` ` `  `    ``// Prints root of func(x)  ` `    ``// in interval [a, b] ` `    ``static` `void` `regulaFalsi(``double` `a, ``double` `b) ` `    ``{ ` `        ``if` `(func(a) * func(b) >= ``0``)  ` `        ``{ ` `            ``System.out.println(``"You have not assumed right a and b"``); ` `        ``} ` `        ``// Initialize result ` `        ``double` `c = a;  ` ` `  `        ``for` `(``int` `i = ``0``; i < MAX_ITER; i++)  ` `        ``{ ` `            ``// Find the point that touches x axis ` `            ``c = (a * func(b) - b * func(a))  ` `                 ``/ (func(b) - func(a)); ` ` `  `            ``// Check if the above found point is root ` `            ``if` `(func(c) == ``0``) ` `                ``break``; ` ` `  `            ``// Decide the side to repeat the steps ` `            ``else` `if` `(func(c) * func(a) < ``0``) ` `                ``b = c; ` `            ``else` `                ``a = c; ` `        ``} ` `        ``System.out.println(``"The value of root is : "` `+ (``int``)c); ` `    ``} ` ` `  `    ``// Driver program  ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``// Initial values assumed ` `        ``double` `a = -``200``, b = ``300``; ` `        ``regulaFalsi(a, b); ` `    ``} ` `} ` ` `  `// This article is contributed by vt_m `

## Python3

 `# Python3 implementation of Bisection ` `# Method for solving equations ` ` `  `MAX_ITER ``=` `1000000` ` `  `# An example function whose solution ` `# is determined using Bisection Method.  ` `# The function is x^3 - x^2 + 2 ` `def` `func( x ): ` `    ``return` `(x ``*` `x ``*` `x ``-` `x ``*` `x ``+` `2``) ` ` `  `# Prints root of func(x) in interval [a, b] ` `def` `regulaFalsi( a , b): ` `    ``if` `func(a) ``*` `func(b) >``=` `0``: ` `        ``print``(``"You have not assumed right a and b"``) ` `        ``return` `-``1` `     `  `    ``c ``=` `a ``# Initialize result ` `     `  `    ``for` `i ``in` `range``(MAX_ITER): ` `         `  `        ``# Find the point that touches x axis ` `        ``c ``=` `(a ``*` `func(b) ``-` `b ``*` `func(a))``/` `(func(b) ``-` `func(a)) ` `         `  `        ``# Check if the above found point is root ` `        ``if` `func(c) ``=``=` `0``: ` `            ``break` `         `  `        ``# Decide the side to repeat the steps ` `        ``elif` `func(c) ``*` `func(a) < ``0``: ` `            ``b ``=` `c ` `        ``else``: ` `            ``a ``=` `c ` `    ``print``(``"The value of root is : "` `, ``'%.4f'` `%``c) ` ` `  `# Driver code to test above function ` `# Initial values assumed ` `a ``=``-``200` `b ``=` `300` `regulaFalsi(a, b) ` ` `  `# This code is contributed by "Sharad_Bhardwaj". `

## C#

 `// C# program for implementation  ` `// of Bisection Method for ` `// solving equations ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``static` `int` `MAX_ITER = 1000000; ` ` `  `    ``// An example function whose  ` `    ``// solution is determined using ` `    ``// Bisection Method. The function ` `    ``// is x^3 - x^2 + 2 ` `    ``static` `double` `func(``double` `x) ` `    ``{ ` `        ``return` `(x * x * x - x * x + 2); ` `    ``} ` ` `  `    ``// Prints root of func(x)  ` `    ``// in interval [a, b] ` `    ``static` `void` `regulaFalsi(``double` `a, ``double` `b) ` `    ``{ ` `        ``if` `(func(a) * func(b) >= 0)  ` `        ``{ ` `            ``Console.WriteLine(``"You have not assumed right a and b"``); ` `        ``} ` `        ``// Initialize result ` `        ``double` `c = a;  ` ` `  `        ``for` `(``int` `i = 0; i < MAX_ITER; i++)  ` `        ``{ ` `            ``// Find the point that touches x axis ` `            ``c = (a * func(b) - b * func(a))  ` `                ``/ (func(b) - func(a)); ` ` `  `            ``// Check if the above found point is root ` `            ``if` `(func(c) == 0) ` `                ``break``; ` ` `  `            ``// Decide the side to repeat the steps ` `            ``else` `if` `(func(c) * func(a) < 0) ` `                ``b = c; ` `            ``else` `                ``a = c; ` `        ``} ` ` `  `        ``Console.WriteLine(``"The value of root is : "` `+ (``int``)c); ` `    ``} ` ` `  `    ``// Driver program  ` `    ``public` `static` `void` `Main(String []args) ` `    ``{ ` `        ``// Initial values assumed ` `        ``double` `a = -200, b = 300; ` `        ``regulaFalsi(a, b); ` `    ``} ` `} ` ` `  `// This code is contributed by Sam007. `

Output:

`The value of root is : -1`

This method always converges, usually considerably faster than Bisection. But worst case can be very slow.

We will soon be discussing other methods to solve algebraic and transcendental equations.