{ } Raw JSON

bundles / scipy 1.17.1 / scipy / optimize / _zeros_py / brentq

function

scipy.optimize._zeros_py:brentq

source: /scipy/optimize/_zeros_py.py :712

Signature

def   brentq ( f a b args = () xtol = 2e-12 rtol = 8.881784197001252e-16 maxiter = 100 full_output = False disp = True )

Summary

Find a root of a function in a bracketing interval using Brent's method.

Extended Summary

Uses the classic Brent's method to find a root of the function f on the sign changing interval [a , b]. Generally considered the best of the rootfinding routines here. It is a safe version of the secant method that uses inverse quadratic extrapolation. Brent's method combines root bracketing, interval bisection, and inverse quadratic 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 must be continuous, and and must have opposite signs.

a : scalar

One end of the bracketing interval .

b : scalar

The other end of the bracketing interval .

xtol : number, optional

The computed root x0 will satisfy np.isclose(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.isclose(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.

Notes

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

As mentioned in the parameter documentation, the computed root x0 will satisfy np.isclose(x, x0, atol=xtol, rtol=rtol), where x is the exact root. In equation form, this terminating condition is abs(x - x0) <= xtol + rtol * abs(x0).

The default value xtol=2e-12 may lead to surprising behavior if one expects brentq to always compute roots with relative error near machine precision. Care should be taken to select xtol for the use case at hand. Setting xtol=5e-324, the smallest subnormal number, will ensure the highest level of accuracy. Larger values of xtol may be useful for saving function evaluations when a root is at or near zero in applications where the tiny absolute differences available between floating point numbers near zero are not meaningful.

Examples

def f(x):
    return (x**2 - 1)
from scipy import optimize
root = optimize.brentq(f, -2, 0)
root
root = optimize.brentq(f, 0, 2)
root

See also

basinhopping

global optimizers

bisect

1-D root-finding

bracket

local scalar minimizers

brent

local scalar minimizers

brenth

1-D root-finding

brute

global optimizers

differential_evolution

global optimizers

elementwise.find_root

efficient elementwise 1-D root-finder

fixed_point

scalar fixed-point finder

fmin

multivariate local optimizers

fmin_bfgs

multivariate local optimizers

fmin_cg

multivariate local optimizers

fmin_cobyla

constrained multivariate optimizers

fmin_l_bfgs_b

constrained multivariate optimizers

fmin_ncg

multivariate local optimizers

fmin_powell

multivariate local optimizers

fmin_tnc

constrained multivariate optimizers

fminbound

local scalar minimizers

fsolve

N-D root-finding

golden

local scalar minimizers

leastsq

nonlinear least squares minimizer

newton

1-D root-finding

ridder

1-D root-finding

Aliases

  • scipy.optimize.brentq

Referenced by