Remove stride_windows

Author: oscargus

lib/matplotlib/mlab.py

@@ -213,8 +213,7 @@ def detrend_linear(y):
     return y - (b*x + a)
 
 
-@_api.deprecated("3.6")
-def stride_windows(x, n, noverlap=None, axis=0):
+def _stride_windows(x, n, noverlap=0):
     """
     Get all windows of *x* with length *n* as a single array,
     using strides to avoid data duplication.
@@ -233,8 +232,6 @@ def stride_windows(x, n, noverlap=None, axis=0):
         The number of data points in each window.
     noverlap : int, default: 0 (no overlap)
         The overlap between adjacent windows.
-    axis : int
-        The axis along which the windows will run.
 
     References
     ----------
@@ -243,49 +240,10 @@ def stride_windows(x, n, noverlap=None, axis=0):
     `stackoverflow: Using strides for an efficient moving average filter
     <https://stackoverflow.com/a/4947453>`_
     """
-    if noverlap is None:
-        noverlap = 0
-    if np.ndim(x) != 1:
-        raise ValueError('only 1-dimensional arrays can be used')
-    return _stride_windows(x, n, noverlap, axis)
-
-
-def _stride_windows(x, n, noverlap=0, axis=0):
-    # np>=1.20 provides sliding_window_view, and we only ever use axis=0.
-    if hasattr(np.lib.stride_tricks, "sliding_window_view") and axis == 0:
-        if noverlap >= n:
-            raise ValueError('noverlap must be less than n')
-        return np.lib.stride_tricks.sliding_window_view(
-            x, n, axis=0)[::n - noverlap].T
-
     if noverlap >= n:
         raise ValueError('noverlap must be less than n')
-    if n < 1:
-        raise ValueError('n cannot be less than 1')
-
-    x = np.asarray(x)
-
-    if n == 1 and noverlap == 0:
-        if axis == 0:
-            return x[np.newaxis]
-        else:
-            return x[np.newaxis].T
-    if n > x.size:
-        raise ValueError('n cannot be greater than the length of x')
-
-    # np.lib.stride_tricks.as_strided easily leads to memory corruption for
-    # non integer shape and strides, i.e. noverlap or n. See #3845.
-    noverlap = int(noverlap)
-    n = int(n)
-
-    step = n - noverlap
-    if axis == 0:
-        shape = (n, (x.shape[-1]-noverlap)//step)
-        strides = (x.strides[0], step*x.strides[0])
-    else:
-        shape = ((x.shape[-1]-noverlap)//step, n)
-        strides = (step*x.strides[0], x.strides[0])
-    return np.lib.stride_tricks.as_strided(x, shape=shape, strides=strides)
+    return np.lib.stride_tricks.sliding_window_view(
+        x, n, axis=0)[::n - noverlap].T
 
 
 def _spectral_helper(x, y=None, NFFT=None, Fs=None, detrend_func=None,

lib/matplotlib/tests/test_mlab.py

@@ -3,7 +3,7 @@
 import numpy as np
 import pytest
 
-from matplotlib import mlab, _api
+from matplotlib import mlab
 
 
 class TestStride:
@@ -13,12 +13,7 @@ def get_base(self, x):
             y = y.base
         return y
 
-    @pytest.fixture(autouse=True)
-    def stride_is_deprecated(self):
-        with _api.suppress_matplotlib_deprecation_warning():
-            yield
-
-    def calc_window_target(self, x, NFFT, noverlap=0, axis=0):
+    def calc_window_target(self, x, NFFT, noverlap=0):
         """
         This is an adaptation of the original window extraction algorithm.
         This is here to test to make sure the new implementation has the same
@@ -32,55 +27,43 @@ def calc_window_target(self, x, NFFT, noverlap=0, axis=0):
         # do the ffts of the slices
         for i in range(n):
             result[:, i] = x[ind[i]:ind[i]+NFFT]
-        if axis == 1:
-            result = result.T
         return result
 
-    @pytest.mark.parametrize('shape', [(), (10, 1)], ids=['0D', '2D'])
-    def test_stride_windows_invalid_input_shape(self, shape):
-        x = np.arange(np.prod(shape)).reshape(shape)
-        with pytest.raises(ValueError):
-            mlab.stride_windows(x, 5)
-
     @pytest.mark.parametrize('n, noverlap',
-                             [(0, None), (11, None), (2, 2), (2, 3)],
-                             ids=['n less than 1', 'n greater than input',
-                                  'noverlap greater than n',
+                             [(2, 2), (2, 3)],
+                             ids=['noverlap greater than n',
                                   'noverlap equal to n'])
     def test_stride_windows_invalid_params(self, n, noverlap):
         x = np.arange(10)
         with pytest.raises(ValueError):
-            mlab.stride_windows(x, n, noverlap)
+            mlab._stride_windows(x, n, noverlap)
 
-    @pytest.mark.parametrize('axis', [0, 1], ids=['axis0', 'axis1'])
     @pytest.mark.parametrize('n, noverlap',
                              [(1, 0), (5, 0), (15, 2), (13, -3)],
                              ids=['n1-noverlap0', 'n5-noverlap0',
                                   'n15-noverlap2', 'n13-noverlapn3'])
-    def test_stride_windows(self, n, noverlap, axis):
+    def test_stride_windows(self, n, noverlap):
         x = np.arange(100)
-        y = mlab.stride_windows(x, n, noverlap=noverlap, axis=axis)
+        y = mlab._stride_windows(x, n, noverlap=noverlap)
 
         expected_shape = [0, 0]
-        expected_shape[axis] = n
-        expected_shape[1 - axis] = 100 // (n - noverlap)
-        yt = self.calc_window_target(x, n, noverlap=noverlap, axis=axis)
+        expected_shape[0] = n
+        expected_shape[1] = 100 // (n - noverlap)
+        yt = self.calc_window_target(x, n, noverlap=noverlap)
 
         assert yt.shape == y.shape
         assert_array_equal(yt, y)
         assert tuple(expected_shape) == y.shape
         assert self.get_base(y) is x
 
-    @pytest.mark.parametrize('axis', [0, 1], ids=['axis0', 'axis1'])
-    def test_stride_windows_n32_noverlap0_unflatten(self, axis):
+    def test_stride_windows_n32_noverlap0_unflatten(self):
         n = 32
         x = np.arange(n)[np.newaxis]
         x1 = np.tile(x, (21, 1))
         x2 = x1.flatten()
-        y = mlab.stride_windows(x2, n, axis=axis)
+        y = mlab._stride_windows(x2, n)
 
-        if axis == 0:
-            x1 = x1.T
+        x1 = x1.T
         assert y.shape == x1.shape
         assert_array_equal(y, x1)