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

scipy/interpolate/_polyint.py

@@ -243,8 +243,7 @@ class _Interpolator1DWithDerivatives(_Interpolator1D):
 
 
 class KroghInterpolator(_Interpolator1DWithDerivatives):
-    """
-    Interpolating polynomial for a set of points.
+    """Krogh interpolator (C∞ smooth).
 
     The polynomial passes through all the pairs ``(xi, yi)``. One may
     additionally specify a number of derivatives at each point `xi`;
@@ -391,8 +390,7 @@ class KroghInterpolator(_Interpolator1DWithDerivatives):
 
 
 def krogh_interpolate(xi, yi, x, der=0, axis=0):
-    """
-    Convenience function for polynomial interpolation.
+    """Convenience function for Krogh interpolation.
 
     See `KroghInterpolator` for more details.
 
@@ -533,27 +531,23 @@ def approximate_taylor_polynomial(f,x,degree,scale,order=None):
 
 
 class BarycentricInterpolator(_Interpolator1DWithDerivatives):
-    r"""Interpolating polynomial for a set of points.
+    r"""Barycentric (Lagrange with improved stability) interpolator (C∞ smooth).
 
     Constructs a polynomial that passes through a given set of points.
     Allows evaluation of the polynomial and all its derivatives,
     efficient changing of the y-values to be interpolated,
-    and updating by adding more x- and y-values.
+    and updating by adding more x- and y-values. For numerical stability, a barycentric
+    representation is used rather than computing the coefficients of the polynomial
+    directly.
 
-    For reasons of numerical stability, this function does not compute
-    the coefficients of the polynomial.
-
-    The values `yi` need to be provided before the function is
-    evaluated, but none of the preprocessing depends on them, so rapid
-    updates are possible.
 
     Parameters
     ----------
     xi : array_like, shape (npoints, )
-        1-D array of x coordinates of the points the polynomial
+        1-D array of x-coordinates of the points the polynomial
         should pass through
     yi : array_like, shape (..., npoints, ...), optional
-        N-D array of y coordinates of the points the polynomial should pass through.
+        N-D array of y-coordinates of the points the polynomial should pass through.
         If None, the y values will be supplied later via the `set_y` method.
         The length of `yi` along the interpolation axis must be equal to the length
         of `xi`. Use the ``axis`` parameter to select correct axis.
@@ -564,7 +558,9 @@ class BarycentricInterpolator(_Interpolator1DWithDerivatives):
         The barycentric weights for the chosen interpolation points `xi`.
         If absent or None, the weights will be computed from `xi` (default).
         This allows for the reuse of the weights `wi` if several interpolants
-        are being calculated using the same nodes `xi`, without re-computation.
+        are being calculated using the same nodes `xi`, without re-computation. This
+        also allows for computing the weights explicitly for some choices of
+        `xi` (see notes).
     rng : {None, int, `numpy.random.Generator`}, optional
         If `rng` is passed by keyword, types other than `numpy.random.Generator` are
         passed to `numpy.random.default_rng` to instantiate a ``Generator``.
@@ -591,21 +587,71 @@ class BarycentricInterpolator(_Interpolator1DWithDerivatives):
 
     Notes
     -----
-    This class uses a "barycentric interpolation" method that treats
-    the problem as a special case of rational function interpolation.
-    This algorithm is quite stable, numerically, but 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.
+    This method is a variant of Lagrange polynomial interpolation [1]_ based on [2]_.
+    Instead of using Lagrange's or Newton's formula, the polynomial is represented by
+    the barycentric formula
+
+    .. math::
+
+        p(x) =
+        \frac{\sum_{i=1}^m\ w_i y_i / (x - x_i)}{\sum_{i=1}^m w_i / (x - x_i)},
+
+    where :math:`w_i` are the barycentric weights computed with the general formula
+
+    .. math::
+
+        w_i = \left( \prod_{k \neq i} x_i - x_k \right)^{-1}.
+
+    This is the same barycentric form used by `AAA` and `FloaterHormannInterpolator`.
+    However, in contrast, the weights :math:`w_i` are defined such that
+    :math:`p(x)` is a polynomial rather than a rational function.
+
+    The barycentric representation avoids many of the problems associated with
+    polynomial interpolation caused by floating-point arithmetic. However, it does not
+    avoid issues that are intrinsic to polynomial interpolation. Namely, if the
+    x-coordinates are equally spaced, then the weights can be computed explicitly using
+    the formula from [2]_
 
