code: def hermeder(c, m=1, scl=1, axis=0):
      """
      Differentiate a Hermite_e series.
  
      Returns the series coefficients `c` differentiated `m` times along
      `axis`.  At each iteration the result is multiplied by `scl` (the
      scaling factor is for use in a linear change of variable). The argument
      `c` is an array of coefficients from low to high degree along each
      axis, e.g., [1,2,3] represents the series ``1*He_0 + 2*He_1 + 3*He_2``
      while [[1,2],[1,2]] represents ``1*He_0(x)*He_0(y) + 1*He_1(x)*He_0(y)
      + 2*He_0(x)*He_1(y) + 2*He_1(x)*He_1(y)`` if axis=0 is ``x`` and axis=1
      is ``y``.
  
      Parameters
      ----------
      c : array_like
          Array of Hermite_e series coefficients. If `c` is multidimensional
          the different axis correspond to different variables with the
          degree in each axis given by the corresponding index.
      m : int, optional
          Number of derivatives taken, must be non-negative. (Default: 1)
      scl : scalar, optional
          Each differentiation is multiplied by `scl`.  The end result is
          multiplication by ``scl**m``.  This is for use in a linear change of
          variable. (Default: 1)
      axis : int, optional
          Axis over which the derivative is taken. (Default: 0).
  
          .. versionadded:: 1.7.0
  
      Returns
      -------
      der : ndarray
          Hermite series of the derivative.
  
      See Also
      --------
      hermeint
  
      Notes
      -----
      In general, the result of differentiating a Hermite series does not
      resemble the same operation on a power series. Thus the result of this
      function may be "unintuitive," albeit correct; see Examples section
      below.
  
      Examples
      --------
      >>> from numpy.polynomial.hermite_e import hermeder
      >>> hermeder([ 1.,  1.,  1.,  1.])
      array([ 1.,  2.,  3.])
      >>> hermeder([-0.25,  1.,  1./2.,  1./3.,  1./4 ], m=2)
      array([ 1.,  2.,  3.])
  
      """
      c = np.array(c, ndmin=1, copy=1)
      if c.dtype.char in "?bBhHiIlLqQpP":
          c = c.astype(np.double)
      cnt, iaxis = [int(t) for t in [m, axis]]
  
      if cnt != m:
          raise ValueError("The order of derivation must be integer")
      if cnt < 0:
          raise ValueError(
              "The order of derivation must be non-negative"
          )
      if iaxis != axis:
          raise ValueError("The axis must be integer")
      iaxis = normalize_axis_index(iaxis, c.ndim)
  
      if cnt == 0:
          return c
  
      c = np.moveaxis(c, iaxis, 0)
      n = len(c)
      if cnt >= n:
          return c[:1] * 0
      else:
          for i in range(cnt):
              n = n - 1
              c *= scl
              der = np.empty((n,) + c.shape[1:], dtype=c.dtype)
              for j in range(n, 0, -1):
                  der[j - 1] = j * c[j]
              c = der
      c = np.moveaxis(c, 0, iaxis)
      return c
  
imports: from __future__ import division, absolute_import, print_function
  import warnings
  import numpy
  import numpy.linalg
  from numpy.core.multiarray import normalize_axis_index
  from .None import polyutils
  from ._polybase import ABCPolyBase
label_desc: Use image node_id 11 for calling a global function with example usage: hermeder(c, m, scl, axis) and returns: c, c, unknown