code: def differint(ctx, f, x, n=1, x0=0):
      r"""
      Calculates the Riemann-Liouville differintegral, or fractional
      derivative, defined by
  
      .. math ::
  
          \,_{x_0}{\mathbb{D}}^n_xf(x) = \frac{1}{\Gamma(m-n)} \frac{d^m}{dx^m}
          \int_{x_0}^{x}(x-t)^{m-n-1}f(t)dt
  
      where `f` is a given (presumably well-behaved) function,
      `x` is the evaluation point, `n` is the order, and `x_0` is
      the reference point of integration (`m` is an arbitrary
      parameter selected automatically).
  
      With `n = 1`, this is just the standard derivative `f'(x)`; with `n = 2`,
      the second derivative `f''(x)`, etc. With `n = -1`, it gives
      `\int_{x_0}^x f(t) dt`, with `n = -2`
      it gives `\int_{x_0}^x \left( \int_{x_0}^t f(u) du \right) dt`, etc.
  
      As `n` is permitted to be any number, this operator generalizes
      iterated differentiation and iterated integration to a single
      operator with a continuous order parameter.
  
      **Examples**
  
      There is an exact formula for the fractional derivative of a
      monomial `x^p`, which may be used as a reference. For example,
      the following gives a half-derivative (order 0.5)::
  
          >>> from mpmath import *
          >>> mp.dps = 15; mp.pretty = True
          >>> x = mpf(3); p = 2; n = 0.5
          >>> differint(lambda t: t**p, x, n)
          7.81764019044672
          >>> gamma(p+1)/gamma(p-n+1) * x**(p-n)
          7.81764019044672
  
      Another useful test function is the exponential function, whose
      integration / differentiation formula easy generalizes
      to arbitrary order. Here we first compute a third derivative,
      and then a triply nested integral. (The reference point `x_0`
      is set to `-\infty` to avoid nonzero endpoint terms.)::
  
          >>> differint(lambda x: exp(pi*x), -1.5, 3)
          0.278538406900792
          >>> exp(pi*-1.5) * pi**3
          0.278538406900792
          >>> differint(lambda x: exp(pi*x), 3.5, -3, -inf)
          1922.50563031149
          >>> exp(pi*3.5) / pi**3
          1922.50563031149
  
      However, for noninteger `n`, the differentiation formula for the
      exponential function must be modified to give the same result as the
      Riemann-Liouville differintegral::
  
          >>> x = mpf(3.5)
          >>> c = pi
          >>> n = 1+2*j
          >>> differint(lambda x: exp(c*x), x, n)
          (-123295.005390743 + 140955.117867654j)
          >>> x**(-n) * exp(c)**x * (x*c)**n * gammainc(-n, 0, x*c) / gamma(-n)
          (-123295.005390743 + 140955.117867654j)
  
  
      """
      m = max(int(ctx.ceil(ctx.re(n))) + 1, 1)
      r = m - n - 1
      g = lambda x: ctx.quad(lambda t: (x - t) ** r * f(t), [x0, x])
      return ctx.diff(g, x, m) / ctx.gamma(m - n)
  
file_path: catboost/contrib/python/mpmath/py3/mpmath/calculus/differentiation.py
imports: from ..libmp.backend import xrange
  from .calculus import defun
label_desc: Use image node_id 10 for calling a global function with example usage: differint(ctx, f, x, n, x0) and returns: unknown