-    Based on Berrut and Trefethen 2004, "Barycentric Lagrange Interpolation".
+    .. math::
+
+        w_i = (-1)^i {n \choose i},
+
+    where :math:`n` is the number of x-coordinates. As noted in [2]_, this means that
+    for large :math:`n` the weights vary by exponentially large factors, leading to the
+    Runge phenomenon.
+
+    To avoid this ill-conditioning, the x-coordinates should be clustered at the
+    endpoints of the interval. An excellent choice of points on the interval
+    :math:`[a,b]` are Chebyshev points of the second kind
+
+    .. math::
+
+        x_i = \frac{a + b}{2} + \frac{a - b}{2}\cos(i\pi/n).
+
+    in which case the weights can be computed explicitly as
+
+    .. math::
+
+        w_i = \begin{cases}
+                  (-1)^i/2 & i = 0,n \\
+                  (-1)^i   & \text{otherwise}
+              \end{cases}.
+
+    See [2]_ for more infomation. Note that for large :math:`n`, computing the weights
+    explicitly (see examples) will be faster than the generic formula.
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Lagrange_polynomial
+    .. [2] Jean-Paul Berrut and Lloyd N. Trefethen, "Barycentric Lagrange
+           Interpolation", SIAM Review 2004 46:3, 501-517
+           :doi:`10.1137/S0036144502417715`
 
     Examples
     --------
     To produce a quintic barycentric interpolant approximating the function
     :math:`\sin x`, and its first four derivatives, using six randomly-spaced
-    nodes in :math:`(0, \frac{\pi}{2})`:
+    nodes in :math:`(0, \pi/2)`:
 
     >>> import numpy as np
     >>> import matplotlib.pyplot as plt
@@ -625,15 +671,34 @@ class BarycentricInterpolator(_Interpolator1DWithDerivatives):
     >>> axs[4].set_xlabel(r"$x$")
     >>> axs[4].set_xticks([i * np.pi / 4 for i in range(5)],
     ...                   ["0", r"$\frac{\pi}{4}$", r"$\frac{\pi}{2}$", r"$\frac{3\pi}{4}$", r"$\pi$"])
-    >>> axs[0].set_ylabel("$f(x)$")
-    >>> axs[1].set_ylabel("$f'(x)$")
-    >>> axs[2].set_ylabel("$f''(x)$")
-    >>> axs[3].set_ylabel("$f^{(3)}(x)$")
-    >>> axs[4].set_ylabel("$f^{(4)}(x)$")
+    >>> for ax, label in zip(axs, ("$f(x)$", "$f'(x)$", "$f''(x)$", "$f^{(3)}(x)$", "$f^{(4)}(x)$")):
+    ...     ax.set_ylabel(label)
     >>> labels = ['Interpolation nodes', 'True function $f$', 'Barycentric interpolation']
     >>> axs[0].legend(axs[0].get_lines()[::-1], labels, bbox_to_anchor=(0., 1.02, 1., .102),
     ...               loc='lower left', ncols=3, mode="expand", borderaxespad=0., frameon=False)
     >>> plt.show()
+
+    Next, we show how using Chebyshev points of the second kind avoids the avoids the
+    Runge phenomenon. In this example, we also compute the weights explicitly.
+
+    >>> n = 20
+    >>> def f(x): return np.abs(x) + 0.5*x - x**2
+    >>> i = np.arange(n)
+    >>> x_cheb = np.cos(i*np.pi/(n - 1))  # Chebyshev points on [-1, 1]
+    >>> w_i_cheb = (-1.)**i  # Explicit formula for weights of Chebyshev points
+    >>> w_i_cheb[[0, -1]] /= 2
+    >>> p_cheb = BarycentricInterpolator(x_cheb, f(x_cheb), wi=w_i_cheb)
+    >>> x_equi = np.linspace(-1, 1, n)
+    >>> p_equi = BarycentricInterpolator(x_equi, f(x_equi))
+    >>> xx = np.linspace(-1, 1, 1000)
+    >>> fig, ax = plt.subplots()
+    >>> ax.plot(xx, f(xx), label="Original Function")
+    >>> ax.plot(xx, p_cheb(xx), "--", label="Chebshev Points")
+    >>> ax.plot(xx, p_equi(xx), "--", label="Equally Spaced Points")
+    >>> ax.set(xlabel="$x$", ylabel="$f(x)$", xlim=[-1, 1])
+    >>> ax.legend()
+    >>> plt.show()
+
     """ # numpy/numpydoc#87  # noqa: E501
 
     @_transition_to_rng("random_state", replace_doc=False)
@@ -881,8 +946,7 @@ class BarycentricInterpolator(_Interpolator1DWithDerivatives):
 
 
 def barycentric_interpolate(xi, yi, x, axis=0, *, der=0, rng=None):
-    """
-    Convenience function for polynomial interpolation.
+    """Convenience function for barycentric interpolation.
 
     Constructs a polynomial that passes through a given set of points,
     then evaluates the polynomial. For reasons of numerical stability,

scipy/interpolate/_rbf.py

@@ -56,8 +56,8 @@ class Rbf:
     """
     Rbf(*args, **kwargs)
 
