code: def splder(tck, n=1):
      """
      Compute the spline representation of the derivative of a given spline
  
      Parameters
      ----------
      tck : tuple of (t, c, k)
          Spline whose derivative to compute
      n : int, optional
          Order of derivative to evaluate. Default: 1
  
      Returns
      -------
      tck_der : tuple of (t2, c2, k2)
          Spline of order k2=k-n representing the derivative
          of the input spline.
  
      Notes
      -----
  
      .. versionadded:: 0.13.0
  
      See Also
      --------
      splantider, splev, spalde
  
      Examples
      --------
      This can be used for finding maxima of a curve:
  
      >>> from scipy.interpolate import splrep, splder, sproot
      >>> x = np.linspace(0, 10, 70)
      >>> y = np.sin(x)
      >>> spl = splrep(x, y, k=4)
  
      Now, differentiate the spline and find the zeros of the
      derivative. (NB: `sproot` only works for order 3 splines, so we
      fit an order 4 spline):
  
      >>> dspl = splder(spl)
      >>> sproot(dspl) / np.pi
      array([ 0.50000001,  1.5       ,  2.49999998])
  
      This agrees well with roots :math:`\\pi/2 + n\\pi` of
      :math:`\\cos(x) = \\sin'(x)`.
  
      """
      if n < 0:
          return splantider(tck, -n)
  
      t, c, k = tck
  
      if n > k:
          raise ValueError(
              (
                  "Order of derivative (n = %r) must be <= "
                  "order of spline (k = %r)"
              )
              % (n, tck[2])
          )
  
      # Extra axes for the trailing dims of the `c` array:
      sh = (slice(None),) + ((None,) * len(c.shape[1:]))
  
      with np.errstate(invalid="raise", divide="raise"):
          try:
              for j in range(n):
                  # See e.g. Schumaker, Spline Functions: Basic Theory, Chapter 5
  
                  # Compute the denominator in the differentiation formula.
                  # (and append traling dims, if necessary)
                  dt = t[k + 1 : -1] - t[1 : -k - 1]
                  dt = dt[sh]
                  # Compute the new coefficients
                  c = (c[1 : -1 - k] - c[: -2 - k]) * k / dt
                  # Pad coefficient array to same size as knots (FITPACK
                  # convention)
                  c = np.r_[c, np.zeros((k,) + c.shape[1:])]
                  # Adjust knots
                  t = t[1:-1]
                  k -= 1
          except FloatingPointError:
              raise ValueError(
                  (
                      "The spline has internal repeated knots "
                      "and is not differentiable %d times"
                  )
                  % n
              )
  
      return t, c, k
  
file_path: catboost/contrib/python/scipy/py2/scipy/interpolate/_fitpack_impl.py
imports: from __future__ import division, print_function, absolute_import
  import warnings
  import numpy
  from .None import _fitpack
  from numpy import atleast_1d, array, ones, zeros, sqrt, ravel, transpose, empty, iinfo, intc, asarray
  from .None import dfitpack
label_desc: Use image node_id 12 for calling a global function with example usage: splder(tck, n) and returns: t,  c,  k, splantider