human
Complete this python program:
def bisect(f, a, b, args=(), xtol=_xtol, rtol=_rtol, maxiter=_iter, full_output=False, disp=True):
assistant
#Here is the Python code you requested.

    """Find root of a function within an interval.
    Basic bisection routine to find a zero of the function `f` between the
    arguments `a` and `b`. `f(a)` and `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 : number
    One end of the bracketing interval [a,b].
    b : number
    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 : number, 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.
    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.
    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 Also
    brentq, brenth, bisect, newton
    fixed_point : scalar fixed-point finder
    fsolve :..."""
    if (not isinstance(args, tuple)):
        args = (args,)
    if (xtol <= 0):
        raise ValueError(('xtol    too    small    (%g    <=    0)' % xtol))
    if (rtol < _rtol):
        raise ValueError(('rtol    too    small    (%g    <    %g)' % (rtol, _rtol)))
    r = _zeros._bisect(f, a, b, xtol, rtol, maxiter, args, full_output, disp)
    return results_c(full_output, r)