-    A class for radial basis function interpolation of functions from
-    N-D scattered data to an M-D domain.
+    Class for radial basis function interpolation of functions from
+    N-D scattered data to an M-D domain (legacy).
 
     .. legacy:: class
 

scipy/interpolate/_rbfinterp.py

@@ -132,7 +132,7 @@ def _build_and_solve_system(y, d, smoothing, kernel, epsilon, powers):
 
 
 class RBFInterpolator:
-    """Radial basis function (RBF) interpolation in N dimensions.
+    """Radial basis function interpolator in N ≥ 1 dimensions.
 
     Parameters
     ----------

scipy/interpolate/_rgi.py

@@ -28,8 +28,9 @@ def _check_points(points):
                 p = np.flip(p)
             else:
                 raise ValueError(
-                    "The points in dimension %d must be strictly "
-                    "ascending or descending" % i)
+                    f"The points in dimension {i} must be strictly ascending or "
+                    f"descending"
+                )
         # see https://github.com/scipy/scipy/issues/17716
         p = np.ascontiguousarray(p)
         grid.append(p)
@@ -38,20 +39,22 @@ def _check_points(points):
 
 def _check_dimensionality(points, values):
     if len(points) > values.ndim:
-        raise ValueError("There are %d point arrays, but values has %d "
-                         "dimensions" % (len(points), values.ndim))
+        raise ValueError(
+            f"There are {len(points)} point arrays, but values has "
+            f"{values.ndim} dimensions"
+        )
     for i, p in enumerate(points):
         if not np.asarray(p).ndim == 1:
-            raise ValueError("The points in dimension %d must be "
-                             "1-dimensional" % i)
+            raise ValueError(f"The points in dimension {i} must be 1-dimensional")
         if not values.shape[i] == len(p):
-            raise ValueError("There are %d points and %d values in "
-                             "dimension %d" % (len(p), values.shape[i], i))
+            raise ValueError(
+                f"There are {len(p)} points and {values.shape[i]} values in "
+                f"dimension {i}"
+            )
 
 
 class RegularGridInterpolator:
-    """
-    Interpolator on a regular or rectilinear grid in arbitrary dimensions.
+    """Interpolator of specified order on a rectilinear grid in N ≥ 1 dimensions.
 
     The data must be defined on a rectilinear grid; that is, a rectangular
     grid with even or uneven spacing. Linear, nearest-neighbor, spline
@@ -154,6 +157,11 @@ class RegularGridInterpolator:
     "cubic_legacy" and "quintic_legacy". These methods allow faster construction
     but evaluations will be much slower.
 
+    **Rounding rule at half points with `nearest` method**
+
+    The rounding rule with the `nearest` method at half points is rounding *down*.
+
+
     Examples
     --------
     **Evaluate a function on the points of a 3-D grid**
@@ -459,8 +467,9 @@ class RegularGridInterpolator:
             for i, p in enumerate(xi.T):
                 if not np.logical_and(np.all(self.grid[i][0] <= p),
                                       np.all(p <= self.grid[i][-1])):
-                    raise ValueError("One of the requested xi is out of bounds "
-                                     "in dimension %d" % i)
+                    raise ValueError(
+                        f"One of the requested xi is out of bounds in dimension {i}"
+                    )
             out_of_bounds = None
         else:
             out_of_bounds = self._find_out_of_bounds(xi.T)
