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

Basic bisection routine to find a zero of the function f between the arguments a and b. :None:None:`f(a)` and :None:None:`f(b)` cannot have the same signs. Slow but sure.

Parameters

f : function

Python function returning a number. f must be continuous, and f(a) and f(b) must have opposite signs.

a : scalar

One end of the bracketing interval [a,b].

b : scalar

The other end of the bracketing interval [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 nonnegative.

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 .

maxiter : int, optional

If convergence is not achieved in :None:None:`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 :None:None:`full_output` is False, the root is returned. If :None:None:`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 a RootResults return object.

Returns

x0 : float

Zero 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.

Find root of a function within an interval using bisection.

See Also

bisect

brenth

brentq

fixed_point

scalar fixed-point finder

fsolve

n-dimensional root-finding

newton

Examples

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

>>> from scipy import optimize

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

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

See :

Back References

The following pages refer to to this document either explicitly or contain code examples using this.

scipy.optimize._zeros_py.bisect scipy.optimize._zeros_py.toms748

Local connectivity graph

Hover to see nodes names; edges to Self not shown, Caped at 50 nodes.

Using a canvas is more power efficient and can get hundred of nodes ; but does not allow hyperlinks; , arrows or text (beyond on hover)

SVG is more flexible but power hungry; and does not scale well to 50 + nodes.

All aboves nodes referred to, (or are referred from) current nodes; Edges from Self to other have been omitted (or all nodes would be connected to the central node "self" which is not useful). Nodes are colored by the library they belong to, and scaled with the number of references pointing them

---

GitHub : /scipy/optimize/_zeros_py.py#475
type: <class 'function'>
Commit: