scipy 1.15.3__cp311-cp311-win_amd64.whl → 1.16.0rc2__cp311-cp311-win_amd64.whl

scipy/interpolate/_fitpack2.py

@@ -1131,8 +1131,7 @@ class _BivariateSplineBase:
                 newc, ier = dfitpack.pardtc(tx, ty, c, kx, ky, dx, dy)
             if ier != 0:
                 # This should not happen under normal conditions.
-                raise ValueError("Unexpected error code returned by"
-                                 " pardtc: %d" % ier)
+                raise ValueError(f"Unexpected error code returned by pardtc: {ier}")
             nx = len(tx)
             ny = len(ty)
             newtx = tx[dx:nx - dx]
@@ -1158,7 +1157,8 @@ Weighted sum of squared residuals does not satisfy abs(fp-s)/s < tol.""",
 the maximal number of iterations maxit (set to 20 by the program)
 allowed for finding a smoothing spline with fp=s has been reached:
 s too small.
-Weighted sum of squared residuals does not satisfy abs(fp-s)/s < tol.""",
+Weighted sum of squared residuals does not satisfy abs(fp-s)/s < tol.
+Try increasing maxit by passing it as a keyword argument.""",
                     4: """
 No more knots can be added because the number of b-spline coefficients
 (nx-kx-1)*(ny-ky-1) already exceeds the number of data points m:
@@ -1575,6 +1575,9 @@ class RectBivariateSpline(BivariateSpline):
         Positive smoothing factor defined for estimation condition:
         ``sum((z[i]-f(x[i], y[i]))**2, axis=0) <= s`` where f is a spline
         function. Default is ``s=0``, which is for interpolation.
+    maxit : int, optional
+        The maximal number of iterations maxit allowed for finding a
+        smoothing spline with fp=s. Default is ``maxit=20``.
 
     See Also
     --------
