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)