code: def approx_fprime(xk, f, epsilon, *args):
      """Finite-difference approximation of the gradient of a scalar function.
  
      Parameters
      ----------
      xk : array_like
          The coordinate vector at which to determine the gradient of `f`.
      f : callable
          The function of which to determine the gradient (partial derivatives).
          Should take `xk` as first argument, other arguments to `f` can be
          supplied in ``*args``. Should return a scalar, the value of the
          function at `xk`.
      epsilon : array_like
          Increment to `xk` to use for determining the function gradient.
          If a scalar, uses the same finite difference delta for all partial
          derivatives. If an array, should contain one value per element of
          `xk`.
      \\*args : args, optional
          Any other arguments that are to be passed to `f`.
  
      Returns
      -------
      grad : ndarray
          The partial derivatives of `f` to `xk`.
  
      See Also
      --------
      check_grad : Check correctness of gradient function against approx_fprime.
  
      Notes
      -----
      The function gradient is determined by the forward finite difference
      formula::
  
                   f(xk[i] + epsilon[i]) - f(xk[i])
          f'[i] = ---------------------------------
                              epsilon[i]
  
      The main use of `approx_fprime` is in scalar function optimizers like
      `fmin_bfgs`, to determine numerically the Jacobian of a function.
  
      Examples
      --------
      >>> from scipy import optimize
      >>> def func(x, c0, c1):
      ...     "Coordinate vector `x` should be an array of size two."
      ...     return c0 * x[0]**2 + c1*x[1]**2
  
      >>> x = np.ones(2)
      >>> c0, c1 = (1, 200)
      >>> eps = np.sqrt(np.finfo(float).eps)
      >>> optimize.approx_fprime(x, func, [eps, np.sqrt(200) * eps], c0, c1)
      array([   2.        ,  400.00004198])
  
      """
      xk = np.asarray(xk, float)
  
      f0 = f(xk, *args)
      if not np.isscalar(f0):
          try:
              f0 = f0.item()
          except (ValueError, AttributeError) as e:
              raise ValueError(
                  "The user-provided "
                  "objective function must "
                  "return a scalar value."
              ) from e
  
      return approx_derivative(
          f, xk, method="2-point", abs_step=epsilon, args=args, f0=f0
      )
  
imports: import warnings
  import sys
  from numpy import atleast_1d, eye, argmin, zeros, shape, squeeze, asarray, sqrt, Inf, asfarray, isinf
  import numpy
  from .linesearch import line_search_wolfe1, line_search_wolfe2, line_search_wolfe2, LineSearchWarning
  from ._numdiff import approx_derivative
  from scipy._lib._util import getfullargspec_no_self
  from scipy._lib._util import MapWrapper
  from scipy.optimize._differentiable_functions import ScalarFunction, FD_METHODS
label_desc: Use image node_id 14 for calling a global function with example usage: approx_fprime(xk, f, epsilon) and returns: approx_derivative