@@ -1607,7 +1610,7 @@ class RectBivariateSpline(BivariateSpline):
 
     """
 
-    def __init__(self, x, y, z, bbox=[None] * 4, kx=3, ky=3, s=0):
+    def __init__(self, x, y, z, bbox=[None] * 4, kx=3, ky=3, s=0, maxit=20):
         x, y, bbox = ravel(x), ravel(y), ravel(bbox)
         z = np.asarray(z)
         if not np.all(diff(x) > 0.0):
@@ -1629,7 +1632,7 @@ class RectBivariateSpline(BivariateSpline):
         xb, xe, yb, ye = bbox
         with FITPACK_LOCK:
             nx, tx, ny, ty, c, fp, ier = dfitpack.regrid_smth(x, y, z, xb, xe, yb,
-                                                            ye, kx, ky, s)
+                                                            ye, kx, ky, s, maxit)
 
         if ier not in [0, -1, -2]:
             msg = _surfit_messages.get(ier, f'ier={ier}')
@@ -2313,7 +2316,7 @@ class RectSphereBivariateSpline(SphereBivariateSpline):
         ider = np.array([-1, 0, -1, 0], dtype=dfitpack_int)
         if pole_values is None:
             pole_values = (None, None)
-        elif isinstance(pole_values, (float, np.float32, np.float64)):
+        elif isinstance(pole_values, float | np.float32 | np.float64):
             pole_values = (pole_values, pole_values)
         if isinstance(pole_continuity, bool):
             pole_continuity = (pole_continuity, pole_continuity)

scipy/interpolate/_fitpack_impl.py

@@ -117,9 +117,10 @@ def splprep(x, w=None, u=None, ub=None, ue=None, k=3, task=0, s=None, t=None,
         for i in range(idim):
             if x[i][0] != x[i][-1]:
                 if not quiet:
-                    warnings.warn(RuntimeWarning('Setting x[%d][%d]=x[%d][0]' %
-                                                 (i, m, i)),
-                                  stacklevel=2)
+                    warnings.warn(
+                        RuntimeWarning(f'Setting x[{i}][{m}]=x[{i}][0]'), 
+                        stacklevel=2
+                    )
                 x[i][-1] = x[i][0]
     if not 0 < idim < 11:
         raise TypeError('0 < idim < 11 must hold')
@@ -141,7 +142,7 @@ def splprep(x, w=None, u=None, ub=None, ue=None, k=3, task=0, s=None, t=None,
     else:
         _parcur_cache['u'] = zeros(m, float)
     if not (1 <= k <= 5):
-        raise TypeError('1 <= k= %d <=5 must hold' % k)
+        raise TypeError(f'1 <= k= {k} <=5 must hold')
     if not (-1 <= task <= 1):
         raise TypeError('task must be -1, 0 or 1')
     if (not len(w) == m) or (ipar == 1 and (not len(u) == m)):
@@ -187,10 +188,12 @@ def splprep(x, w=None, u=None, ub=None, ue=None, k=3, task=0, s=None, t=None,
     c.shape = idim, n - k - 1
     tcku = [t, list(c), k], u
     if ier <= 0 and not quiet:
-        warnings.warn(RuntimeWarning(_iermess[ier][0] +
-                                     "\tk=%d n=%d m=%d fp=%f s=%f" %
-                                     (k, len(t), m, fp, s)),
-                      stacklevel=2)
+        warnings.warn(
+            RuntimeWarning(
+                _iermess[ier][0] + f"\tk={k} n={len(t)} m={m} fp={fp} s={s}"
+            ), 
+            stacklevel=2
+        )
     if ier > 0 and not full_output:
         if ier in [1, 2, 3]:
             warnings.warn(RuntimeWarning(_iermess[ier][0]), stacklevel=2)
@@ -228,13 +231,14 @@ def splrep(x, y, w=None, xb=None, xe=None, k=3, task=0, s=None, t=None,
         if s is None:
             s = m - sqrt(2*m)
     if not len(w) == m:
-        raise TypeError('len(w)=%d is not equal to m=%d' % (len(w), m))
+        raise TypeError(f'len(w)={len(w)} is not equal to m={m}')
     if (m != len(y)) or (m != len(w)):
         raise TypeError('Lengths of the first three arguments (x,y,w) must '
                         'be equal')
     if not (1 <= k <= 5):
-        raise TypeError('Given degree of the spline (k=%d) is not supported. '
-                        '(1<=k<=5)' % k)
+        raise TypeError(
+            f'Given degree of the spline (k={k}) is not supported. (1<=k<=5)'
+        )
     if m <= k:
         raise TypeError('m > k must hold')
     if xb is None:
@@ -279,8 +283,7 @@ def splrep(x, y, w=None, xb=None, xe=None, k=3, task=0, s=None, t=None,
         n, c, fp, ier = dfitpack.percur(task, x, y, w, t, wrk, iwrk, k, s)
     tck = (t[:n], c[:n], k)
     if ier <= 0 and not quiet:
-        _mess = (_iermess[ier][0] + "\tk=%d n=%d m=%d fp=%f s=%f" %
-                 (k, len(t), m, fp, s))
+        _mess = (_iermess[ier][0] + f"\tk={k} n={len(t)} m={m} fp={fp} s={s}")
         warnings.warn(RuntimeWarning(_mess), stacklevel=2)
     if ier > 0 and not full_output:
         if ier in [1, 2, 3]:
@@ -312,7 +315,7 @@ def splev(x, tck, der=0, ext=0):
                         splev(x, [t, c, k], der, ext), c))
     else:
         if not (0 <= der <= k):
-            raise ValueError("0<=der=%d<=k=%d must hold" % (der, k))
+            raise ValueError(f"0<=der={der}<=k={k} must hold")
         if ext not in (0, 1, 2, 3):
             raise ValueError(f"ext = {ext} not in (0, 1, 2, 3) ")
 
@@ -516,7 +519,7 @@ def bisplrep(x, y, z, w=None, xb=None, xe=None, yb=None, ye=None,
     else:
         w = atleast_1d(w)
     if not len(w) == m:
-        raise TypeError('len(w)=%d is not equal to m=%d' % (len(w), m))
+        raise TypeError(f'len(w)={len(w)} is not equal to m={m}')
     if xb is None:
         xb = x.min()
     if xe is None:
@@ -544,8 +547,9 @@ def bisplrep(x, y, z, w=None, xb=None, xe=None, yb=None, ye=None,
     if task == -1 and ny < 2*ky+2:
         raise TypeError('There must be at least 2*ky+2 knots_x for task=-1')
     if not ((1 <= kx <= 5) and (1 <= ky <= 5)):
-        raise TypeError('Given degree of the spline (kx,ky=%d,%d) is not '
-                        'supported. (1<=k<=5)' % (kx, ky))
+        raise TypeError(
+            f'Given degree of the spline (kx,ky={kx},{ky}) is not supported. (1<=k<=5)'
+        )
     if m < (kx + 1)*(ky + 1):
         raise TypeError('m >= (kx+1)(ky+1) must hold')
     if nxest is None:
@@ -586,14 +590,16 @@ def bisplrep(x, y, z, w=None, xb=None, xe=None, yb=None, ye=None,
 
     ierm = min(11, max(-3, ier))
     if ierm <= 0 and not quiet:
-        _mess = (_iermess2[ierm][0] +
-                 "\tkx,ky=%d,%d nx,ny=%d,%d m=%d fp=%f s=%f" %
-                 (kx, ky, len(tx), len(ty), m, fp, s))
+        _mess = (
+            _iermess2[ierm][0] + 
+            f"\tkx,ky={kx},{ky} nx,ny={len(tx)},{len(ty)} m={m} fp={fp} s={s}"
+        )
         warnings.warn(RuntimeWarning(_mess), stacklevel=2)
     if ierm > 0 and not full_output:
         if ier in [1, 2, 3, 4, 5]:
-            _mess = ("\n\tkx,ky=%d,%d nx,ny=%d,%d m=%d fp=%f s=%f" %
-                     (kx, ky, len(tx), len(ty), m, fp, s))
+            _mess = (
+                f"\n\tkx,ky={kx},{ky} nx,ny={len(tx)},{len(ty)} m={m} fp={fp} s={s}"
+            )
             warnings.warn(RuntimeWarning(_iermess2[ierm][0] + _mess), stacklevel=2)
         else:
             try:
@@ -663,9 +669,9 @@ def bisplev(x, y, tck, dx=0, dy=0):
     """
     tx, ty, c, kx, ky = tck
     if not (0 <= dx < kx):
