code: def central_diff_weights(Np, ndiv=1):
      """
      Return weights for an Np-point central derivative.
  
      Assumes equally-spaced function points.
  
      If weights are in the vector w, then
      derivative is w[0] * f(x-ho*dx) + ... + w[-1] * f(x+h0*dx)
  
      Parameters
      ----------
      Np : int
          Number of points for the central derivative.
      ndiv : int, optional
          Number of divisions. Default is 1.
  
      Returns
      -------
      w : ndarray
          Weights for an Np-point central derivative. Its size is `Np`.
  
      Notes
      -----
      Can be inaccurate for a large number of points.
  
      Examples
      --------
      We can calculate a derivative value of a function.
  
      >>> from scipy.misc import central_diff_weights
      >>> def f(x):
      ...     return 2 * x**2 + 3
      >>> x = 3.0 # derivative point
      >>> h = 0.1 # differential step
      >>> Np = 3 # point number for central derivative
      >>> weights = central_diff_weights(Np) # weights for first derivative
      >>> vals = [f(x + (i - Np/2) * h) for i in range(Np)]
      >>> sum(w * v for (w, v) in zip(weights, vals))/h
      11.79999999999998
  
      This value is close to the analytical solution:
      f'(x) = 4x, so f'(3) = 12
  
      References
      ----------
      .. [1] https://en.wikipedia.org/wiki/Finite_difference
  
      """
      if Np < ndiv + 1:
          raise ValueError(
              "Number of points must be at least the derivative order + 1."
          )
      if Np % 2 == 0:
          raise ValueError("The number of points must be odd.")
      from scipy import linalg
  
      ho = Np >> 1
      x = arange(-ho, ho + 1.0)
      x = x[:, newaxis]
      X = x**0.0
      for k in range(1, Np):
          X = hstack([X, x**k])
      w = prod(arange(1, ndiv + 1), axis=0) * linalg.inv(X)[ndiv]
      return w
  
imports: from numpy import arange, newaxis, hstack, prod, array, frombuffer, load
label_desc: Use image node_id 1 for calling a global function with example usage: central_diff_weights(Np, ndiv) and returns: w