This article is about searching zeros of continuous functions.

A few steps of the bisection method applied over the starting range [a_{1};b_{1}]. The bigger red dot is the root of the function.

In mathematics, the **bisection method** is a root-finding method that applies to any continuous functions for which one knows two values with opposite signs. The method consists of repeatedly bisecting the interval defined by these values and then selecting the subinterval in which the function changes sign, and therefore must contain a root. It is a very simple and robust method, but it is also relatively slow. Because of this, it is often used to obtain a rough approximation to a solution which is then used as a starting point for more rapidly converging methods.^{[1]} The method is also called the **interval halving** method,^{[2]} the **binary search method**,^{[3]} or the **dichotomy method**.^{[4]}

For polynomials, more elaborated methods exists for testing the existence of a root in an interval (Descartes’ rule of signs, Sturm’s theorem, Budan’s theorem). They allow extending bisection method into efficient algorithms for finding all real roots of a polynomial;

## Contents

- The method
- Iteration tasks
- Algorithm

- Example: Finding the root of a polynomial
- Analysis
- See also
- References
- Further reading
- External links

## The Method

The method is applicable for numerically solving the equation *f*(*x*) = 0 for the real variable *x*, where *f* is a continuous function defined on an interval [*a*, *b*] and where *f*(*a*) and *f*(*b*) have opposite signs. In this case *a* and *b* are said to bracket a root since, by the intermediate value theorem, the continuous function *f* must have at least one root in the interval (*a*, *b*).

At each step the method divides the interval in two by computing the midpoint *c* = (*a*+*b*) / 2 of the interval and the value of the function *f*(*c*) at that point. Unless *c* is itself a root (which is very unlikely, but possible) there are now only two possibilities: either *f*(*a*) and *f*(*c*) have opposite signs and bracket a root, or *f*(*c*) and *f*(*b*) have opposite signs and bracket a root.^{[5]} The method selects the subinterval that is guaranteed to be a bracket as the new interval to be used in the next step. In this way an interval that contains a zero of *f* is reduced in width by 50% at each step. The process is continued until the interval is sufficiently small.

Explicitly, if *f*(*a*) and *f*(*c*) have opposite signs, then the method sets *c* as the new value for *b*, and if *f*(*b*) and *f*(*c*) have opposite signs then the method sets *c* as the new *a*. (If *f*(*c*)=0 then *c* may be taken as the solution and the process stops.) In both cases, the new *f*(*a*) and *f*(*b*) have opposite signs, so the method is applicable to this smaller interval.^{[6]}

### Iteration Tasks

The input for the method is a continuous function *f*, an interval [*a*, *b*], and the function values *f*(*a*) and *f*(*b*). The function values are of opposite sign (there is at least one zero crossing within the interval). Each iteration performs these steps:

- Calculate
*c*, the midpoint of the interval,*c*=*a*+*b*/2. - Calculate the function value at the midpoint,
*f*(*c*). - If convergence is satisfactory (that is,
*c*–*a*is sufficiently small, or |*f*(*c*)| is sufficiently small), return*c*and stop iterating. - Examine the sign of
*f*(*c*) and replace either (*a*,*f*(*a*)) or (*b*,*f*(*b*)) with (*c*,*f*(*c*)) so that there is a zero crossing within the new interval.

When implementing the method on a computer, there can be problems with finite precision, so there are often additional convergence tests or limits to the number of iterations. Although *f* is continuous, finite precision may preclude a function value ever being zero. For example, consider *f*(*x*) = *x* − π; there will never be a finite representation of *x* that gives zero. Additionally, the difference between *a* and *b* is limited by the floating point precision; i.e., as the difference between *a* and *b* decreases, at some point the midpoint of [*a*, *b*] will be numerically identical to (within floating point precision of) either *a* or *b*.

## Get a Bisection MATLAB Code

### Algorithm

The method may be written in pseudocode as follows:^{[7]}

INPUT:

Functionf,

endpoint valuesa,b,

toleranceTOL,

maximum iterationsNMAXCONDITIONS:a<b,

eitherf(a) < 0 andf(b) > 0 orf(a) > 0 andf(b) < 0OUTPUT:value which differs from a root off(x) = 0 by less thanTOLN← 1WhileN≤NMAX# limit iterations to prevent infinite loopc← (a+b)/2# new midpointIff(c) = 0 or (b–a)/2 <TOLthen# solution found

Output(c)StopEndIfN←N+ 1# increment step counterIfsign(f(c)) = sign(f(a))thena←celseb←c# new intervalEndWhile

