# Root-finding algorithm

A **root-finding algorithm** is a numerical method, or algorithm, for finding a value *x* such that *f*(*x*) = 0, for a given function *f*. Such an *x* is called a root of the function *f*.

Finding a root of *f* − *g* is the same as solving the equation *f*(*x*) = *g*(*x*). Here, *x* is called the *unknown* in the equation. Conversely, any equation can take the canonical form *f*(*x*) = 0, so equation solving is the same thing as computing (or *finding*) a root of a function.

All numerical root-finding methods use iteration, producing a sequence of numbers (hopefully) converging towards a limit which is a root. The first values of this series are *initial guesses*. The method computes subsequent values based on the old ones and the function *f*.

The behaviour of root-finding algorithms is studied in numerical analysis.

## Specific algorithms

The simplest root-finding algorithm is the bisection method. It works when *f* is a continuous function and it requires previous knowledge of two initial guesses, *a* and *b*, such that *f*(*a*) and *f*(*b*) have opposite signs.

Newton's method, assumes the function *f* to have a derivative. Newton's method may not converge if you start too far away from a root. However, if it does converge, it is faster than the bisection method (convergence is quadratic). Newton's method is also important because it readily generalizes to higher-dimensional problems.

Replacing the derivative in Newton's method with a finite difference, we get the secant method. This method does not require the computation (nor the existence) of a derivative, but the price is slower convergence (the order is approximately 1.6).

The false position method, also called the *regula falsi* method, is like the bisection method. However, it does not cut the interval in two equal parts at every iteration, but it cuts the interval at the point given by the formula for the secant method. The false position method inherits the robustness of the bisection method and the superlinear convergence of the secant method.

The secant method also arises if one approximates the unknown function *f* by linear interpolation. When quadratic interpolation is used instead, one arrives at Müller's method. It converges faster than the secant method. A particular feature of this method is that the iterates *x*_{n} may become complex.

This can be avoided by interpolating the inverse of *f*, resulting in the inverse quadratic interpolation method. Again, convergence is asymptotically faster than the secant method, but inverse quadratic interpolation often behaves poorly when the iterates are not close to the root.

Finally, Brent's method is a combination of the bisection method, the secant method and inverse quadratic interpolation. At every iteration, Brent's method decides which method out of these three is likely to do best, and proceeds by doing a step according to that method. This gives a robust and fast method, which therefore enjoys considerable popularity.

## Finding roots of polynomials

Much attention has been given to the special case that the function *f* is a polynomial; there exist root-finding algorithms exploiting the polynomial nature of *f*.

One possibility is to form the companion matrix of the polynomial. Since the eigenvalues of this matrix coincide with the roots of the polynomial, one can use any eigenvalue algorithm to find the roots of the polynomial.

Laguerre's method is rather complicated, but it converges fast. It exhibits cubic convergence for simple roots, beating the quadratic convergence displayed by Newton's method.

Bairstow's method uses Newton's method to find quadratic factors of a polynomial with real coefficients. It can determine both real and complex roots of a real polynomial using only real arithmetic.

The Durand-Kerner method simultaneously finds all the roots using only simple complex number arithmetic.

The splitting circle method is useful for finding the roots of polynomials of high degree to arbitrary precision; it has almost optimal complexity in this setting.