Remove mlab.cohere_pairs

dstansby · dstansby · commit 5d7fbc7cdcc5 · 2018-09-19T17:58:42.000+01:00
diff --git a/doc/api/next_api_changes/2018-09-18-DS.rst b/doc/api/next_api_changes/2018-09-18-DS.rst
@@ -4,4 +4,6 @@ Removal of deprecated :mod:`matplotlib.mlab` code
 Lots of code inside the :mod:`matplotlib.mlab` module which was deprecated
 in Matplotlib 2.2 has been removed. See below for a list:
 
-- `mlab.logspace`
+- `mlab.logspace` (use numpy.logspace instead)
+- `mlab.cohere_pairs` (use scipy.signal.coherence instead)
+- `mlab.donothing_callback`
diff --git a/lib/matplotlib/mlab.py b/lib/matplotlib/mlab.py
@@ -1194,169 +1194,6 @@ def cohere(x, y, NFFT=256, Fs=2, detrend=detrend_none, window=window_hanning,
     return Cxy, f
 
 
-@cbook.deprecated('2.2')
-def donothing_callback(*args):
-    pass
-
-
-@cbook.deprecated('2.2', 'scipy.signal.coherence')
-def cohere_pairs(X, ij, NFFT=256, Fs=2, detrend=detrend_none,
-                 window=window_hanning, noverlap=0,
-                 preferSpeedOverMemory=True,
-                 progressCallback=donothing_callback,
-                 returnPxx=False):
-
-    """
-    Compute the coherence and phase for all pairs *ij*, in *X*.
-
-    *X* is a *numSamples* * *numCols* array
-
-    *ij* is a list of tuples.  Each tuple is a pair of indexes into
-    the columns of X for which you want to compute coherence.  For
-    example, if *X* has 64 columns, and you want to compute all
-    nonredundant pairs, define *ij* as::
-
-      ij = []
-      for i in range(64):
-          for j in range(i+1,64):
-              ij.append( (i,j) )
-
-    *preferSpeedOverMemory* is an optional bool. Defaults to true. If
-    False, limits the caching by only making one, rather than two,
-    complex cache arrays. This is useful if memory becomes critical.
-    Even when *preferSpeedOverMemory* is False, :func:`cohere_pairs`
-    will still give significant performance gains over calling
-    :func:`cohere` for each pair, and will use subtantially less
-    memory than if *preferSpeedOverMemory* is True.  In my tests with
-    a 43000,64 array over all nonredundant pairs,
-    *preferSpeedOverMemory* = True delivered a 33% performance boost
-    on a 1.7GHZ Athlon with 512MB RAM compared with
-    *preferSpeedOverMemory* = False.  But both solutions were more
-    than 10x faster than naively crunching all possible pairs through
-    :func:`cohere`.
-
-    Returns
-    -------
-    Cxy : dictionary of (*i*, *j*) tuples -> coherence vector for
-        that pair.  i.e., ``Cxy[(i,j) = cohere(X[:,i], X[:,j])``.
-        Number of dictionary keys is ``len(ij)``.
-
-    Phase : dictionary of phases of the cross spectral density at
-        each frequency for each pair.  Keys are (*i*, *j*).
-
-    freqs : vector of frequencies, equal in length to either the
-         coherence or phase vectors for any (*i*, *j*) key.
-
-    e.g., to make a coherence Bode plot::
-
-          subplot(211)
-          plot( freqs, Cxy[(12,19)])
-          subplot(212)
-          plot( freqs, Phase[(12,19)])
-
-    For a large number of pairs, :func:`cohere_pairs` can be much more
-    efficient than just calling :func:`cohere` for each pair, because
-    it caches most of the intensive computations.  If :math:`N` is the
-    number of pairs, this function is :math:`O(N)` for most of the
-    heavy lifting, whereas calling cohere for each pair is
-    :math:`O(N^2)`.  However, because of the caching, it is also more
-    memory intensive, making 2 additional complex arrays with
-    approximately the same number of elements as *X*.
-
-    See :file:`test/cohere_pairs_test.py` in the src tree for an
-    example script that shows that this :func:`cohere_pairs` and
-    :func:`cohere` give the same results for a given pair.
-
-    See Also
-    --------
-    :func:`psd`
-        For information about the methods used to compute :math:`P_{xy}`,
-        :math:`P_{xx}` and :math:`P_{yy}`.
-    """
-    numRows, numCols = X.shape
-
-    # zero pad if X is too short
-    if numRows < NFFT:
-        tmp = X
-        X = np.zeros((NFFT, numCols), X.dtype)
-        X[:numRows, :] = tmp
-        del tmp
-
-    numRows, numCols = X.shape
-    # get all the columns of X that we are interested in by checking
-    # the ij tuples
-    allColumns = set()
-    for i, j in ij:
-        allColumns.add(i)
-        allColumns.add(j)
-    Ncols = len(allColumns)
-
-    # for real X, ignore the negative frequencies
-    if np.iscomplexobj(X):
-        numFreqs = NFFT
-    else:
-        numFreqs = NFFT//2+1
-
-    # cache the FFT of every windowed, detrended NFFT length segment
-    # of every channel.  If preferSpeedOverMemory, cache the conjugate
-    # as well
-    if np.iterable(window):
-        if len(window) != NFFT:
-            raise ValueError("The length of the window must be equal to NFFT")
-        windowVals = window
-    else:
-        windowVals = window(np.ones(NFFT, X.dtype))
-    ind = list(range(0, numRows-NFFT+1, NFFT-noverlap))
-    numSlices = len(ind)
-    FFTSlices = {}
-    FFTConjSlices = {}
-    Pxx = {}
-    slices = range(numSlices)
-    normVal = np.linalg.norm(windowVals)**2
-    for iCol in allColumns:
-        progressCallback(i/Ncols, 'Cacheing FFTs')
-        Slices = np.zeros((numSlices, numFreqs), dtype=np.complex_)
-        for iSlice in slices:
-            thisSlice = X[ind[iSlice]:ind[iSlice]+NFFT, iCol]
-            thisSlice = windowVals*detrend(thisSlice)
-            Slices[iSlice, :] = np.fft.fft(thisSlice)[:numFreqs]
-
-        FFTSlices[iCol] = Slices
-        if preferSpeedOverMemory:
-            FFTConjSlices[iCol] = np.conj(Slices)
-        Pxx[iCol] = np.divide(np.mean(abs(Slices)**2, axis=0), normVal)
-    del Slices, ind, windowVals
-
-    # compute the coherences and phases for all pairs using the
-    # cached FFTs
-    Cxy = {}
-    Phase = {}
-    count = 0
-    N = len(ij)
-    for i, j in ij:
-        count += 1
-        if count % 10 == 0:
-            progressCallback(count/N, 'Computing coherences')
-
-        if preferSpeedOverMemory:
-            Pxy = FFTSlices[i] * FFTConjSlices[j]
-        else:
-            Pxy = FFTSlices[i] * np.conj(FFTSlices[j])
-        if numSlices > 1:
-            Pxy = np.mean(Pxy, axis=0)
-#       Pxy = np.divide(Pxy, normVal)
-        Pxy /= normVal
-#       Cxy[(i,j)] = np.divide(np.absolute(Pxy)**2, Pxx[i]*Pxx[j])
-        Cxy[i, j] = abs(Pxy)**2 / (Pxx[i]*Pxx[j])
-        Phase[i, j] = np.arctan2(Pxy.imag, Pxy.real)
-
-    freqs = Fs/NFFT*np.arange(numFreqs)
-    if returnPxx:
-        return Cxy, Phase, freqs, Pxx
-    else:
-        return Cxy, Phase, freqs
-
-
 @cbook.deprecated('2.2', 'scipy.stats.entropy')
 def entropy(y, bins):
     r"""