Output(“Method failed.”)# max number of steps exceeded

## Example: Finding the Root of a Polynomial

Suppose that the bisection method is used to find a root of the polynomial

First, two numbers {a} and {b} have to be found such that {f(a)} and {f(b)} have opposite signs. For the above function, {a=1} and {b=2} satisfy this criterion, as

and

Because the function is continuous, there must be a root within the interval [1, 2].

In the first iteration, the end points of the interval which brackets the root are {a(1)=1} and {b(1)=2}, so the midpoint is

The function value at the midpoint is

Because {f(c(1))} is negative, {a=1} is replaced with {a=1.5} for the next iteration to ensure that {f(a)} and {f(b)} have opposite signs. As this continues, the interval between {a} and {b} will become increasingly smaller, converging on the root of the function. See this happen in the table below.

Iteration | an | bn | cn | f(cn) |
---|---|---|---|---|

1 | 1 | 2 | 1.5 | −0.125 |

2 | 1.5 | 2 | 1.75 | 1.6093750 |

3 | 1.5 | 1.75 | 1.625 | 0.6660156 |

4 | 1.5 | 1.625 | 1.5625 | 0.2521973 |

5 | 1.5 | 1.5625 | 1.5312500 | 0.0591125 |

6 | 1.5 | 1.5312500 | 1.5156250 | −0.0340538 |

7 | 1.5156250 | 1.5312500 | 1.5234375 | 0.0122504 |

8 | 1.5156250 | 1.5234375 | 1.5195313 | −0.0109712 |

9 | 1.5195313 | 1.5234375 | 1.5214844 | 0.0006222 |

10 | 1.5195313 | 1.5214844 | 1.5205078 | −0.0051789 |

11 | 1.5205078 | 1.5214844 | 1.5209961 | −0.0022794 |

12 | 1.5209961 | 1.5214844 | 1.5212402 | −0.0008289 |

13 | 1.5212402 | 1.5214844 | 1.5213623 | −0.0001034 |

14 | 1.5213623 | 1.5214844 | 1.5214233 | 0.0002594 |

15 | 1.5213623 | 1.5214233 | 1.5213928 | 0.0000780 |

After 13 iterations, it becomes apparent that there is a convergence to about 1.521: a root for the polynomial.

## Analysis

The method is guaranteed to converge to a root of *f* if *f* is a continuous function on the interval [*a*, *b*] and *f*(*a*) and *f*(*b*) have opposite signs. The absolute error is halved at each step so the method converges linearly, which is comparatively slow.

Specifically, if *c*_{1} = *a*+*b*/2 is the midpoint of the initial interval, and *c*_{n} is the midpoint of the interval in the *n*th step, then the difference between *c*_{n} and a solution *c* is bounded by^{[8]}

This formula can be used to determine in advance the number of iterations that the bisection method would need to converge to a root to within a certain tolerance. The number of iterations needed, *n*, to achieve a given error (or tolerance), ε, is given by:

where

Therefore, the linear convergence is expressed by

## Matlab Code for Bisection Method

## References

**Burden & Faires 1985, p. 31**- “Archived copy”. Archived from the original on 2013-05-19. Retrieved 2013-11-07.
- Burden & Faires 1985, p. 28
- “Dichotomy method – Encyclopedia of Mathematics”.
*www.encyclopediaofmath.org*. Retrieved 2015-12-21. - If the function has the same sign at the endpoints of an interval, the endpoints may or may not bracket roots of the function.
- Burden & Faires 1985, p. 28 for section
- Burden & Faires 1985, p. 29. This version recomputes the function values at each iteration rather than carrying them to the next iterations.
- Burden & Faires 1985, p. 31, Theorem 2.1

- Burden, Richard L.; Faires, J. Douglas (1985), “2.1 The Bisection Algorithm”,
*Numerical Analysis*(3rd ed.), PWS Publishers, ISBN 0-87150-857-5

## Further Reading

- Corliss, George (1977), “Which root does the bisection algorithm find?”,
*SIAM Review*,**19**(2): 325–327, doi:10.1137/1019044, ISSN 1095-7200 - Kaw, Autar; Kalu, Egwu (2008),
*Numerical Methods with Applications*(1st ed.), archived from the original on 2009-04-13

## External Links

- Weisstein, Eric W. “Bisection”.
*MathWorld*. - Bisection Method Notes, PPT, Mathcad, Maple, Matlab, Mathematica from Holistic Numerical Methods Institute