def test_coherence_linear_dependence():
"""
Tests that the coherence between two linearly dependent time-series
behaves as expected.
From William Wei's book, according to eq. 14.5.34, if two time-series are
linearly related through:
y(t) = alpha*x(t+time_shift)
then the coherence between them should be equal to:
.. :math:
C(\nu) = \frac{1}{1+\frac{fft_{noise}(\nu)}{fft_{x}(\nu) \cdot \alpha^2}}
"""
t = np.linspace(0,16*np.pi,2**14)
x = np.sin(t) + np.sin(2*t) + np.sin(3*t) + 0.1 *np.random.rand(t.shape[-1])
N = x.shape[-1]
alpha = 10
m = 3
noise = 0.1 * np.random.randn(t.shape[-1])
y = alpha*(np.roll(x,m)) + noise
f_noise = np.fft.fft(noise)[0:N/2]
f_x = np.fft.fft(x)[0:N/2]
c_t = ( 1/( 1 + ( f_noise/( f_x*(alpha**2)) ) ) )
f,c = tsa.coherence(np.vstack([x,y]))
c_t = np.abs(signaltools.resample(c_t,c.shape[-1]))
npt.assert_array_almost_equal(c[0,1],c_t,2)
def test_coherence():
"""
Tests that the coherency algorithm runs smoothly, using the different csd
routines and that the result is symmetrical:
"""
for method in methods:
f, c = tsa.coherence(tseries, csd_method=method)
npt.assert_array_almost_equal(c[0, 1], c[1, 0])
npt.assert_array_almost_equal(c[0, 0], np.ones(f.shape))
def test_coherence():
"""
Tests that the coherency algorithm runs smoothly, using the different csd
routines and that the result is symmetrical:
"""
for method in methods:
f, c = tsa.coherence(tseries, csd_method=method)
npt.assert_array_almost_equal(c[0, 1], c[1, 0])
npt.assert_array_almost_equal(c[0, 0], np.ones(f.shape))
def test_coherence_multi_taper():
"""Tests that the code runs and that the resulting matrix is symmetric """
t = np.linspace(0,16*np.pi,1024)
x = np.sin(t) + np.sin(2*t) + np.sin(3*t) + np.random.rand(t.shape[-1])
y = x + np.random.rand(t.shape[-1])
method = {"this_method":'multi_taper_csd',
"Fs":2*np.pi}
f,c = tsa.coherence(np.vstack([x,y]),csd_method=method)
npt.assert_array_almost_equal(c[0,1],c[1,0])
def multitaper_coherence(x,y,Fs=1000,BW=5):
'''
multitaper_coherence(x,y,Fs=1000,BW=5)
BW is the multitaper bandwidth
returns freqs, cohere
'''
x -= mean(x)
y -= mean(y)
method = {'this_method':'multi_taper_csd','BW':BW,'Fs':Fs}
freqs,cohere = coherence(np.array([x,y]),method)
N = len(x)
freqs = abs(fftfreq(N,1./Fs)[:N/2+1])
return freqs, cohere[0,1]
def test_coherence_welch():
"""Tests that the code runs and that the resulting matrix is symmetric """
t = np.linspace(0,16*np.pi,1024)
x = np.sin(t) + np.sin(2*t) + np.sin(3*t) + np.random.rand(t.shape[-1])
y = x + np.random.rand(t.shape[-1])
method = {"this_method":'welch',
"NFFT":256,
"Fs":2*np.pi}
f,c = tsa.coherence(np.vstack([x,y]),csd_method=method)
np.testing.assert_array_almost_equal(c[0,1],c[1,0])
f_theoretical = ut.get_freqs(method['Fs'],method['NFFT'])
npt.assert_array_almost_equal(f,f_theoretical)
def test_coherence_matlab():
""" Test against coherence values calculated with matlab's mscohere"""
ts = np.loadtxt(os.path.join(test_dir_path, 'tseries12.txt'))
ts0 = ts[1]
ts1 = ts[0]
method = {}
method['this_method'] = 'welch'
method['NFFT'] = 64
method['Fs'] = 1.0
method['noverlap'] = method['NFFT'] // 2
ttt = np.vstack([ts0, ts1])
f, cxy_mlab = tsa.coherence(ttt, csd_method=method)
cxy_matlab = np.loadtxt(os.path.join(test_dir_path, 'cxy_matlab.txt'))
npt.assert_almost_equal(cxy_mlab[0][1], cxy_matlab, decimal=5)
def test_coherence_matlab():
""" Test against coherence values calculated with matlab's mscohere"""
ts = np.loadtxt('tseries12.txt')
ts0 = ts[1]
ts1 = ts[0]
method = {}
method['this_method']='mlab'
method['NFFT'] = 64;
method['Fs'] = 1.0;
method['noverlap'] = method['NFFT']/2
ttt = np.vstack([ts0,ts1])
f,cxy_mlab = tsa.coherence(ttt,csd_method=method)
cxy_matlab = np.loadtxt('cxy_matlab.txt')
npt.assert_almost_equal(cxy_mlab[0][1],cxy_matlab,decimal=5)
def test_coherence_linear_dependence():
"""
Tests that the coherence between two linearly dependent time-series
behaves as expected.
From William Wei's book, according to eq. 14.5.34, if two time-series are
linearly related through:
y(t) = alpha*x(t+time_shift)
then the coherence between them should be equal to:
.. :math:
C(\nu) = \frac{1}{1+\frac{fft_{noise}(\nu)}{fft_{x}(\nu) \cdot \alpha^2}}
"""
t = np.linspace(0, 16 * np.pi, 2**14)
x = (np.sin(t) + np.sin(2 * t) + np.sin(3 * t) +
0.1 * np.random.rand(t.shape[-1]))
N = x.shape[-1]
alpha = 10
m = 3
noise = 0.1 * np.random.randn(t.shape[-1])
y = alpha * np.roll(x, m) + noise
f_noise = fftpack.fft(noise)[0:N // 2]
f_x = fftpack.fft(x)[0:N // 2]
c_t = (1 / (1 + (f_noise / (f_x * (alpha**2)))))
method = {"this_method": 'welch', "NFFT": 2048, "Fs": 2 * np.pi}
f, c = tsa.coherence(np.vstack([x, y]), csd_method=method)
c_t = np.abs(signaltools.resample(c_t, c.shape[-1]))
npt.assert_array_almost_equal(c[0, 1], c_t, 2)
"""
fig03 = plt.figure()
ax03 = fig03.add_subplot(1, 1, 1)
# total causality
ax03.plot(w, f_xy + f_x2y + f_y2x, label='Total causality')
#Interdepence:
f_id = alg.interdependence_xy(Sw)
ax03.plot(w, f_id, label='Interdependence')
coh = np.empty((N, 33))
for i in range(N):
frex, this_coh = alg.coherence(z[i])
coh[i] = this_coh[0, 1]
ax03.plot(frex, np.mean(coh, axis=0), label='Coherence')
ax03.legend()
"""
.. image:: fig/ar_est_2vars_03.png
Finally, we call plt.show(), in order to show the figures:
"""
