atic interpolation. It is
sometimes known as the van Wijngaarden-Dekker-Brent method. Brent (1973)
claims convergence is guaranteed for functions computable within [a,b].

[Brent1973]_ provides the classic description of the algorithm. Another
description can be found in a recent edition of Numerical Recipes, including
[PressEtal1992]_. A third description is at
http://mathworld.wolfram.com/BrentsMethod.html. It should be easy to
understand the algorithm just by reading our code. Our code diverges a bit
from standard presentations: we choose a different formula for the
extrapolation step.

Parameters
----------
f : function
    Python function returning a number. The function :math:`f`
    must be continuous, and :math:`f(a)` and :math:`f(b)` must
    have opposite signs.
a : scalar
    One end of the bracketing interval :math:`[a, b]`.
b : scalar
    The other end of the bracketing interval :math:`[a, b]`.
xtol : number, optional
    The computed root ``x0`` will satisfy ``np.allclose(x, x0,
    atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The
    parameter must be positive. For nice functions, Brent's
    method will often satisfy the above condition with ``xtol/2``
    and ``rtol/2``. [Brent1973]_
rtol : number, optional
    The computed root ``x0`` will satisfy ``np.allclose(x, x0,
    atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The
    parameter cannot be smaller than its default value of
    ``4*np.finfo(float).eps``. For nice functions, Brent's
    method will often satisfy the above condition with ``xtol/2``
    and ``rtol/2``. [Brent1973]_
maxiter : int, optional
    If convergence is not achieved in `maxiter` iterations, an error is
    raised. Must be >= 0.
args : tuple, optional
    Containing extra arguments for the function `f`.
    `f` is called by ``apply(f, (x)+args)``.
full_output : bool, optional
    If `full_output` is False, the root is returned. If `full_output` is
    True, the return value is ``(x, r)``, where `x` is the root, and `r` is
    a `RootResults` object.
disp : bool, optional
    If True, raise RuntimeError if the algorithm didn't converge.
    Otherwise, the convergence status is recorded in any `RootResults`
    return object.

Returns
-------
root : float
    Root of `f` between `a` and `b`.
r : `RootResults` (present if ``full_output = True``)
    Object containing information about the convergence. In particular,
    ``r.converged`` is True if the routine converged.

See Also
--------
fmin, fmin_powell, fmin_cg, fmin_bfgs, fmin_ncg : multivariate local optimizers
leastsq : nonlinear least squares minimizer
fmin_l_bfgs_b, fmin_tnc, fmin_cobyla : constrained multivariate optimizers
basinhopping, differential_evolution, brute : global optimizers
fminbound, brent, golden, bracket : local scalar minimizers
fsolve : N-D root-finding
brenth, ridder, bisect, newton : 1-D root-finding
fixed_point : scalar fixed-point finder

Notes
-----
`f` must be continuous.  f(a) and f(b) must have opposite signs.

References
----------
.. [Brent1973]
   Brent, R. P.,
   *Algorithms for Minimization Without Derivatives*.
   Englewood Cliffs, NJ: Prentice-Hall, 1973. Ch. 3-4.

.. [PressEtal1992]
   Press, W. H.; Flannery, B. P.; Teukolsky, S. A.; and Vetterling, W. T.
   *Numerical Recipes in FORTRAN: The Art of Scientific Computing*, 2nd ed.
   Cambridge, England: Cambridge University Press, pp. 352-355, 1992.
   Section 9.3:  "Van Wijngaarden-Dekker-Brent Method."

Examples
--------
>>> def f(x):
...     return (x**2 - 1)

>>> from scipy import optimize

>>> root = optimize.brentq(f, -2, 0)
>>> root
-1.0

>>> root = optimize.brentq(f, 0, 2)
>>> root
1.0
r