code: def limit(ctx, f, x, direction=1, exp=False, **kwargs):
      r"""
      Computes an estimate of the limit
  
      .. math ::
  
          \lim_{t \to x} f(t)
  
      where `x` may be finite or infinite.
  
      For finite `x`, :func:`~mpmath.limit` evaluates `f(x + d/n)` for
      consecutive integer values of `n`, where the approach direction
      `d` may be specified using the *direction* keyword argument.
      For infinite `x`, :func:`~mpmath.limit` evaluates values of
      `f(\mathrm{sign}(x) \cdot n)`.
  
      If the approach to the limit is not sufficiently fast to give
      an accurate estimate directly, :func:`~mpmath.limit` attempts to find
      the limit using Richardson extrapolation or the Shanks
      transformation. You can select between these methods using
      the *method* keyword (see documentation of :func:`~mpmath.nsum` for
      more information).
  
      **Options**
  
      The following options are available with essentially the
      same meaning as for :func:`~mpmath.nsum`: *tol*, *method*, *maxterms*,
      *steps*, *verbose*.
  
      If the option *exp=True* is set, `f` will be
      sampled at exponentially spaced points `n = 2^1, 2^2, 2^3, \ldots`
      instead of the linearly spaced points `n = 1, 2, 3, \ldots`.
      This can sometimes improve the rate of convergence so that
      :func:`~mpmath.limit` may return a more accurate answer (and faster).
      However, do note that this can only be used if `f`
      supports fast and accurate evaluation for arguments that
      are extremely close to the limit point (or if infinite,
      very large arguments).
  
      **Examples**
  
      A basic evaluation of a removable singularity::
  
          >>> from mpmath import *
          >>> mp.dps = 30; mp.pretty = True
          >>> limit(lambda x: (x-sin(x))/x**3, 0)
          0.166666666666666666666666666667
  
      Computing the exponential function using its limit definition::
  
          >>> limit(lambda n: (1+3/n)**n, inf)
          20.0855369231876677409285296546
          >>> exp(3)
          20.0855369231876677409285296546
  
      A limit for `\pi`::
  
          >>> f = lambda n: 2**(4*n+1)*fac(n)**4/(2*n+1)/fac(2*n)**2
          >>> limit(f, inf)
          3.14159265358979323846264338328
  
      Calculating the coefficient in Stirling's formula::
  
          >>> limit(lambda n: fac(n) / (sqrt(n)*(n/e)**n), inf)
          2.50662827463100050241576528481
          >>> sqrt(2*pi)
          2.50662827463100050241576528481
  
      Evaluating Euler's constant `\gamma` using the limit representation
  
      .. math ::
  
          \gamma = \lim_{n \rightarrow \infty } \left[ \left(
          \sum_{k=1}^n \frac{1}{k} \right) - \log(n) \right]
  
      (which converges notoriously slowly)::
  
          >>> f = lambda n: sum([mpf(1)/k for k in range(1,int(n)+1)]) - log(n)
          >>> limit(f, inf)
          0.577215664901532860606512090082
          >>> +euler
          0.577215664901532860606512090082
  
      With default settings, the following limit converges too slowly
      to be evaluated accurately. Changing to exponential sampling
      however gives a perfect result::
  
          >>> f = lambda x: sqrt(x**3+x**2)/(sqrt(x**3)+x)
          >>> limit(f, inf)
          0.992831158558330281129249686491
          >>> limit(f, inf, exp=True)
          1.0
  
      """
  
      if ctx.isinf(x):
          direction = ctx.sign(x)
          g = lambda k: f(ctx.mpf(k + 1) * direction)
      else:
          direction *= ctx.one
          g = lambda k: f(x + direction / (k + 1))
      if exp:
          h = g
          g = lambda k: h(2**k)
  
      def update(values, indices):
          for k in indices:
              values.append(g(k + 1))
  
      # XXX: steps used by nsum don't work well
      if not "steps" in kwargs:
          kwargs["steps"] = [10]
  
      return +ctx.adaptive_extrapolation(update, None, kwargs)
  
imports: from ..libmp.backend import xrange
  from .calculus import defun
label_desc: Use image node_id 16 for calling a global function with example usage: limit(ctx, f, x, direction, exp) and returns: unknown