code: def ridder(
      f,
      a,
      b,
      args=(),
      xtol=_xtol,
      rtol=_rtol,
      maxiter=_iter,
      full_output=False,
      disp=True,
  ):
      """
      Find a root of a function in an interval using Ridder's method.
  
      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 `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
      -------
      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.
  
      See Also
      --------
      brentq, brenth, bisect, newton : one-dimensional root-finding
      fixed_point : scalar fixed-point finder
  
      Notes
      -----
      Uses [Ridders1979]_ method to find a zero of the function `f` between the
      arguments `a` and `b`. Ridders' method is faster than bisection, but not
      generally as fast as the Brent routines. [Ridders1979]_ provides the
      classic description and source of the algorithm. A description can also be
      found in any recent edition of Numerical Recipes.
  
      The routine used here diverges slightly from standard presentations in
      order to be a bit more careful of tolerance.
  
      References
      ----------
      .. [Ridders1979]
         Ridders, C. F. J. "A New Algorithm for Computing a
         Single Root of a Real Continuous Function."
         IEEE Trans. Circuits Systems 26, 979-980, 1979.
  
      Examples
      --------
  
      >>> def f(x):
      ...     return (x**2 - 1)
  
      >>> from scipy import optimize
  
      >>> root = optimize.ridder(f, 0, 2)
      >>> root
      1.0
  
      >>> root = optimize.ridder(f, -2, 0)
      >>> root
      -1.0
      """
      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._ridder(
          f, a, b, xtol, rtol, maxiter, args, full_output, disp
      )
      return results_c(full_output, r)
  
imports: from __future__ import division, print_function, absolute_import
  import warnings
  from collections import namedtuple
  from .None import _zeros
  import numpy
label_desc: Use image node_id 6 for calling a global function with example usage: ridder(f, a, b, args, xtol, rtol, maxiter, full_output, disp) and returns: results_c