@@ -611,13 +620,6 @@ def interpn(points, values, xi, method="linear", bounds_error=True,
     values : array_like, shape (m1, ..., mn, ...)
         The data on the regular grid in n dimensions. Complex data is
         accepted.
-
-        .. deprecated:: 1.13.0
-            Complex data is deprecated with ``method="pchip"`` and will raise an
-            error in SciPy 1.15.0. This is because ``PchipInterpolator`` only
-            works with real values. If you are trying to use the real components of
-            the passed array, use ``np.real`` on ``values``.
-
     xi : ndarray of shape (..., ndim)
         The coordinates to sample the gridded data at
 
@@ -710,8 +712,9 @@ def interpn(points, values, xi, method="linear", bounds_error=True,
 
     # sanity check consistency of input dimensions
     if len(points) > ndim:
-        raise ValueError("There are %d point arrays, but values has %d "
-                         "dimensions" % (len(points), ndim))
+        raise ValueError(
+            f"There are {len(points)} point arrays, but values has {ndim} dimensions"
+        )
     if len(points) != ndim and method == 'splinef2d':
         raise ValueError("The method splinef2d can only be used for "
                          "scalar data with one point per coordinate")
@@ -722,16 +725,18 @@ def interpn(points, values, xi, method="linear", bounds_error=True,
     # sanity check requested xi
     xi = _ndim_coords_from_arrays(xi, ndim=len(grid))
     if xi.shape[-1] != len(grid):
-        raise ValueError("The requested sample points xi have dimension "
-                         "%d, but this RegularGridInterpolator has "
-                         "dimension %d" % (xi.shape[-1], len(grid)))
+        raise ValueError(
+            f"The requested sample points xi have dimension {xi.shape[-1]}, "
+            f"but this RegularGridInterpolator has dimension {len(grid)}"
+        )
 
     if bounds_error:
         for i, p in enumerate(xi.T):
             if not np.logical_and(np.all(grid[i][0] <= p),
                                   np.all(p <= grid[i][-1])):
-                raise ValueError("One of the requested xi is out of bounds "
-                                 "in dimension %d" % i)
+                raise ValueError(
+                    f"One of the requested xi is out of bounds in dimension {i}"
+                )
 
     # perform interpolation
     if method in RegularGridInterpolator._ALL_METHODS:

scipy/interpolate/dfitpack.py

@@ -6,31 +6,11 @@ from scipy._lib.deprecation import _sub_module_deprecation
 
 
 __all__ = [  # noqa: F822
-    'bispeu',
-    'bispev',
-    'curfit',
-    'dblint',
-    'fpchec',
-    'fpcurf0',
-    'fpcurf1',
-    'fpcurfm1',
-    'parcur',
-    'parder',
-    'pardeu',
-    'pardtc',
-    'percur',
-    'regrid_smth',
-    'regrid_smth_spher',
     'spalde',
-    'spherfit_lsq',
-    'spherfit_smth',
     'splder',
     'splev',
     'splint',
     'sproot',
-    'surfit_lsq',
-    'surfit_smth',
-    'types',
 ]
 
 

scipy/interpolate/interpnd.py

@@ -21,5 +21,4 @@ def __dir__():
 def __getattr__(name):
     return _sub_module_deprecation(sub_package="interpolate", module="interpnd",
                                    private_modules=["_interpnd"], all=__all__,
-                                   attribute=name)
-
+                                   attribute=name, dep_version="1.17.0")

scipy/interpolate/tests/test_bary_rational.py

@@ -200,8 +200,8 @@ class TestAAA:
     @pytest.mark.parametrize("func,atol,rtol",
                              [(lambda x: np.abs(x + 0.5 + 0.01j), 5e-13, 1e-7),
                               (lambda x: np.sin(1/(1.05 - x)), 2e-13, 1e-7),
-                              (lambda x: np.exp(-1/(x**2)), 3.5e-13, 0),
-                              (lambda x: np.exp(-100*x**2), 8e-13, 0),
+                              (lambda x: np.exp(-1/(x**2)), 3.5e-12, 0),
+                              (lambda x: np.exp(-100*x**2), 2e-12, 0),
                               (lambda x: np.exp(-10/(1.2 - x)), 1e-14, 0),
                               (lambda x: 1/(1+np.exp(100*(x + 0.5))), 2e-13, 1e-7),
                               (lambda x: np.abs(x - 0.95), 1e-6, 1e-7)])

scipy/interpolate/tests/test_bsplines.py

@@ -3,6 +3,7 @@ import operator
 import itertools
 import math
 import threading
+import copy
 
 import numpy as np
 from numpy.testing import suppress_warnings
@@ -671,6 +672,7 @@ class TestBSpline:
 
         xp_assert_close(b(xx), expected)
 
+
 class TestInsert:
 
     @pytest.mark.parametrize('xval', [0.0, 1.0, 2.5, 4, 6.5, 7.0])
@@ -2165,7 +2167,7 @@ class TestSmoothingSpline:
         # using an iterative algorithm for minimizing the GCV criteria. These
         # algorithms may vary, so the tolerance should be rather low.
         # Not checking dtypes as gcvspl.npz stores little endian arrays, which
-        # result in conflicting dtypes on big endian systems. 
+        # result in conflicting dtypes on big endian systems.
         xp_assert_close(y_compr, y_GCVSPL, atol=1e-4, rtol=1e-4, check_dtype=False)
 
     def test_non_regularized_case(self):
@@ -2375,6 +2377,11 @@ class TestNdBSpline:
         xp_assert_close(bspl2(xi),
                         target, atol=1e-14)
 
+        # test that a nan in -> nan out
+        xi = np.asarray(xi)
+        xi[0, 1] = np.nan
+        xp_assert_equal(np.isnan(bspl2(xi)), np.asarray([True, False, False]))
+
         # now check on a multidim xi
         rng = np.random.default_rng(12345)
         xi = rng.uniform(size=(4, 3, 2)) * 5
@@ -2826,6 +2833,15 @@ class TestMakeND:
         bspl = make_ndbspl((x, y), values, k=k, solver=ssl.spsolve)
         xp_assert_close(bspl(xi), values.ravel(), atol=1e-15)
 
+    def test_2D_nans(self):
+        x = np.arange(6)
+        y = np.arange(6) + 0.5
+        y[-1] = np.nan
+        values = x[:, None]**3 * (y**3 + 2*y)[None, :]
+
+        with assert_raises(ValueError):
+            make_ndbspl((x, y), values, k=1)
+
     def _get_sample_2d_data(self):
         # from test_rgi.py::TestIntepN
         x = np.array([.5, 2., 3., 4., 5.5, 6.])
@@ -3517,6 +3533,20 @@ class TestMakeSplrep:
             xp_assert_close(np.r_[spl.c, [0]*(spl.k+1)],
                             tck[1], atol=5e-13)
 
+    def test_issue_22704(self):
+        # Reference - https://github.com/scipy/scipy/issues/22704
+        x = np.asarray([20.00, 153.81, 175.57, 202.47, 237.11,
+             253.61, 258.56, 273.40, 284.54, 293.61,
+             298.56, 301.86, 305.57, 307.22, 308.45,
+             310.10, 310.10, 310.50], dtype=np.float64)
+        y = np.asarray([53.00, 49.50, 48.60, 46.80, 43.20,
+             40.32, 39.60, 36.00, 32.40, 28.80,
+             25.20, 21.60, 18.00, 14.40, 10.80,
+             7.20, 3.60, 0.0], dtype=np.float64)
+        w = np.asarray([1.38723] * y.shape[0], dtype=np.float64)
+        with assert_raises(ValueError):
+            make_splrep(x, y, w=w, k=2, s=12)
+
     def test_shape(self):
         # make sure coefficients have the right shape (not extra dims)
         n, k = 10, 3
@@ -3656,3 +3686,69 @@ class TestMakeSplprep:
         assert spl(u).shape == (1, 8)
         xp_assert_close(spl(u), [x], atol=1e-15)
 
+
+class BatchSpline:
+    # BSpline-line class with reference batch behavior
+    def __init__(self, x, y, axis, *, spline, **kwargs):
+        y = np.moveaxis(y, axis, -1)
+        self._batch_shape = y.shape[:-1]
+        self._splines = [spline(x, yi, **kwargs) for yi in y.reshape(-1, y.shape[-1])]
+        self._axis = axis
+
+    def __call__(self, x):
+        y = [spline(x) for spline in self._splines]
+        y = np.reshape(y, self._batch_shape + x.shape)
+        return np.moveaxis(y, -1, self._axis) if x.shape else y
+
+    def integrate(self, a, b, extrapolate=None):
+        y = [spline.integrate(a, b, extrapolate) for spline in self._splines]
+        return np.reshape(y, self._batch_shape)
+
+    def derivative(self, nu):
+        res = copy.deepcopy(self)
+        res._splines = [spline.derivative(nu) for spline in res._splines]
+        return res
+
+    def antiderivative(self, nu):
+        res = copy.deepcopy(self)
+        res._splines = [spline.antiderivative(nu) for spline in res._splines]
+        return res
+
+
+class TestBatch:
+    @pytest.mark.parametrize('make_spline, kwargs',
+        [(make_interp_spline, {}),
+         (make_smoothing_spline, {}),
+         (make_smoothing_spline, {'lam': 1.0}),
+         (make_lsq_spline, {'method': "norm-eq"}),
+         (make_lsq_spline, {'method': "qr"}),
+         ])
+    @pytest.mark.parametrize('eval_shape', [(), (1,), (3,)])
+    @pytest.mark.parametrize('axis', [-1, 0, 1])
+    def test_batch(self, make_spline, kwargs, axis, eval_shape):
+        rng = np.random.default_rng(4329872134985134)
+        n = 10
+        shape = (2, 3, 4, n)
+        domain = (0, 10)
+
+        x = np.linspace(*domain, n)
+        y = np.moveaxis(rng.random(shape), -1, axis)
+
+        if make_spline == make_lsq_spline:
+            k = 3  # spline degree, if needed
+            t = (x[0],) * (k + 1) + (x[-1],) * (k + 1)  # valid knots, if needed
+            kwargs = kwargs | dict(t=t, k=k)
+
+        res = make_spline(x, y, axis=axis, **kwargs)
+        ref = BatchSpline(x, y, axis=axis, spline=make_spline, **kwargs)
+
+        x = rng.uniform(*domain, size=eval_shape)
+        np.testing.assert_allclose(res(x), ref(x))
+
+        res, ref = res.antiderivative(1), ref.antiderivative(1)
+        np.testing.assert_allclose(res(x), ref(x))
+
+        res, ref = res.derivative(2), ref.derivative(2)
+        np.testing.assert_allclose(res(x), ref(x))
+
+        np.testing.assert_allclose(res.integrate(*domain), ref.integrate(*domain))

scipy/interpolate/tests/test_fitpack2.py

@@ -1,6 +1,6 @@
 # Created by Pearu Peterson, June 2003
 import itertools
-from threading import Lock
+import sys
 import numpy as np
 from numpy.testing import suppress_warnings
 import pytest
@@ -1132,6 +1132,44 @@ class TestRectBivariateSpline:
             Interpolator(GridPosLats, nonGridPosLons)
         assert "y must be strictly increasing" in str(exc_info.value)
 
+    def _sample_large_2d_data(self, nx, ny):
+        rng = np.random.default_rng(1)
+        x = np.arange(nx)
+        y = np.arange(ny)
+        z = rng.integers(0, 100, (nx, ny))
+
+        return x, y, z.astype(np.float64)
+
+    @pytest.mark.slow()
+    @pytest.mark.parametrize('shape', [(350, 850), (2000, 170)])
+    @pytest.mark.parametrize('s_tols', [(0, 1e-12, 1e-7),
+                                        (1, 7e-3, 1e-4),
+                                        (3, 2e-2, 1e-4)])
+    def test_spline_large_2d(self, shape, s_tols):
+        # Reference - https://github.com/scipy/scipy/issues/17787
+        nx, ny = shape
+        s, atol, rtol = s_tols
+        x, y, z = self._sample_large_2d_data(nx, ny)
+
+        spl = RectBivariateSpline(x, y, z, s=s)
+        z_spl = spl(x, y)
+        assert(not np.isnan(z_spl).any())
+        xp_assert_close(z_spl, z, atol=atol, rtol=rtol)
+
+    @pytest.mark.slow()
+    @pytest.mark.skipif(sys.maxsize <= 2**32, reason="Segfaults on 32-bit system "
+                                                     "due to large input data")
+    def test_spline_large_2d_maxit(self):
+        # Reference - for https://github.com/scipy/scipy/issues/17787
+        nx, ny = 1000, 1700
+        s, atol, rtol = 2, 2e-2, 1e-12
+        x, y, z = self._sample_large_2d_data(nx, ny)
+
+        spl = RectBivariateSpline(x, y, z, s=s, maxit=25)
+        z_spl = spl(x, y)
+        assert(not np.isnan(z_spl).any())
+        xp_assert_close(z_spl, z, atol=atol, rtol=rtol)
+
 
 class TestRectSphereBivariateSpline:
     def test_defaults(self):