-        raise ValueError("0 <= dx = %d < kx = %d must hold" % (dx, kx))
+        raise ValueError(f"0 <= dx = {dx} < kx = {kx} must hold")
     if not (0 <= dy < ky):
-        raise ValueError("0 <= dy = %d < ky = %d must hold" % (dy, ky))
+        raise ValueError(f"0 <= dy = {dy} < ky = {ky} must hold")
     x, y = map(atleast_1d, [x, y])
     if (len(x.shape) != 1) or (len(y.shape) != 1):
         raise ValueError("First two entries should be rank-1 arrays.")
@@ -771,8 +777,8 @@ def splder(tck, n=1):
                 t = t[1:-1]
                 k -= 1
         except FloatingPointError as e:
-            raise ValueError(("The spline has internal repeated knots "
-                              "and is not differentiable %d times") % n) from e
+            raise ValueError("The spline has internal repeated knots "
+                              f"and is not differentiable {n} times") from e
 
     return t, c, k
 

scipy/interpolate/_fitpack_repro.py

@@ -57,7 +57,11 @@ def _get_residuals(x, y, t, k, w):
     _, _, c = _lsq_solve_qr(x, y, t, k, w)
     c = np.ascontiguousarray(c)
     spl = BSpline(t, c, k)
-    return _compute_residuals(w2, spl(x), y)
+    residuals = _compute_residuals(w2, spl(x), y)
+    fp = residuals.sum()
+    if np.isnan(fp):
+        raise ValueError(_iermesg[1])
+    return residuals, fp
 
 
 def _compute_residuals(w2, splx, y):
