def test_statdist_decomposition(self):
P = self.bdc.transition_matrix_sparse()
mu = self.bdc.stationary_distribution()
mun = stationary_distribution_from_eigenvector(P, ncv=self.ncv)
assert_allclose(mu, mun)
def test_tmatrix_cov(self):
cov = tmatrix_cov(self.C)
assert_allclose(cov, self.cov)
cov = tmatrix_cov(self.C, k=1)
assert_allclose(cov, self.cov[1, :, :])
def test_flux(self):
flux = self.bdc.flux(self.a, self.b)
assert_allclose(self.fluxn.toarray(), flux)
def test_pcca_2(self):
P = np.array([[0.0, 1.0, 0.0], [0.0, 0.999, 0.001],
[0.0, 0.001, 0.999]])
chi = pcca(P, 2)
sol = np.array([[1., 0.], [1., 0.], [0., 1.]])
assert_allclose(chi, sol)
def test_error_perturbation(self):
xn = error_perturbation(self.C, self.S1)
assert_allclose(xn, self.x)
Xn = error_perturbation(self.C, self.S2)
assert_allclose(Xn, self.X)
def test_rdl_decomposition_rev(self):
P = self.bdc.transition_matrix_sparse()
mu = self.bdc.stationary_distribution()
"""Non-reversible"""
"""k=None"""
with self.assertRaises(ValueError):
Rn, Dn, Ln = rdl_decomposition(P, reversible=True)
"""norm='standard'"""
Rn, Dn, Ln = rdl_decomposition(P,
k=self.k,
reversible=True,
norm='standard')
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(P.dot(Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(P.transpose().dot(Ln.transpose()).transpose(),
np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.k))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Standard l2-normalization of right eigenvectors except dominant one"""
Yn = np.dot(Rn.T, Rn)
assert_allclose(np.diag(Yn)[1:], 1.0)
"""ncv is not None"""
Rn, Dn, Ln = rdl_decomposition(P,
k=self.k,
reversible=True,
norm='standard',
ncv=self.ncv)
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(P.dot(Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(P.transpose().dot(Ln.transpose()).transpose(),
np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.k))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Standard l2-normalization of right eigenvectors except dominant one"""
Yn = np.dot(Rn.T, Rn)
assert_allclose(np.diag(Yn)[1:], 1.0)
"""norm='reversible'"""
Rn, Dn, Ln = rdl_decomposition(P,
reversible=True,
norm='reversible',
k=self.k)
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(P.dot(Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(P.transpose().dot(Ln.transpose()).transpose(),
np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.k))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Reversibility"""
assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn)
Rn, Dn, Ln = rdl_decomposition(P,
reversible=True,
norm='reversible',
k=self.k,
ncv=self.ncv)
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(P.dot(Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(P.transpose().dot(Ln.transpose()).transpose(),
np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.k))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Reversibility"""
assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn)
"""mu is not None"""
"""norm='standard'"""
Rn, Dn, Ln = rdl_decomposition(P,
k=self.k,
reversible=True,
norm='standard',
mu=mu)
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(P.dot(Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(P.transpose().dot(Ln.transpose()).transpose(),
np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.k))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Standard l2-normalization of right eigenvectors except dominant one"""
Yn = np.dot(Rn.T, Rn)
assert_allclose(np.diag(Yn)[1:], 1.0)
"""ncv is not None"""
Rn, Dn, Ln = rdl_decomposition(P,
k=self.k,
reversible=True,
norm='standard',
ncv=self.ncv,
mu=mu)
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(P.dot(Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(P.transpose().dot(Ln.transpose()).transpose(),
np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.k))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Standard l2-normalization of right eigenvectors except dominant one"""
Yn = np.dot(Rn.T, Rn)
assert_allclose(np.diag(Yn)[1:], 1.0)
"""norm='reversible'"""
Rn, Dn, Ln = rdl_decomposition(P,
reversible=True,
norm='reversible',
k=self.k,
mu=mu)
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(P.dot(Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(P.transpose().dot(Ln.transpose()).transpose(),
np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.k))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Reversibility"""
assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn)
Rn, Dn, Ln = rdl_decomposition(P,
reversible=True,
norm='reversible',
k=self.k,
ncv=self.ncv,
mu=mu)
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(P.dot(Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(P.transpose().dot(Ln.transpose()).transpose(),
np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.k))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Reversibility"""
assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn)
def test_eigenvectors(self):
P = self.bdc.transition_matrix()
# k==None
ev = eigvals(P)
ev = ev[np.argsort(np.abs(ev))[::-1]]
Dn = np.diag(ev)
# right eigenvectors
Rn = eigenvectors(P)
assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn))
# left eigenvectors
Ln = eigenvectors(P, right=False).T
assert_allclose(np.dot(Ln.T, P), np.dot(Dn, Ln.T))
# orthogonality
Xn = np.dot(Ln.T, Rn)
di = np.diag_indices(Xn.shape[0])
Xn[di] = 0.0
assert_allclose(Xn, 0)
# k!=None
Dnk = Dn[:, 0:self.k][0:self.k, :]
# right eigenvectors
Rn = eigenvectors(P, k=self.k)
assert_allclose(np.dot(P, Rn), np.dot(Rn, Dnk))
# left eigenvectors
Ln = eigenvectors(P, right=False, k=self.k).T
assert_allclose(np.dot(Ln.T, P), np.dot(Dnk, Ln.T))
# orthogonality
Xn = np.dot(Ln.T, Rn)
di = np.diag_indices(self.k)
Xn[di] = 0.0
assert_allclose(Xn, 0)
def test_mle_trev(self):
C = np.loadtxt(testpath + 'C_1_lag.dat')
T_impl_algo_sparse_type_sparse = impl_sparse(
scipy.sparse.csr_matrix(C)).toarray()
T_impl_algo_dense_type_dense = impl_dense(C)
T_api_algo_dense_type_dense = apicall(C,
reversible=True,
method='dense')
T_api_algo_sparse_type_dense = apicall(C,
reversible=True,
method='sparse')
T_api_algo_dense_type_sparse = apicall(scipy.sparse.csr_matrix(C),
reversible=True,
method='dense').toarray()
T_api_algo_sparse_type_sparse = apicall(scipy.sparse.csr_matrix(C),
reversible=True,
method='sparse').toarray()
T_api_algo_auto_type_dense = apicall(C, reversible=True, method='auto')
T_api_algo_auto_type_sparse = apicall(scipy.sparse.csr_matrix(C),
reversible=True,
method='auto').toarray()
assert_allclose(T_impl_algo_sparse_type_sparse,
T_impl_algo_dense_type_dense)
assert_allclose(T_api_algo_dense_type_dense,
T_impl_algo_dense_type_dense)
assert_allclose(T_api_algo_sparse_type_dense,
T_impl_algo_dense_type_dense)
assert_allclose(T_api_algo_dense_type_sparse,
T_impl_algo_dense_type_dense)
assert_allclose(T_api_algo_sparse_type_sparse,
T_impl_algo_dense_type_dense)
assert_allclose(T_api_algo_auto_type_dense,
T_impl_algo_dense_type_dense)
assert_allclose(T_api_algo_auto_type_sparse,
T_impl_algo_dense_type_dense)
def test_count_matrix(self):
"""Small test cases"""
C = count_matrix(self.S_short, 1, sliding=False).toarray()
assert_allclose(C, self.B1_lag)
C = count_matrix(self.S_short, 2, sliding=False).toarray()
assert_allclose(C, self.B2_lag)
C = count_matrix(self.S_short, 3, sliding=False).toarray()
assert_allclose(C, self.B3_lag)
C = count_matrix(self.S_short, 1).toarray()
assert_allclose(C, self.B1_sliding)
C = count_matrix(self.S_short, 2).toarray()
assert_allclose(C, self.B2_sliding)
C = count_matrix(self.S_short, 3).toarray()
assert_allclose(C, self.B3_sliding)
"""Larger test cases"""
C = count_matrix(self.S_long, 1, sliding=False).toarray()
assert_allclose(C, self.C1_lag)
C = count_matrix(self.S_long, 7, sliding=False).toarray()
assert_allclose(C, self.C7_lag)
C = count_matrix(self.S_long, 13, sliding=False).toarray()
assert_allclose(C, self.C13_lag)
C = count_matrix(self.S_long, 1).toarray()
assert_allclose(C, self.C1_sliding)
C = count_matrix(self.S_long, 7).toarray()
assert_allclose(C, self.C7_sliding)
C = count_matrix(self.S_long, 13).toarray()
assert_allclose(C, self.C13_sliding)
"""Test raising of value error if lag greater than trajectory length"""
with self.assertRaises(ValueError):
C = count_matrix(self.S_short, 10)
def test_rate(self):
k = self.bdc.rate(self.a, self.b)
assert_allclose(self.kn, k)
def test_pathways(self):
paths, capacities = pathways(self.F, self.A, self.B)
assert_allclose(capacities, self.capacities)
N = len(paths)
for i in range(N):
self.assertTrue(np.all(paths[i] == self.paths[i]))
def test_totalflux(self):
F = self.bdc.totalflux(self.a, self.b)
assert_allclose(self.Fn, F)
def test_flux(self):
flux = self.bdc.flux(self.a, self.b)
assert_allclose(self.fluxn, flux)
def test_statdist_iteration(self):
P = self.bdc.transition_matrix_sparse()
mu = self.bdc.stationary_distribution()
mun = stationary_distribution_from_backward_iteration(P)
assert_allclose(mu, mun)
def test_eigenvectors_rev(self):
P_dense = self.bdc.transition_matrix()
P = self.bdc.transition_matrix_sparse()
ev, L, R = eig(P_dense, left=True, right=True)
ind = np.argsort(np.abs(ev))[::-1]
ev = ev[ind]
R = R[:, ind]
L = L[:, ind]
vals = ev[0:self.k]
"""k=None"""
with self.assertRaises(ValueError):
Rn = eigenvectors(P, reversible=True)
with self.assertRaises(ValueError):
Ln = eigenvectors(P, right=False, reversible=True).T
"""k is not None"""
Rn = eigenvectors(P, k=self.k, reversible=True)
assert_allclose(vals[np.newaxis, :] * Rn, P.dot(Rn))
Ln = eigenvectors(P, right=False, k=self.k, reversible=True).T
assert_allclose(P.transpose().dot(Ln), vals[np.newaxis, :] * Ln)
"""k is not None and ncv is not None"""
Rn = eigenvectors(P, k=self.k, ncv=self.ncv, reversible=True)
assert_allclose(vals[np.newaxis, :] * Rn, P.dot(Rn))
Ln = eigenvectors(P,
right=False,
k=self.k,
ncv=self.ncv,
reversible=True).T
assert_allclose(P.transpose().dot(Ln), vals[np.newaxis, :] * Ln)
"""mu is not None"""
mu = self.bdc.stationary_distribution()
"""k=None"""
with self.assertRaises(ValueError):
Rn = eigenvectors(P, reversible=True, mu=mu)
with self.assertRaises(ValueError):
Ln = eigenvectors(P, right=False, reversible=True, mu=mu).T
"""k is not None"""
Rn = eigenvectors(P, k=self.k, reversible=True, mu=mu)
assert_allclose(vals[np.newaxis, :] * Rn, P.dot(Rn))
Ln = eigenvectors(P, right=False, k=self.k, reversible=True, mu=mu).T
assert_allclose(P.transpose().dot(Ln), vals[np.newaxis, :] * Ln)
"""k is not None and ncv is not None"""
Rn = eigenvectors(P, k=self.k, ncv=self.ncv, reversible=True, mu=mu)
assert_allclose(vals[np.newaxis, :] * Rn, P.dot(Rn))
Ln = eigenvectors(P,
right=False,
k=self.k,
ncv=self.ncv,
reversible=True,
mu=mu).T
assert_allclose(P.transpose().dot(Ln), vals[np.newaxis, :] * Ln)
def test_mle_trev_given_pi(self):
C = np.loadtxt(testpath + 'C_1_lag.dat')
pi = np.loadtxt(testpath + 'pi.dat')
T_impl_algo_dense_type_dense = impl_dense(C, pi)
T_impl_algo_sparse_type_sparse = impl_sparse(
scipy.sparse.csr_matrix(C), pi).toarray()
T_Frank = impl_dense_Frank(C, pi)
T_api_algo_dense_type_dense = apicall(C,
reversible=True,
mu=pi,
method='dense')
T_api_algo_sparse_type_dense = apicall(C,
reversible=True,
mu=pi,
method='sparse')
T_api_algo_dense_type_sparse = apicall(scipy.sparse.csr_matrix(C),
reversible=True,
mu=pi,
method='dense').toarray()
T_api_algo_sparse_type_sparse = apicall(scipy.sparse.csr_matrix(C),
reversible=True,
mu=pi,
method='sparse').toarray()
T_api_algo_auto_type_dense = apicall(C,
reversible=True,
mu=pi,
method='auto')
T_api_algo_auto_type_sparse = apicall(scipy.sparse.csr_matrix(C),
reversible=True,
mu=pi,
method='auto').toarray()
assert_allclose(T_impl_algo_dense_type_dense, T_Frank)
assert_allclose(T_impl_algo_sparse_type_sparse, T_Frank)
assert_allclose(T_api_algo_dense_type_dense, T_Frank)
assert_allclose(T_api_algo_sparse_type_dense, T_Frank)
assert_allclose(T_api_algo_dense_type_sparse, T_Frank)
assert_allclose(T_api_algo_sparse_type_sparse, T_Frank)
assert_allclose(T_api_algo_auto_type_dense, T_Frank)
assert_allclose(T_api_algo_auto_type_sparse, T_Frank)
assert is_transition_matrix(T_Frank)
assert is_transition_matrix(T_impl_algo_dense_type_dense)
assert is_transition_matrix(T_impl_algo_sparse_type_sparse)
assert is_transition_matrix(T_api_algo_dense_type_dense)
assert is_transition_matrix(T_api_algo_sparse_type_dense)
assert is_transition_matrix(T_api_algo_dense_type_sparse)
assert is_transition_matrix(T_api_algo_sparse_type_sparse)
assert is_transition_matrix(T_api_algo_auto_type_dense)
assert is_transition_matrix(T_api_algo_auto_type_sparse)
assert_allclose(statdist(T_Frank), pi)
assert_allclose(statdist(T_impl_algo_dense_type_dense), pi)
assert_allclose(statdist(T_impl_algo_sparse_type_sparse), pi)
assert_allclose(statdist(T_api_algo_dense_type_dense), pi)
assert_allclose(statdist(T_api_algo_sparse_type_dense), pi)
assert_allclose(statdist(T_api_algo_dense_type_sparse), pi)
assert_allclose(statdist(T_api_algo_sparse_type_sparse), pi)
assert_allclose(statdist(T_api_algo_auto_type_dense), pi)
assert_allclose(statdist(T_api_algo_auto_type_sparse), pi)
def test_rdl_decomposition(self):
P = self.bdc.transition_matrix_sparse()
mu = self.bdc.stationary_distribution()
"""Non-reversible"""
"""k=None"""
with self.assertRaises(ValueError):
Rn, Dn, Ln = rdl_decomposition(P)
"""k is not None"""
Rn, Dn, Ln = rdl_decomposition(P, k=self.k)
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(P.dot(Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(P.transpose().dot(Ln.transpose()).transpose(),
np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.k))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""k is not None, ncv is not None"""
Rn, Dn, Ln = rdl_decomposition(P, k=self.k, ncv=self.ncv)
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(P.dot(Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(P.transpose().dot(Ln.transpose()).transpose(),
np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.k))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Reversible"""
"""k=None"""
with self.assertRaises(ValueError):
Rn, Dn, Ln = rdl_decomposition(P, norm='reversible')
"""k is not None"""
Rn, Dn, Ln = rdl_decomposition(P, k=self.k, norm='reversible')
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(P.dot(Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(P.transpose().dot(Ln.transpose()).transpose(),
np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.k))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Reversibility"""
assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn)
"""k is not None ncv is not None"""
Rn, Dn, Ln = rdl_decomposition(P,
k=self.k,
norm='reversible',
ncv=self.ncv)
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(P.dot(Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(P.transpose().dot(Ln.transpose()).transpose(),
np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.k))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Reversibility"""
assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn)
def test_prior_neighbor(self):
Bn = prior_neighbor(self.C)
assert_allclose(Bn, self.alpha_def * self.B_neighbor)
Bn = prior_neighbor(self.C, alpha=self.alpha)
assert_allclose(Bn, self.alpha * self.B_neighbor)
def test_statdist(self):
P = self.bdc.transition_matrix()
mu = self.bdc.stationary_distribution()
mun = stationary_distribution(P)
assert_allclose(mu, mun)
def test_prior_const(self):
Bn = prior_const(self.C)
assert_allclose(Bn, self.alpha_def * self.B_const)
Bn = prior_const(self.C, alpha=self.alpha)
assert_allclose(Bn, self.alpha * self.B_const)
def test_pcca_1(self):
P = np.array([[1, 0], [0, 1]])
chi = pcca(P, 2)
sol = np.array([[1., 0.], [0., 1.]])
assert_allclose(chi, sol)
def test_prior_rev(self):
Bn = prior_rev(self.C)
assert_allclose(Bn, -1.0 * self.B_rev)
Bn = prior_rev(self.C, alpha=self.alpha)
assert_allclose(Bn, self.alpha * self.B_rev)
def test_pcca_4(self):
P = np.array([[0.9, 0.1, 0.0, 0.0], [0.1, 0.8, 0.1, 0.0],
[0.0, 0.0, 0.8, 0.2], [0.0, 0.0, 0.2, 0.8]])
chi = pcca(P, 2)
sol = np.array([[1., 0.], [1., 0.], [1., 0.], [0., 1.]])
assert_allclose(chi, sol)
def test_backward_comittor(self):
P = self.bdc.transition_matrix()
un = committor.backward_committor(P, [0, 1], [8, 9])
u = self.bdc.committor_backward(1, 8)
assert_allclose(un, u)
def test_transition_matrix(self):
"""Non-reversible"""
T = transition_matrix(self.C1).toarray()
assert_allclose(T, self.T1.toarray())
T = transition_matrix(self.C2).toarray()
assert_allclose(T, self.T2.toarray())
"""Reversible"""
T = transition_matrix(self.C1, rversible=True).toarray()
assert_allclose(T, self.T1.toarray())
T = transition_matrix(self.C2, reversible=True).toarray()
assert_allclose(T, self.T2.toarray())
"""Reversible with fixed pi"""
T = transition_matrix(self.C1, rversible=True, pi=self.pi1).toarray()
assert_allclose(T, self.T1.toarray())
T = transition_matrix(self.C2, rversible=True, pi=self.pi2).toarray()
assert_allclose(T, self.T2.toarray())
def test_rdl_decomposition(self):
P = self.bdc.transition_matrix()
mu = self.bdc.stationary_distribution()
"""Non-reversible"""
"""k=None"""
Rn, Dn, Ln = rdl_decomposition(P)
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.dim))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""k is not None"""
Rn, Dn, Ln = rdl_decomposition(P, k=self.k)
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.k))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Reversible"""
"""k=None"""
Rn, Dn, Ln = rdl_decomposition(P, norm='reversible')
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.dim))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Reversibility"""
assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn)
"""k is not None"""
Rn, Dn, Ln = rdl_decomposition(P, norm='reversible', k=self.k)
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.k))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Reversibility"""
assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn)
def test_remove_negative_entries(self):
A = csr_matrix(self.A)
Aplus = self.Aplus
Aplusn = tpt.remove_negative_entries(A)
assert_allclose(Aplusn.toarray(), Aplus)
def test_rdl_decomposition_rev(self):
P = self.bdc.transition_matrix()
mu = self.bdc.stationary_distribution()
"""norm='standard'"""
"""k=None"""
Rn, Dn, Ln = rdl_decomposition(P, reversible=True, norm='standard')
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.dim))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Standard l2-normalization of right eigenvectors except dominant one"""
Yn = np.dot(Rn.T, Rn)
assert_allclose(np.diag(Yn)[1:], 1.0)
"""k is not None"""
Rn, Dn, Ln = rdl_decomposition(P,
k=self.k,
reversible=True,
norm='standard')
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.k))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Standard l2-normalization of right eigenvectors except dominant one"""
Yn = np.dot(Rn.T, Rn)
assert_allclose(np.diag(Yn)[1:], 1.0)
"""norm='reversible'"""
"""k=None"""
Rn, Dn, Ln = rdl_decomposition(P, reversible=True, norm='reversible')
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.dim))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Reversibility"""
assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn)
"""k is not None"""
Rn, Dn, Ln = rdl_decomposition(P,
reversible=True,
norm='reversible',
k=self.k)
Xn = np.dot(Ln, Rn)
"""Right-eigenvectors"""
assert_allclose(np.dot(P, Rn), np.dot(Rn, Dn))
"""Left-eigenvectors"""
assert_allclose(np.dot(Ln, P), np.dot(Dn, Ln))
"""Orthonormality"""
assert_allclose(Xn, np.eye(self.k))
"""Probability vector"""
assert_allclose(np.sum(Ln[0, :]), 1.0)
"""Reversibility"""
assert_allclose(Ln.transpose(), mu[:, np.newaxis] * Rn)
def test_netflux(self):
netflux = self.bdc.netflux(self.a, self.b)
assert_allclose(self.netfluxn.toarray(), netflux)
def test_fingerprint_correlation(self):
"""Autocorrelation"""
"""k=None, tau=1"""
acorr_amp = np.dot(self.mu * self.obs1, self.R) * np.dot(
self.L, self.obs1)
tsn, acorr_ampn = fingerprint_correlation(self.T, self.obs1)
assert_allclose(tsn, self.ts)
assert_allclose(acorr_ampn, acorr_amp)
"""k=None, tau=7.5"""
tau = self.tau
tsn, acorr_ampn = fingerprint_correlation(self.T, self.obs1, tau=tau)
assert_allclose(tsn, tau * self.ts)
assert_allclose(acorr_ampn, acorr_amp)
"""k=4, tau=1"""
k = self.k
acorr_amp = np.dot(self.mu * self.obs1, self.R[:, 0:k]) * np.dot(
self.L[0:k, :], self.obs1)
tsn, acorr_ampn = fingerprint_correlation(self.T, self.obs1, k=k)
assert_allclose(tsn, self.ts[0:k])
assert_allclose(acorr_ampn, acorr_amp)
"""k=4, tau=7.5"""
tau = self.tau
tsn, acorr_ampn = fingerprint_correlation(self.T,
self.obs1,
k=k,
tau=tau)
assert_allclose(tsn, tau * self.ts[0:k])
assert_allclose(acorr_ampn, acorr_amp)
"""Cross-correlation"""
"""k=None, tau=1"""
corr_amp = np.dot(self.mu * self.obs1, self.R) * np.dot(
self.L, self.obs2)
tsn, corr_ampn = fingerprint_correlation(self.T,
self.obs1,
obs2=self.obs2)
assert_allclose(tsn, self.ts)
assert_allclose(corr_ampn, corr_amp)
"""k=None, tau=7.5"""
tau = self.tau
tsn, corr_ampn = fingerprint_correlation(self.T,
self.obs1,
obs2=self.obs2,
tau=tau)
assert_allclose(tsn, tau * self.ts)
assert_allclose(corr_ampn, corr_amp)
"""k=4, tau=1"""
k = self.k
corr_amp = np.dot(self.mu * self.obs1, self.R[:, 0:k]) * np.dot(
self.L[0:k, :], self.obs2)
tsn, corr_ampn = fingerprint_correlation(self.T,
self.obs1,
obs2=self.obs2,
k=k)
assert_allclose(tsn, self.ts[0:k])
assert_allclose(corr_ampn, corr_amp)
"""k=4, tau=7.5"""
tau = self.tau
tsn, corr_ampn = fingerprint_correlation(self.T,
self.obs1,
obs2=self.obs2,
k=k,
tau=tau)
assert_allclose(tsn, tau * self.ts[0:k])
assert_allclose(corr_ampn, corr_amp)
