code: def chebder(c, m=1, scl=1, axis=0):
      """
      Differentiate a Chebyshev series.
  
      Returns the Chebyshev 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*T_0 + 2*T_1 + 3*T_2``
      while [[1,2],[1,2]] represents ``1*T_0(x)*T_0(y) + 1*T_1(x)*T_0(y) +
      2*T_0(x)*T_1(y) + 2*T_1(x)*T_1(y)`` if axis=0 is ``x`` and axis=1 is
      ``y``.
  
      Parameters
      ----------
      c : array_like
          Array of Chebyshev 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
          Chebyshev series of the derivative.
  
      See Also
      --------
      chebint
  
      Notes
      -----
      In general, the result of differentiating a C-series needs to be
      "reprojected" onto the C-series basis set. Thus, typically, the
      result of this function is "unintuitive," albeit correct; see Examples
      section below.
  
      Examples
      --------
      >>> from numpy.polynomial import chebyshev as C
      >>> c = (1,2,3,4)
      >>> C.chebder(c)
      array([14., 12., 24.])
      >>> C.chebder(c,3)
      array([96.])
      >>> C.chebder(c,scl=-1)
      array([-14., -12., -24.])
      >>> C.chebder(c,2,-1)
      array([12.,  96.])
  
      """
      c = np.array(c, ndmin=1, copy=True)
      if c.dtype.char in "?bBhHiIlLqQpP":
          c = c.astype(np.double)
      cnt = pu._deprecate_as_int(m, "the order of derivation")
      iaxis = pu._deprecate_as_int(axis, "the axis")
      if cnt < 0:
          raise ValueError(
              "The order of derivation must be non-negative"
          )
      iaxis = normalize_axis_index(iaxis, c.ndim)
  
      if cnt == 0:
          return c
  
      c = np.moveaxis(c, iaxis, 0)
      n = len(c)
      if cnt >= n:
          c = 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, 2, -1):
                  der[j - 1] = (2 * j) * c[j]
                  c[j - 2] += (j * c[j]) / (j - 2)
              if n > 1:
                  der[1] = 4 * c[2]
              der[0] = c[1]
              c = der
      c = np.moveaxis(c, 0, iaxis)
      return c
  
imports: 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 17 for calling a global function with example usage: chebder(c, m, scl, axis) and returns: c, c