@@ -139,7 +143,7 @@ def _validate_inputs(x, y, w, k, s, xb, xe, parametric):
 
 
 def generate_knots(x, y, *, w=None, xb=None, xe=None, k=3, s=0, nest=None):
-    """Replicate FITPACK's constructing the knot vector.
+    """Generate knot vectors until the Least SQuares (LSQ) criterion is satified.
 
     Parameters
     ----------
@@ -258,8 +262,7 @@ def _generate_knots_impl(x, y, *, w=None, xb=None, xe=None, k=3, s=0, nest=None)
 
         # construct the LSQ spline with this set of knots
         fpold = fp
-        residuals = _get_residuals(x, y, t, k, w=w)
-        fp = residuals.sum()
+        residuals, fp = _get_residuals(x, y, t, k, w=w)
         fpms = fp - s
 
         # c  test whether the approximation sinf(x) is an acceptable solution.
@@ -300,7 +303,7 @@ def _generate_knots_impl(x, y, *, w=None, xb=None, xe=None, k=3, s=0, nest=None)
 
             # recompute if needed
             if j < nplus - 1:
-                residuals = _get_residuals(x, y, t, k, w=w)
+                residuals, _ = _get_residuals(x, y, t, k, w=w)
 
     # this should never be reached
     return
@@ -536,11 +539,15 @@ class Bunch:
         self.__dict__.update(**kwargs)
 
 
