code: def derivative(func, x0, dx=1.0, n=1, args=(), order=3):
      """
      Find the nth derivative of a function at a point.
  
      Given a function, use a central difference formula with spacing `dx` to
      compute the nth derivative at `x0`.
  
      Parameters
      ----------
      func : function
          Input function.
      x0 : float
          The point at which the nth derivative is found.
      dx : float, optional
          Spacing.
      n : int, optional
          Order of the derivative. Default is 1.
      args : tuple, optional
          Arguments
      order : int, optional
          Number of points to use, must be odd.
  
      Notes
      -----
      Decreasing the step size too small can result in round-off error.
  
      Examples
      --------
      >>> from scipy.misc import derivative
      >>> def f(x):
      ...     return x**3 + x**2
      >>> derivative(f, 1.0, dx=1e-6)
      4.9999999999217337
  
      """
      if order < n + 1:
          raise ValueError(
              "'order' (the number of points used to compute the derivative), "
              "must be at least the derivative order 'n' + 1."
          )
      if order % 2 == 0:
          raise ValueError(
              "'order' (the number of points used to compute the derivative) "
              "must be odd."
          )
      # pre-computed for n=1 and 2 and low-order for speed.
      if n == 1:
          if order == 3:
              weights = array([-1, 0, 1]) / 2.0
          elif order == 5:
              weights = array([1, -8, 0, 8, -1]) / 12.0
          elif order == 7:
              weights = array([-1, 9, -45, 0, 45, -9, 1]) / 60.0
          elif order == 9:
              weights = (
                  array([3, -32, 168, -672, 0, 672, -168, 32, -3])
                  / 840.0
              )
          else:
              weights = central_diff_weights(order, 1)
      elif n == 2:
          if order == 3:
              weights = array([1, -2.0, 1])
          elif order == 5:
              weights = array([-1, 16, -30, 16, -1]) / 12.0
          elif order == 7:
              weights = array([2, -27, 270, -490, 270, -27, 2]) / 180.0
          elif order == 9:
              weights = (
                  array(
                      [
                          -9,
                          128,
                          -1008,
                          8064,
                          -14350,
                          8064,
                          -1008,
                          128,
                          -9,
                      ]
                  )
                  / 5040.0
              )
          else:
              weights = central_diff_weights(order, 2)
      else:
          weights = central_diff_weights(order, n)
      val = 0.0
      ho = order >> 1
      for k in range(order):
          val += weights[k] * func(x0 + (k - ho) * dx, *args)
      return val / prod((dx,) * n, axis=0)
  
imports: from numpy import arange, newaxis, hstack, prod, array, frombuffer, load
label_desc: Use image node_id 2 for calling a global function with example usage: derivative(func, x0, dx, n, args, order) and returns: unknown