def setUp(self):
m, n = randint(20, 101), randint(4, 5)
ms = randint(2, 11)
fs = int(2 ** nextpow2(randint(1, m / ms)))
self.x = rand(m, n)
self.window = int(np.floor(ms / 1e3 * fs))
if not self.window:
self.window += 1
def test_get_fft_funcs():
m, n = [int(2 ** nextpow2(randint(5, 10))) for _ in xrange(2)]
x = randn(m, n)
xc = x + 1j
ifft, fft = get_fft_funcs(xc, xc)
assert fft is np.fft.fft, 'fft is not np.fft.fft'
assert ifft is np.fft.ifft, 'ifft is not np.fft.ifft'
ravelxc = xc.ravel()
assert_allclose(ifft(fft(ravelxc)), ravelxc)
ifft, fft = get_fft_funcs(x, x)
assert fft is np.fft.rfft
assert ifft is np.fft.irfft
ravelx = x.ravel()
assert_allclose(ifft(fft(ravelx)), ravelx)
def test_mult_mat_xcorr():
x = randn(randint(2, 4), randint(4, 5))
m, n = x.shape
ifft, fft = get_fft_funcs(x)
nfft = int(2 ** nextpow2(m))
X = fft(x.T, nfft)
Xc = X.conj()
mx, nx = X.shape
c = np.empty((mx ** 2, nx), dtype=X.dtype)
oc = c.copy()
mult_mat_xcorr(X, Xc, oc, n, nx)
for i in xrange(n):
c[i * n:(i + 1) * n] = X[i] * Xc
assert_allclose(c, oc)
cc, occ = map(lambda x: ifft(x, nfft).T, (c, oc))
assert_allclose(cc, occ)
def xcorr(x, y=None, maxlags=None, detrend=detrend_mean,
scale_type='normalize'):
"""Compute the cross correlation of `x` and `y`.
This function computes the cross correlation of `x` and `y`. It uses the
equivalence of the cross correlation with the negative convolution computed
using a FFT to achieve must faster cross correlation than is possible with
the signal processing definition.
By default it computes the normalized cross correlation.
Parameters
----------
x : array_like
The array to correlate.
y : array_like, optional
If y is None or equal to `x` or x and y reference the same object,
the autocorrelation is computed.
maxlags : int, optional
The maximum lag at which to compute the cross correlation. Must be less
than or equal to the max(x.size, y.size) if not None.
detrend : callable, optional
A callable to detrend the data. It must take a single parameter and
return an array
scale_type : {None, 'none', 'unbiased', 'biased', 'normalize'}, optional
* The type of scaling to perform on the data
* The default of 'normalize' returns the cross correlation scaled by
the lag 0 cross correlation i.e., the cross correlation scaled by the
product of the standard deviations of the arrays at lag 0.
Raises
------
AssertionError
* If `y` is not None and `x` is a matrix
* If `x` is not a vector when `y` is None or `y` is `x` or
``all(x == y)``.
* If `detrend` is not callable
* If `scale_type` is not a string or ``None``
* If `scale_type` is not in ``(None, 'none', 'unbiased', 'biased',
'normalize')``
* If `maxlags` ``>`` `lsize`, see source for details.
Returns
-------
c : Series or DataFrame or array_like
Autocorrelation of `x` if `y` is ``None``, cross-correlation of `x` if
`x` is a matrix and `y` is ``None``, or the cross-correlation of `x`
and `y` if both `x` and `y` are vectors.
"""
assert x.ndim in (1, 2), 'x must be a 1D or 2D array'
assert callable(detrend), 'detrend must be a callable object'
assert isinstance(scale_type, basestring) or scale_type is None, \
'"scale_type" must be a string or None'
assert scale_type in _SCALE_KEYS, ('"scale_type" must be one of '
'{0}'.format(_SCALE_KEYS))
x = detrend(x)
if x.ndim == 2 and np.greater(x.shape, 1).all():
assert y is None, 'y argument not allowed when x is a 2D array'
lsize = x.shape[0]
inputs = x,
corrfunc = matrixcorr
elif y is None or y is x or np.array_equal(x, y):
assert isvector(x), 'x must be 1D'
lsize = max(x.shape)
inputs = x,
corrfunc = autocorr
else:
x, y, lsize = pad_larger(x, detrend(y))
inputs = x, y
corrfunc = crosscorr
nfft = 2 ** nextpow2(2 * lsize - 1)
ctmp = corrfunc(*inputs, nfft=nfft)
if maxlags is None:
maxlags = lsize
assert maxlags <= lsize, ('max lags must be less than or equal to %i'
% lsize)
lags = np.r_[1 - maxlags:maxlags]
if isinstance(x, Series):
return_type = lambda x, index: Series(x, index=index)
elif isinstance(x, DataFrame):
return_type = lambda x, index: DataFrame(x, index=index)
elif isinstance(x, np.ndarray):
return_type = lambda x, index: np.asanyarray(x)
sc_func = _SCALE_FUNCTIONS[scale_type]
return sc_func(return_type(ctmp[lags], index=lags), x, y, lags, lsize)