-_iermesg = {
-2: """error. a theoretically impossible result was found during
+_iermesg1 = """error. a theoretically impossible result was found during
 the iteration process for finding a smoothing spline with
 fp = s. probably causes : s too small.
-there is an approximation returned but the corresponding
+"""
+
+_iermesg = {
+1: _iermesg1 + """the weighted sum of squared residuals is becoming NaN
+""",
+2: _iermesg1 + """there is an approximation returned but the corresponding
 weighted sum of squared residuals does not satisfy the
 condition abs(fp-s)/s < tol.
 """,
@@ -659,7 +666,7 @@ def _make_splrep_impl(x, y, *, w=None, xb=None, xe=None, k=3, s=0, t=None, nest=
         nest = max(m + k + 1, 2*k + 3)
     else:
         if nest < 2*(k + 1):
-            raise ValueError(f"`nest` too small: {nest = } < 2*(k+1) = {2*(k+1)}.")    
+            raise ValueError(f"`nest` too small: {nest = } < 2*(k+1) = {2*(k+1)}.")
         if t is not None:
             raise ValueError("Either supply `t` or `nest`.")
 
@@ -685,13 +692,11 @@ def _make_splrep_impl(x, y, *, w=None, xb=None, xe=None, k=3, s=0, t=None, nest=
     # ### bespoke solver ####
     # initial conditions
     # f(p=inf) : LSQ spline with knots t   (XXX: reuse R, c)
-    residuals = _get_residuals(x, y, t, k, w=w)
-    fp = residuals.sum()
+    _, fp = _get_residuals(x, y, t, k, w=w)
     fpinf = fp - s
 
     # f(p=0): LSQ spline without internal knots
-    residuals = _get_residuals(x, y, np.array([xb]*(k+1) + [xe]*(k+1)), k, w)
-    fp0 = residuals.sum()
+    _, fp0 = _get_residuals(x, y, np.array([xb]*(k+1) + [xe]*(k+1)), k, w)
     fp0 = fp0 - s
 
     # solve
@@ -712,7 +717,7 @@ def _make_splrep_impl(x, y, *, w=None, xb=None, xe=None, k=3, s=0, t=None, nest=
 
 
 def make_splrep(x, y, *, w=None, xb=None, xe=None, k=3, s=0, t=None, nest=None):
-    r"""Find the B-spline representation of a 1D function.
+    r"""Create a smoothing B-spline function with bounded error, minimizing derivative jumps.
 
     Given the set of data points ``(x[i], y[i])``, determine a smooth spline
     approximation of degree ``k`` on the interval ``xb <= x <= xe``.
@@ -736,7 +741,7 @@ def make_splrep(x, y, *, w=None, xb=None, xe=None, k=3, s=0, t=None, nest=None):
         especially with small `s` values.
     s : float, optional
         The smoothing condition. The amount of smoothness is determined by
-        satisfying the conditions::
+        satisfying the LSQ (least-squares) constraint::
 
             sum((w * (g(x)  - y))**2 ) <= s
 
@@ -829,7 +834,7 @@ def make_splrep(x, y, *, w=None, xb=None, xe=None, k=3, s=0, t=None, nest=None):
     for a spline function :math:`g(x)` with a _fixed_ knot vector ``t``.
 
     .. versionadded:: 1.15.0
-    """
+    """  # noqa:E501
     if s == 0:
         if t is not None or w is not None or nest is not None:
             raise ValueError("s==0 is for interpolation only")
@@ -846,7 +851,7 @@ def make_splrep(x, y, *, w=None, xb=None, xe=None, k=3, s=0, t=None, nest=None):
 
 def make_splprep(x, *, w=None, u=None, ub=None, ue=None, k=3, s=0, t=None, nest=None):
     r"""
-    Find a smoothed B-spline representation of a parametric N-D curve.
+    Create a smoothing parametric B-spline curve with bounded error, minimizing derivative jumps.
 
     Given a list of N 1D arrays, `x`, which represent a curve in
     N-dimensional space parametrized by `u`, find a smooth approximating
@@ -965,7 +970,7 @@ def make_splprep(x, *, w=None, u=None, ub=None, ue=None, k=3, s=0, t=None, nest=
         20 (1982) 171-184.
     .. [2] P. Dierckx, "Curve and surface fitting with splines", Monographs on
         Numerical Analysis, Oxford University Press, 1993.
-    """
+    """  # noqa:E501
     x = np.stack(x, axis=1)
 
     # construct the default parametrization of the curve
@@ -989,4 +994,3 @@ def make_splprep(x, *, w=None, u=None, ub=None, ue=None, k=3, s=0, t=None, nest=
     spl1 = BSpline(spl.t, cc, spl.k, axis=1)
 
     return spl1, u
-

scipy/interpolate/_interpolate.py

@@ -38,6 +38,23 @@ def lagrange(x, w):
     lagrange : `numpy.poly1d` instance
         The Lagrange interpolating polynomial.
 
+    Notes
+    -----
+    The name of this function refers to the fact that the returned object represents
+    a Lagrange polynomial, the unique polynomial of lowest degree that interpolates
+    a given set of data [1]_. It computes the polynomial using Newton's divided
+    differences formula [2]_; that is, it works with Newton basis polynomials rather
+    than Lagrange basis polynomials. For numerical calculations, the barycentric form
+    of Lagrange interpolation (`scipy.interpolate.BarycentricInterpolator`) is
+    typically more appropriate.
+
+    References
+    ----------
+    .. [1] Lagrange polynomial. *Wikipedia*.
+           https://en.wikipedia.org/wiki/Lagrange_polynomial
+    .. [2] Newton polynomial. *Wikipedia*.
+           https://en.wikipedia.org/wiki/Newton_polynomial
+
     Examples
     --------
     Interpolate :math:`f(x) = x^3` by 3 points.
@@ -48,7 +65,7 @@ def lagrange(x, w):
     >>> y = x**3
     >>> poly = lagrange(x, y)
 
-    Since there are only 3 points, Lagrange polynomial has degree 2. Explicitly,
+    Since there are only 3 points, the Lagrange polynomial has degree 2. Explicitly,
     it is given by
 
     .. math::
@@ -110,6 +127,8 @@ class interp2d:
     interp2d(x, y, z, kind='linear', copy=True, bounds_error=False,
              fill_value=None)
 
+    Class for 2D interpolation (deprecated and removed)
+
     .. versionremoved:: 1.14.0
 
         `interp2d` has been removed in SciPy 1.14.0.
@@ -153,7 +172,7 @@ def _do_extrapolate(fill_value):
 
 class interp1d(_Interpolator1D):
     """
-    Interpolate a 1-D function.
+    Interpolate a 1-D function (legacy).
 
     .. legacy:: class
 
@@ -402,8 +421,7 @@ class interp1d(_Interpolator1D):
                 self._call = self.__class__._call_spline
 
         if len(self.x) < minval:
-            raise ValueError("x and y arrays must have at "
-                             "least %d entries" % minval)
+            raise ValueError(f"x and y arrays must have at least {minval} entries")
 
         self.fill_value = fill_value  # calls the setter, can modify bounds_err
 
@@ -796,8 +814,7 @@ class _PPolyBase:
 
 
 class PPoly(_PPolyBase):
-    """
-    Piecewise polynomial in terms of coefficients and breakpoints
+    """Piecewise polynomial in the power basis.
 
     The polynomial between ``x[i]`` and ``x[i + 1]`` is written in the
     local power basis::
@@ -1260,7 +1277,7 @@ class PPoly(_PPolyBase):
 
 
 class BPoly(_PPolyBase):
-    """Piecewise polynomial in terms of coefficients and breakpoints.
+    """Piecewise polynomial in the Bernstein basis.
 
     The polynomial between ``x[i]`` and ``x[i + 1]`` is written in the
     Bernstein polynomial basis::
@@ -1650,7 +1667,7 @@ class BPoly(_PPolyBase):
         if orders is None:
             orders = [None] * m
         else:
-            if isinstance(orders, (int, np.integer)):
+            if isinstance(orders, int | np.integer):
                 orders = [orders] * m
             k = max(k, max(orders))
 
@@ -1667,10 +1684,11 @@ class BPoly(_PPolyBase):
                 n1 = min(n//2, len(y1))
                 n2 = min(n - n1, len(y2))
                 n1 = min(n - n2, len(y2))
-                if n1+n2 != n:
-                    mesg = ("Point %g has %d derivatives, point %g"
-                            " has %d derivatives, but order %d requested" % (
-                               xi[i], len(y1), xi[i+1], len(y2), orders[i]))
+                if n1 + n2 != n:
+                    mesg = (
+                        f"Point {xi[i]} has {len(y1)} derivatives, point {xi[i+1]} has "
+                        f"{len(y2)} derivatives, but order {orders[i]} requested"
+                    )
                     raise ValueError(mesg)
 
                 if not (n1 <= len(y1) and n2 <= len(y2)):

scipy/interpolate/_ndbspline.py

@@ -5,7 +5,7 @@ import numpy as np
 
 from math import prod
 
-from . import _bspl   # type: ignore[attr-defined]
+from . import _dierckx  # type: ignore[attr-defined]
 
 import scipy.sparse.linalg as ssl
 from scipy.sparse import csr_array
@@ -139,9 +139,9 @@ class NdBSpline:
         extrapolate = bool(extrapolate)
 
         if nu is None:
-            nu = np.zeros((ndim,), dtype=np.intc)
+            nu = np.zeros((ndim,), dtype=np.int64)
         else:
-            nu = np.asarray(nu, dtype=np.intc)
+            nu = np.asarray(nu, dtype=np.int64)
             if nu.ndim != 1 or nu.shape[0] != ndim:
                 raise ValueError(
                     f"invalid number of derivative orders {nu = } for "
@@ -173,12 +173,10 @@ class NdBSpline:
 
         # replacement for np.ravel_multi_index for indexing of `c1`:
         _strides_c1 = np.asarray([s // c1.dtype.itemsize
-                                  for s in c1.strides], dtype=np.intp)
+                                  for s in c1.strides], dtype=np.int64)
 
         num_c_tr = c1.shape[-1]  # # of trailing coefficients
-        out = np.empty(xi.shape[:-1] + (num_c_tr,), dtype=c1.dtype)
-
-        _bspl.evaluate_ndbspline(xi,
+        out = _dierckx.evaluate_ndbspline(xi,
                                  self._t,
                                  self._len_t,
                                  self._k,
@@ -188,7 +186,7 @@ class NdBSpline:
                                  num_c_tr,
                                  _strides_c1,
                                  self._indices_k1d,
-                                 out,)
+        )
         out = out.view(self.c.dtype)
         return out.reshape(xi_shape[:-1] + self.c.shape[ndim:])
 
@@ -235,15 +233,12 @@ class NdBSpline:
         # The strides of the coeffs array: the computation is equivalent to
         # >>> cstrides = [s // 8 for s in np.empty(c_shape).strides]
         cs = c_shape[1:] + (1,)
-        cstrides = np.cumprod(cs[::-1], dtype=np.intp)[::-1].copy()
+        cstrides = np.cumprod(cs[::-1], dtype=np.int64)[::-1].copy()
 
         # heavy lifting happens here
-        data, indices, indptr = _bspl._colloc_nd(xvals,
-                                                _t,
-                                                len_t,
-                                                k,
-                                                _indices_k1d,
-                                                cstrides)
+        data, indices, indptr = _dierckx._coloc_nd(xvals,
+                _t, len_t, k, _indices_k1d, cstrides)
+
         return csr_array((data, indices, indptr))
 
 
@@ -271,7 +266,7 @@ def _preprocess_inputs(k, t_tpl):
         # make k a tuple
         k = (k,)*ndim
 
-    k = np.asarray([operator.index(ki) for ki in k], dtype=np.int32)
+    k = np.asarray([operator.index(ki) for ki in k], dtype=np.int64)
 
     if len(k) != ndim:
         raise ValueError(f"len(t) = {len(t_tpl)} != {len(k) = }.")
@@ -305,7 +300,7 @@ def _preprocess_inputs(k, t_tpl):
     # non-zero b-spline elements
     shape = tuple(kd + 1 for kd in k)
     indices = np.unravel_index(np.arange(prod(shape)), shape)
-    _indices_k1d = np.asarray(indices, dtype=np.intp).T.copy()
+    _indices_k1d = np.asarray(indices, dtype=np.int64).T.copy()
 
     # 5. pack the knots into a single array:
     #    ([1, 2, 3, 4], [5, 6], (7, 8, 9)) -->
@@ -318,7 +313,7 @@ def _preprocess_inputs(k, t_tpl):
     _t.fill(np.nan)
     for d in range(ndim):
         _t[d, :len(t_tpl[d])] = t_tpl[d]
-    len_t = np.asarray(len_t, dtype=np.int32)
+    len_t = np.asarray(len_t, dtype=np.int64)
 
     return k, _indices_k1d, (_t, len_t)
 

scipy/interpolate/_ndgriddata.py

@@ -18,11 +18,7 @@ __all__ = ['griddata', 'NearestNDInterpolator', 'LinearNDInterpolator',
 
 
 class NearestNDInterpolator(NDInterpolatorBase):
-    """NearestNDInterpolator(x, y).
-
-    Nearest-neighbor interpolator in N > 1 dimensions.
-
-    .. versionadded:: 0.9
+    """Nearest-neighbor interpolator in N > 1 dimensions.
 
     Methods
     -------
@@ -174,7 +170,7 @@ class NearestNDInterpolator(NDInterpolatorBase):
 def griddata(points, values, xi, method='linear', fill_value=np.nan,
              rescale=False):
     """
-    Interpolate unstructured D-D data.
+    Convenience function for interpolating unstructured data in multiple dimensions.
 
     Parameters
     ----------
@@ -328,5 +324,6 @@ def griddata(points, values, xi, method='linear', fill_value=np.nan,
                                         rescale=rescale)
         return ip(xi)
     else:
-        raise ValueError("Unknown interpolation method %r for "
-                         "%d dimensional data" % (method, ndim))
+        raise ValueError(
+            f"Unknown interpolation method {method!r} for {ndim} dimensional data"
+        )