class_docstr: Interpolating polynomial for a set of points.
  
  The polynomial passes through all the pairs (xi,yi). One may
  additionally specify a number of derivatives at each point xi;
  this is done by repeating the value xi and specifying the
  derivatives as successive yi values.
  
  Allows evaluation of the polynomial and all its derivatives.
  For reasons of numerical stability, this function does not compute
  the coefficients of the polynomial, although they can be obtained
  by evaluating all the derivatives.
  
  Parameters
  ----------
  xi : array_like, length N
      Known x-coordinates. Must be sorted in increasing order.
  yi : array_like
      Known y-coordinates. When an xi occurs two or more times in
      a row, the corresponding yi's represent derivative values.
  axis : int, optional
      Axis in the yi array corresponding to the x-coordinate values.
  
  Notes
  -----
  Be aware that the algorithms implemented here are not necessarily
  the most numerically stable known. Moreover, even in a world of
  exact computation, unless the x coordinates are chosen very
  carefully - Chebyshev zeros (e.g., cos(i*pi/n)) are a good choice -
  polynomial interpolation itself is a very ill-conditioned process
  due to the Runge phenomenon. In general, even with well-chosen
  x values, degrees higher than about thirty cause problems with
  numerical instability in this code.
  
  Based on [1]_.
  
  References
  ----------
  .. [1] Krogh, "Efficient Algorithms for Polynomial Interpolation
      and Numerical Differentiation", 1970.
  
  Examples
  --------
  To produce a polynomial that is zero at 0 and 1 and has
  derivative 2 at 0, call
  
  >>> from scipy.interpolate import KroghInterpolator
  >>> KroghInterpolator([0,0,1],[0,2,0])
  
  This constructs the quadratic 2*X**2-2*X. The derivative condition
  is indicated by the repeated zero in the xi array; the corresponding
  yi values are 0, the function value, and 2, the derivative value.
  
  For another example, given xi, yi, and a derivative ypi for each
  point, appropriate arrays can be constructed as:
  
  >>> rng = np.random.default_rng()
  >>> xi = np.linspace(0, 1, 5)
  >>> yi, ypi = rng.random((2, 5))
  >>> xi_k, yi_k = np.repeat(xi, 2), np.ravel(np.dstack((yi,ypi)))
  >>> KroghInterpolator(xi_k, yi_k)
  
  To produce a vector-valued polynomial, supply a higher-dimensional
  array for yi:
  
  >>> KroghInterpolator([0,1],[[2,3],[4,5]])
  
  This constructs a linear polynomial giving (2,3) at 0 and (4,5) at 1.
code: def __init__(self, xi, yi, axis=0):
      _Interpolator1DWithDerivatives.__init__(self, xi, yi, axis)
  
      self.xi = np.asarray(xi)
      self.yi = self._reshape_yi(yi)
      self.n, self.r = self.yi.shape
  
      c = np.zeros((self.n + 1, self.r), dtype=self.dtype)
      c[0] = self.yi[0]
      Vk = np.zeros((self.n, self.r), dtype=self.dtype)
      for k in range(1, self.n):
          s = 0
          while s <= k and xi[k - s] == xi[k]:
              s += 1
          s -= 1
          Vk[0] = self.yi[k] / float_factorial(s)
          for i in range(k - s):
              if xi[i] == xi[k]:
                  raise ValueError("Elements if `xi` can't be equal.")
              if s == 0:
                  Vk[i + 1] = (c[i] - Vk[i]) / (xi[i] - xi[k])
              else:
                  Vk[i + 1] = (Vk[i + 1] - Vk[i]) / (xi[i] - xi[k])
          c[k] = Vk[k - s]
      self.c = c
  
imports: import numpy
  from scipy.special import factorial
  from scipy._lib._util import _asarray_validated, float_factorial
label_desc: Use image node_id 1 to create a new KroghInterpolator object from inherited base classes: _Interpolator1DWithDerivatives with example: obj = KroghInterpolator(xi, yi, axis)