class TestCommittorDense(unittest.TestCase):
def setUp(self):
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
def tearDown(self):
pass
def test_forward_comittor(self):
P = self.bdc.transition_matrix()
un = committor(P, [0, 1], [8, 9], forward=True)
u = self.bdc.committor_forward(1, 8)
assert_allclose(un, u)
def test_backward_comittor(self):
P = self.bdc.transition_matrix()
un = committor(P, [0, 1], [8, 9], forward=False)
u = self.bdc.committor_backward(1, 8)
assert_allclose(un, u)
class TestCommittorDense(unittest.TestCase):
def setUp(self):
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
def tearDown(self):
pass
def test_forward_comittor(self):
P = self.bdc.transition_matrix()
un = committor(P, [0, 1], [8, 9], forward=True)
u = self.bdc.committor_forward(1, 8)
assert_allclose(un, u)
def test_backward_comittor(self):
P = self.bdc.transition_matrix()
un = committor(P, [0, 1], [8, 9], forward=False)
u = self.bdc.committor_backward(1, 8)
assert_allclose(un, u)
def setUp(self):
self.k = 4
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix_sparse()
R, D, L = rdl_decomposition(self.T, k=self.k)
self.L = L
self.R = R
self.ts = timescales(self.T, k=self.k)
self.times = np.array([1, 5, 10, 20, 100])
ev = np.diagonal(D)
self.ev_t = ev[np.newaxis, :]**self.times[:, np.newaxis]
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
obs2 = np.zeros(10)
obs2[8] = 1
obs2[9] = 1
self.obs1 = obs1
self.obs2 = obs2
self.one_vec = np.ones(10)
class TestCommittorSparse(unittest.TestCase):
def setUp(self):
p = np.zeros(100)
q = np.zeros(100)
p[0:-1] = 0.5
q[1:] = 0.5
p[49] = 0.01
q[51] = 0.1
self.bdc = BirthDeathChain(q, p)
def tearDown(self):
pass
def test_forward_comittor(self):
P = self.bdc.transition_matrix_sparse()
un = committor(P, range(10), range(90, 100), forward=True)
u = self.bdc.committor_forward(9, 90)
assert_allclose(un, u)
def test_backward_comittor(self):
P = self.bdc.transition_matrix_sparse()
un = committor(P, range(10), range(90, 100), forward=False)
u = self.bdc.committor_backward(9, 90)
assert_allclose(un, u)
def setUp(self):
self.k = 4
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix_sparse()
"""Test matrix-vector product against spectral decomposition"""
R, D, L = rdl_decomposition(self.T, k=self.k)
self.L = L
self.R = R
self.ts = timescales(self.T, k=self.k)
self.times = np.array([1, 5, 10, 20, 100])
ev = np.diagonal(D)
self.ev_t = ev[np.newaxis, :]**self.times[:, np.newaxis]
"""Observable"""
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
self.obs = obs1
"""Initial distribution"""
w0 = np.zeros(10)
w0[0:4] = 0.25
self.p0 = w0
class TestCommittorSparse(unittest.TestCase):
def setUp(self):
p = np.zeros(100)
q = np.zeros(100)
p[0:-1] = 0.5
q[1:] = 0.5
p[49] = 0.01
q[51] = 0.1
self.bdc = BirthDeathChain(q, p)
def tearDown(self):
pass
def test_forward_comittor(self):
P = self.bdc.transition_matrix_sparse()
un = committor(P, range(10), range(90, 100), forward=True)
u = self.bdc.committor_forward(9, 90)
assert_allclose(un, u)
def test_backward_comittor(self):
P = self.bdc.transition_matrix_sparse()
un = committor(P, range(10), range(90, 100), forward=False)
u = self.bdc.committor_backward(9, 90)
assert_allclose(un, u)
def setUp(self):
"""Store state of the rng"""
self.state = np.random.mtrand.get_state()
"""Reseed the rng to enforce 'deterministic' behavior"""
np.random.mtrand.seed(42)
"""Meta-stable birth-death chain"""
b = 2
q = np.zeros(7)
p = np.zeros(7)
q[1:] = 0.5
p[0:-1] = 0.5
q[2] = 1.0 - 10**(-b)
q[4] = 10**(-b)
p[2] = 10**(-b)
p[4] = 1.0 - 10**(-b)
bdc = BirthDeathChain(q, p)
P = bdc.transition_matrix()
self.dtrajs = [generate_traj(P, 10000, start=0)]
self.tau = 1
"""Estimate MSM"""
self.C_MSM = cmatrix(self.dtrajs, self.tau, sliding=True).toarray()
self.lcc_MSM = largest_connected_set(self.C_MSM)
self.Ccc_MSM = connected_cmatrix(self.C_MSM, lcc=self.lcc_MSM)
self.P_MSM = tmatrix(self.Ccc_MSM, reversible=True)
self.mu_MSM = statdist(self.P_MSM)
self.k = 3
self.ts = timescales(self.P_MSM, k=self.k + 1, tau=self.tau)[1:]
def setUp(self):
"""Store state of the rng"""
self.state = np.random.mtrand.get_state()
"""Reseed the rng to enforce 'deterministic' behavior"""
np.random.mtrand.seed(42)
"""Meta-stable birth-death chain"""
b = 2
q = np.zeros(7)
p = np.zeros(7)
q[1:] = 0.5
p[0:-1] = 0.5
q[2] = 1.0-10**(-b)
q[4] = 10**(-b)
p[2] = 10**(-b)
p[4] = 1.0-10**(-b)
bdc = BirthDeathChain(q, p)
P = bdc.transition_matrix()
self.dtrajs = [generate_traj(P, 10000, start=0)]
self.tau = 1
"""Estimate MSM"""
self.C_MSM = cmatrix(self.dtrajs, self.tau, sliding=True).toarray()
self.lcc_MSM = largest_connected_set(self.C_MSM)
self.Ccc_MSM = connected_cmatrix(self.C_MSM, lcc=self.lcc_MSM)
self.P_MSM = tmatrix(self.Ccc_MSM, reversible=True)
self.mu_MSM = statdist(self.P_MSM)
self.k = 3
self.ts = timescales(self.P_MSM, k=self.k+1, tau=self.tau)[1:]
def setUp(self):
p = np.zeros(100)
q = np.zeros(100)
p[0:-1] = 0.5
q[1:] = 0.5
p[49] = 0.01
q[51] = 0.1
self.bdc = BirthDeathChain(q, p)
class TestCorrelationSparse(unittest.TestCase):
def setUp(self):
self.k = 4
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix_sparse()
R, D, L = rdl_decomposition(self.T, k=self.k)
self.L = L
self.R = R
self.ts = timescales(self.T, k=self.k)
self.times = np.array([1, 5, 10, 20, 100])
ev = np.diagonal(D)
self.ev_t = ev[np.newaxis, :]**self.times[:, np.newaxis]
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
obs2 = np.zeros(10)
obs2[8] = 1
obs2[9] = 1
self.obs1 = obs1
self.obs2 = obs2
self.one_vec = np.ones(10)
def test_correlation(self):
"""Auto-correlation"""
acorr_amp = np.dot(self.mu * self.obs1, self.R) * np.dot(
self.L, self.obs1)
acorr = np.dot(self.ev_t, acorr_amp)
acorrn = correlation(self.T, self.obs1, k=self.k, times=self.times)
assert_allclose(acorrn, acorr)
"""Cross-correlation"""
corr_amp = np.dot(self.mu * self.obs1, self.R) * np.dot(
self.L, self.obs2)
corr = np.dot(self.ev_t, corr_amp)
corrn = correlation(self.T,
self.obs1,
obs2=self.obs2,
k=self.k,
times=self.times)
assert_allclose(corrn, corr)
def setUp(self):
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
self.T = self.bdc.transition_matrix()
self.mu = self.bdc.stationary_distribution()
self.A = create_rate_matrix()
class TestRelaxationDense(unittest.TestCase):
def setUp(self):
p=np.zeros(10)
q=np.zeros(10)
p[0:-1]=0.5
q[1:]=0.5
p[4]=0.01
q[6]=0.1
self.bdc=BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix()
"""Test matrix-vector product against spectral decomposition"""
R, D, L=rdl_decomposition(self.T)
self.L=L
self.R=R
self.ts=timescales(self.T)
self.times=np.array([1, 5, 10, 20, 100])
ev=np.diagonal(D)
self.ev_t=ev[np.newaxis,:]**self.times[:,np.newaxis]
self.k=4
"""Observable"""
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
self.obs=obs1
"""Initial distribution"""
w0=np.zeros(10)
w0[0:4]=0.25
self.p0=w0
def test_relaxation(self):
"""k=None"""
relax_amp=np.dot(self.p0, self.R)*np.dot(self.L, self.obs)
relax=np.dot(self.ev_t, relax_amp)
relaxn=relaxation(self.T, self.p0, self.obs, times=self.times)
self.assertTrue(np.allclose(relaxn, relax))
"""k=4"""
k=self.k
relax_amp=np.dot(self.p0, self.R[:,0:k])*np.dot(self.L[0:k,:], self.obs)
relax=np.dot(self.ev_t[:,0:k], relax_amp)
relaxn=relaxation(self.T, self.p0, self.obs, k=k, times=self.times)
self.assertTrue(np.allclose(relaxn, relax))
def setUp(self):
self.dim = 100
self.k = 10
"""Set up meta-stable birth-death chain"""
p = np.zeros(self.dim)
p[0:-1] = 0.5
q = np.zeros(self.dim)
q[1:] = 0.5
p[self.dim / 2 - 1] = 0.001
q[self.dim / 2 + 1] = 0.001
self.bdc = BirthDeathChain(q, p)
class TestRelaxationDense(unittest.TestCase):
def setUp(self):
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix()
"""Test matrix-vector product against spectral decomposition"""
R, D, L = rdl_decomposition(self.T)
self.L = L
self.R = R
self.ts = timescales(self.T)
self.times = np.array([1, 5, 10, 20, 100])
ev = np.diagonal(D)
self.ev_t = ev[np.newaxis, :] ** self.times[:, np.newaxis]
self.k = 4
"""Observable"""
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
self.obs = obs1
"""Initial distribution"""
w0 = np.zeros(10)
w0[0:4] = 0.25
self.p0 = w0
def test_relaxation(self):
"""k=None"""
relax_amp = np.dot(self.p0, self.R) * np.dot(self.L, self.obs)
relax = np.dot(self.ev_t, relax_amp)
relaxn = relaxation(self.T, self.p0, self.obs, times=self.times)
assert_allclose(relaxn, relax)
"""k=4"""
k = self.k
relax_amp = np.dot(self.p0, self.R[:, 0:k]) * np.dot(self.L[0:k, :], self.obs)
relax = np.dot(self.ev_t[:, 0:k], relax_amp)
relaxn = relaxation(self.T, self.p0, self.obs, k=k, times=self.times)
assert_allclose(relaxn, relax)
class TestCorrelationSparse(unittest.TestCase):
def setUp(self):
self.k=4
p=np.zeros(10)
q=np.zeros(10)
p[0:-1]=0.5
q[1:]=0.5
p[4]=0.01
q[6]=0.1
self.bdc=BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix_sparse()
R, D, L=rdl_decomposition(self.T, k=self.k)
self.L=L
self.R=R
self.ts=timescales(self.T, k=self.k)
self.times=np.array([1, 5, 10, 20, 100])
ev=np.diagonal(D)
self.ev_t=ev[np.newaxis,:]**self.times[:,np.newaxis]
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
obs2 = np.zeros(10)
obs2[8] = 1
obs2[9] = 1
self.obs1=obs1
self.obs2=obs2
self.one_vec=np.ones(10)
def test_correlation(self):
"""Auto-correlation"""
acorr_amp=np.dot(self.mu*self.obs1, self.R)*np.dot(self.L, self.obs1)
acorr=np.dot(self.ev_t, acorr_amp)
acorrn=correlation(self.T, self.obs1, k=self.k, times=self.times)
self.assertTrue(np.allclose(acorrn, acorr))
"""Cross-correlation"""
corr_amp=np.dot(self.mu*self.obs1, self.R)*np.dot(self.L, self.obs2)
corr=np.dot(self.ev_t, corr_amp)
corrn=correlation(self.T, self.obs1, obs2=self.obs2, k=self.k, times=self.times)
self.assertTrue(np.allclose(corrn, corr))
def setUp(self):
self.k=4
p=np.zeros(10)
q=np.zeros(10)
p[0:-1]=0.5
q[1:]=0.5
p[4]=0.01
q[6]=0.1
self.bdc=BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix_sparse()
"""Test matrix-vector product against spectral decomposition"""
R, D, L=rdl_decomposition(self.T, k=self.k)
self.L=L
self.R=R
self.ts=timescales(self.T, k=self.k)
self.times=np.array([1, 5, 10, 20, 100])
ev=np.diagonal(D)
self.ev_t=ev[np.newaxis,:]**self.times[:,np.newaxis]
"""Observable"""
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
self.obs=obs1
"""Initial distribution"""
w0=np.zeros(10)
w0[0:4]=0.25
self.p0=w0
def setUp(self):
self.k=4
p=np.zeros(10)
q=np.zeros(10)
p[0:-1]=0.5
q[1:]=0.5
p[4]=0.01
q[6]=0.1
self.bdc=BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix_sparse()
R, D, L=rdl_decomposition(self.T, k=self.k)
self.L=L
self.R=R
self.ts=timescales(self.T, k=self.k)
self.times=np.array([1, 5, 10, 20, 100])
ev=np.diagonal(D)
self.ev_t=ev[np.newaxis,:]**self.times[:,np.newaxis]
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
obs2 = np.zeros(10)
obs2[8] = 1
obs2[9] = 1
self.obs1=obs1
self.obs2=obs2
self.one_vec=np.ones(10)
def setUp(self):
p = np.zeros(100)
q = np.zeros(100)
p[0:-1] = 0.5
q[1:] = 0.5
p[49] = 0.01
q[51] = 0.1
self.bdc = BirthDeathChain(q, p)
class TestAssessmentDense(unittest.TestCase):
def setUp(self):
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
self.T = self.bdc.transition_matrix()
self.mu = self.bdc.stationary_distribution()
self.A = create_rate_matrix()
def test_IsRateMatrix(self):
self.assert_(is_rate_matrix(self.A), \
'A should be a rate matrix')
# manipulate matrix so it isn't a rate matrix any more
self.A[0][0] = 3
self.assertFalse(is_rate_matrix(self.A), \
'matrix is not a rate matrix')
def test_IsReversible(self):
# create a reversible matrix
self.assertTrue(is_reversible(self.T, self.mu),
"T should be reversible")
def test_is_transition_matrix(self):
self.assertTrue(is_transition_matrix(self.T))
"""Larger test-case to prevent too restrictive tolerance settings"""
X=np.random.random((2000, 2000))
Tlarge=X/X.sum(axis=1)[:,np.newaxis]
self.assertTrue(is_transition_matrix(Tlarge))
def test_is_connected(self):
self.assertTrue(is_connected(self.T))
self.assertTrue(is_connected(self.T, directed=False))
def setUp(self):
self.k = 4
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix_sparse()
R, D, L = rdl_decomposition(self.T, k=self.k)
self.L = L
self.R = R
self.ts = timescales(self.T, k=self.k)
self.times = np.array([1, 5, 10, 20])
ev = np.diagonal(D)
self.ev_t = ev[np.newaxis, :] ** self.times[:, np.newaxis]
self.tau = 7.5
"""Observables"""
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
obs2 = np.zeros(10)
obs2[8] = 1
obs2[9] = 1
self.obs1 = obs1
self.obs2 = obs2
"""Initial vector for relaxation"""
w0 = np.zeros(10)
w0[0:4] = 0.25
self.p0 = w0
def setUp(self):
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
self.T = self.bdc.transition_matrix()
self.mu = self.bdc.stationary_distribution()
self.A = create_rate_matrix()
class TestAssessmentDense(unittest.TestCase):
def setUp(self):
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
self.T = self.bdc.transition_matrix()
self.mu = self.bdc.stationary_distribution()
self.A = create_rate_matrix()
def test_IsRateMatrix(self):
self.assert_(is_rate_matrix(self.A), 'A should be a rate matrix')
# manipulate matrix so it isn't a rate matrix any more
self.A[0][0] = 3
self.assertFalse(is_rate_matrix(self.A), 'matrix is not a rate matrix')
def test_IsReversible(self):
# create a reversible matrix
self.assertTrue(is_reversible(self.T, self.mu),
"T should be reversible")
def test_is_transition_matrix(self):
self.assertTrue(is_transition_matrix(self.T))
"""Larger test-case to prevent too restrictive tolerance settings"""
X = np.random.random((2000, 2000))
Tlarge = X / X.sum(axis=1)[:, np.newaxis]
self.assertTrue(is_transition_matrix(Tlarge))
def test_is_connected(self):
self.assertTrue(is_connected(self.T))
self.assertTrue(is_connected(self.T, directed=False))
def setUp(self):
self.dim=100
self.k=10
"""Set up meta-stable birth-death chain"""
p=np.zeros(self.dim)
p[0:-1]=0.5
q=np.zeros(self.dim)
q[1:]=0.5
p[self.dim/2-1]=0.001
q[self.dim/2+1]=0.001
self.bdc=BirthDeathChain(q, p)
class TestAssessmentDense(unittest.TestCase):
def setUp(self):
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
self.T = self.bdc.transition_matrix()
self.mu = self.bdc.stationary_distribution()
self.A = create_rate_matrix()
def test_IsRateMatrix(self):
self.assert_(is_rate_matrix(self.A), \
'A should be a rate matrix')
# manipulate matrix so it isn't a rate matrix any more
self.A[0][0] = 3
self.assertFalse(is_rate_matrix(self.A), \
'matrix is not a rate matrix')
def test_IsReversible(self):
# create a reversible matrix
self.assertTrue(is_reversible(self.T, self.mu),
"T should be reversible")
def test_is_transition_matrix(self):
self.assertTrue(is_transition_matrix(self.T))
def test_is_connected(self):
self.assertTrue(is_connected(self.T))
self.assertTrue(is_connected(self.T, directed=False))
class TestExpectation(unittest.TestCase):
def setUp(self):
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix()
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
self.obs1 = obs1
def test_expectation(self):
exp = np.dot(self.mu, self.obs1)
expn = expectation(self.T, self.obs1)
assert_allclose(exp, expn)
class TestExpectation(unittest.TestCase):
def setUp(self):
p=np.zeros(10)
q=np.zeros(10)
p[0:-1]=0.5
q[1:]=0.5
p[4]=0.01
q[6]=0.1
self.bdc=BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix()
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
self.obs1=obs1
def test_expectation(self):
exp=np.dot(self.mu, self.obs1)
expn=expectation(self.T, self.obs1)
self.assertTrue(np.allclose(exp, expn))
def setUp(self):
self.k=4
p=np.zeros(10)
q=np.zeros(10)
p[0:-1]=0.5
q[1:]=0.5
p[4]=0.01
q[6]=0.1
self.bdc=BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix_sparse()
R, D, L=rdl_decomposition(self.T, k=self.k)
self.L=L
self.R=R
self.ts=timescales(self.T, k=self.k)
self.times=np.array([1, 5, 10, 20])
ev=np.diagonal(D)
self.ev_t=ev[np.newaxis,:]**self.times[:,np.newaxis]
self.tau=7.5
"""Observables"""
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
obs2 = np.zeros(10)
obs2[8] = 1
obs2[9] = 1
self.obs1=obs1
self.obs2=obs2
"""Initial vector for relaxation"""
w0=np.zeros(10)
w0[0:4]=0.25
self.p0=w0
class TestDecomposition(unittest.TestCase):
def setUp(self):
self.dim = 100
self.k = 10
self.ncv = 40
"""Set up meta-stable birth-death chain"""
p = np.zeros(self.dim)
p[0:-1] = 0.5
q = np.zeros(self.dim)
q[1:] = 0.5
p[self.dim / 2 - 1] = 0.001
q[self.dim / 2 + 1] = 0.001
self.bdc = BirthDeathChain(q, p)
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_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_eigenvalues(self):
P = self.bdc.transition_matrix()
P_dense = self.bdc.transition_matrix()
ev = eigvals(P_dense)
"""Sort with decreasing magnitude"""
ev = ev[np.argsort(np.abs(ev))[::-1]]
"""k=None"""
with self.assertRaises(ValueError):
evn = eigenvalues(P)
"""k is not None"""
evn = eigenvalues(P, k=self.k)
assert_allclose(ev[0:self.k], evn)
"""k is not None and ncv is not None"""
evn = eigenvalues(P, k=self.k, ncv=self.ncv)
assert_allclose(ev[0:self.k], evn)
def test_eigenvectors(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)
with self.assertRaises(ValueError):
Ln = eigenvectors(P, right=False)
"""k is not None"""
Rn = eigenvectors(P, k=self.k)
assert_allclose(vals[np.newaxis, :] * Rn, P.dot(Rn))
Ln = eigenvectors(P, right=False, k=self.k)
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)
assert_allclose(vals[np.newaxis, :] * Rn, P.dot(Rn))
Ln = eigenvectors(P, right=False, k=self.k, ncv=self.ncv)
assert_allclose(P.transpose().dot(Ln), vals[np.newaxis, :] * Ln)
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_timescales(self):
P_dense = self.bdc.transition_matrix()
P = self.bdc.transition_matrix_sparse()
ev = eigvals(P_dense)
"""Sort with decreasing magnitude"""
ev = ev[np.argsort(np.abs(ev))[::-1]]
ts = -1.0 / np.log(np.abs(ev))
"""k=None"""
with self.assertRaises(ValueError):
tsn = timescales(P)
"""k is not None"""
tsn = timescales(P, k=self.k)
assert_allclose(ts[1:self.k], tsn[1:])
"""k is not None, ncv is not None"""
tsn = timescales(P, k=self.k, ncv=self.ncv)
assert_allclose(ts[1:self.k], tsn[1:])
"""tau=7"""
"""k is not None"""
tsn = timescales(P, k=self.k, tau=7)
assert_allclose(7 * ts[1:self.k], tsn[1:])
class TestDecompositionDense(unittest.TestCase):
def setUp(self):
self.dim = 100
self.k = 10
"""Set up meta-stable birth-death chain"""
p = np.zeros(self.dim)
p[0:-1] = 0.5
q = np.zeros(self.dim)
q[1:] = 0.5
p[int(self.dim / 2 - 1)] = 0.001
q[int(self.dim / 2 + 1)] = 0.001
self.bdc = BirthDeathChain(q, p)
def test_statdist(self):
P = self.bdc.transition_matrix()
mu = self.bdc.stationary_distribution()
mun = stationary_distribution(P)
assert_allclose(mu, mun)
def test_eigenvalues(self):
P = self.bdc.transition_matrix()
ev = eigvals(P)
"""Sort with decreasing magnitude"""
ev = ev[np.argsort(np.abs(ev))[::-1]]
"""k=None"""
evn = eigenvalues(P)
assert_allclose(ev, evn)
"""k is not None"""
evn = eigenvalues(P, k=self.k)
assert_allclose(ev[0:self.k], evn)
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_eigenvalues_reversible(self):
P = self.bdc.transition_matrix()
ev = eigvals(P)
"""Sort with decreasing magnitude"""
ev = ev[np.argsort(np.abs(ev))[::-1]]
"""reversible without given mu"""
evn = eigenvalues(P, reversible=True)
assert_allclose(ev, evn)
"""reversible with given mu"""
evn = eigenvalues(P, reversible=True, mu=self.bdc.stationary_distribution())
assert_allclose(ev, evn)
def test_eigenvectors_reversible(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, reversible=True)
assert_allclose(np.dot(P,Rn),np.dot(Rn,Dn))
# left eigenvectors
Ln = eigenvectors(P, right=False, reversible=True).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, reversible=True)
assert_allclose(np.dot(P,Rn),np.dot(Rn,Dnk))
# left eigenvectors
Ln = eigenvectors(P, right=False, k=self.k, reversible=True).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_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_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_timescales(self):
P = self.bdc.transition_matrix()
ev = eigvals(P)
"""Sort with decreasing magnitude"""
ev = ev[np.argsort(np.abs(ev))[::-1]]
ts = -1.0 / np.log(np.abs(ev))
"""k=None"""
tsn = timescales(P)
assert_allclose(ts[1:], tsn[1:])
"""k is not None"""
tsn = timescales(P, k=self.k)
assert_allclose(ts[1:self.k], tsn[1:])
"""tau=7"""
"""k=None"""
tsn = timescales(P, tau=7)
assert_allclose(7 * ts[1:], tsn[1:])
"""k is not None"""
tsn = timescales(P, k=self.k, tau=7)
assert_allclose(7 * ts[1:self.k], tsn[1:])
def test_timescales_rev(self):
P_dense = self.bdc.transition_matrix()
P = self.bdc.transition_matrix()
mu = self.bdc.stationary_distribution()
ev = eigvals(P_dense)
"""Sort with decreasing magnitude"""
ev = ev[np.argsort(np.abs(ev))[::-1]]
ts = -1.0 / np.log(np.abs(ev))
tsn = timescales(P, reversible=True)
assert_allclose(ts[1:], tsn[1:])
"""k is not None"""
tsn = timescales(P, k=self.k, reversible=True)
assert_allclose(ts[1:self.k], tsn[1:])
"""k is not None, mu is not None"""
tsn = timescales(P, k=self.k, reversible=True, mu=mu)
assert_allclose(ts[1:self.k], tsn[1:])
"""tau=7"""
"""k is not None"""
tsn = timescales(P, k=self.k, tau=7, reversible=True)
assert_allclose(7 * ts[1:self.k], tsn[1:])
class TestDecompositionDense(unittest.TestCase):
def setUp(self):
self.dim = 100
self.k = 10
"""Set up meta-stable birth-death chain"""
p = np.zeros(self.dim)
p[0:-1] = 0.5
q = np.zeros(self.dim)
q[1:] = 0.5
p[self.dim / 2 - 1] = 0.001
q[self.dim / 2 + 1] = 0.001
self.bdc = BirthDeathChain(q, p)
def test_statdist(self):
P = self.bdc.transition_matrix()
mu = self.bdc.stationary_distribution()
mun = stationary_distribution(P)
assert_allclose(mu, mun)
def test_eigenvalues(self):
P = self.bdc.transition_matrix()
ev = eigvals(P)
"""Sort with decreasing magnitude"""
ev = ev[np.argsort(np.abs(ev))[::-1]]
"""k=None"""
evn = eigenvalues(P)
assert_allclose(ev, evn)
"""k is not None"""
evn = eigenvalues(P, k=self.k)
assert_allclose(ev[0:self.k], evn)
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)
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)
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_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_timescales(self):
P = self.bdc.transition_matrix()
ev = eigvals(P)
"""Sort with decreasing magnitude"""
ev = ev[np.argsort(np.abs(ev))[::-1]]
ts = -1.0 / np.log(np.abs(ev))
"""k=None"""
tsn = timescales(P)
assert_allclose(ts[1:], tsn[1:])
"""k is not None"""
tsn = timescales(P, k=self.k)
assert_allclose(ts[1:self.k], tsn[1:])
"""tau=7"""
"""k=None"""
tsn = timescales(P, tau=7)
assert_allclose(7 * ts[1:], tsn[1:])
"""k is not None"""
tsn = timescales(P, k=self.k, tau=7)
assert_allclose(7 * ts[1:self.k], tsn[1:])
class TestCorrelationDense(unittest.TestCase):
def setUp(self):
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix()
R, D, L = rdl_decomposition(self.T, norm='reversible')
self.L = L
self.R = R
self.ts = timescales(self.T)
self.times = np.array([1, 5, 10, 20, 100])
ev = np.diagonal(D)
self.ev_t = ev[np.newaxis, :] ** self.times[:, np.newaxis]
self.k = 4
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
obs2 = np.zeros(10)
obs2[8] = 1
obs2[9] = 1
self.obs1 = obs1
self.obs2 = obs2
self.one_vec = np.ones(10)
def test_correlation(self):
"""Auto-correlation"""
"""k=None"""
acorr_amp = np.dot(self.mu * self.obs1, self.R) * np.dot(self.L, self.obs1)
acorr = np.dot(self.ev_t, acorr_amp)
acorrn = correlation(self.T, self.obs1, times=self.times)
assert_allclose(acorrn, acorr)
"""k=4"""
k = self.k
acorr_amp = np.dot(self.mu * self.obs1, self.R[:, 0:k]) * np.dot(self.L[0:k, :], self.obs1)
acorr = np.dot(self.ev_t[:, 0:k], acorr_amp)
acorrn = correlation(self.T, self.obs1, times=self.times, k=k)
assert_allclose(acorrn, acorr)
"""Cross-correlation"""
"""k=None"""
corr_amp = np.dot(self.mu * self.obs1, self.R) * np.dot(self.L, self.obs2)
corr = np.dot(self.ev_t, corr_amp)
corrn = correlation(self.T, self.obs1, obs2=self.obs2, times=self.times)
assert_allclose(corrn, corr)
"""k=4"""
k = self.k
corr_amp = np.dot(self.mu * self.obs1, self.R[:, 0:k]) * np.dot(self.L[0:k, :], self.obs2)
corr = np.dot(self.ev_t[:, 0:k], corr_amp)
corrn = correlation(self.T, self.obs1, obs2=self.obs2, times=self.times, k=k)
assert_allclose(corrn, corr)
class TestFingerprintSparse(unittest.TestCase):
def setUp(self):
self.k = 4
p = np.zeros(10)
q = np.zeros(10)
p[0:-1] = 0.5
q[1:] = 0.5
p[4] = 0.01
q[6] = 0.1
self.bdc = BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix_sparse()
R, D, L = rdl_decomposition(self.T, k=self.k)
self.L = L
self.R = R
self.ts = timescales(self.T, k=self.k)
self.times = np.array([1, 5, 10, 20])
ev = np.diagonal(D)
self.ev_t = ev[np.newaxis, :]**self.times[:, np.newaxis]
self.tau = 7.5
"""Observables"""
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
obs2 = np.zeros(10)
obs2[8] = 1
obs2[9] = 1
self.obs1 = obs1
self.obs2 = obs2
"""Initial vector for relaxation"""
w0 = np.zeros(10)
w0[0:4] = 0.25
self.p0 = w0
def test_fingerprint_correlation(self):
"""Autocorrelation"""
"""k=4, tau=1"""
k = self.k
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, k=k)
assert_allclose(tsn, self.ts)
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)
assert_allclose(acorr_ampn, acorr_amp)
"""Cross-correlation"""
"""k=4, tau=1"""
k = self.k
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,
k=k)
assert_allclose(tsn, self.ts)
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)
assert_allclose(corr_ampn, corr_amp)
def test_fingerprint_relaxation(self):
one_vec = np.ones(self.T.shape[0])
relax_amp = np.dot(self.p0, self.R) * np.dot(self.L, self.obs1)
tsn, relax_ampn = fingerprint_relaxation(self.T,
self.p0,
self.obs1,
k=self.k)
assert_allclose(tsn, self.ts)
assert_allclose(relax_ampn, relax_amp)
class TestDecomposition(unittest.TestCase):
def setUp(self):
self.dim=100
self.k=10
self.ncv=40
"""Set up meta-stable birth-death chain"""
p=np.zeros(self.dim)
p[0:-1]=0.5
q=np.zeros(self.dim)
q[1:]=0.5
p[self.dim/2-1]=0.001
q[self.dim/2+1]=0.001
self.bdc=BirthDeathChain(q, p)
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)
self.assertTrue(np.allclose(mu, mun))
def test_statdist_iteration(self):
P=self.bdc.transition_matrix_sparse()
mu=self.bdc.stationary_distribution()
mun=stationary_distribution_from_backward_iteration(P)
self.assertTrue(np.allclose(mu, mun))
def test_eigenvalues(self):
P=self.bdc.transition_matrix()
P_dense=self.bdc.transition_matrix()
ev=eigvals(P_dense)
"""Sort with decreasing magnitude"""
ev=ev[np.argsort(np.abs(ev))[::-1]]
"""k=None"""
with self.assertRaises(ValueError):
evn=eigenvalues(P)
"""k is not None"""
evn=eigenvalues(P, k=self.k)
self.assertTrue(np.allclose(ev[0:self.k], evn))
"""k is not None and ncv is not None"""
evn=eigenvalues(P, k=self.k, ncv=self.ncv)
self.assertTrue(np.allclose(ev[0:self.k], evn))
def test_eigenvectors(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)
with self.assertRaises(ValueError):
Ln=eigenvectors(P, right=False)
"""k is not None"""
Rn=eigenvectors(P, k=self.k)
self.assertTrue(np.allclose(vals[np.newaxis,:]*Rn, P.dot(Rn)))
Ln=eigenvectors(P, right=False, k=self.k)
self.assertTrue(np.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)
self.assertTrue(np.allclose(vals[np.newaxis,:]*Rn, P.dot(Rn)))
Ln=eigenvectors(P, right=False, k=self.k, ncv=self.ncv)
self.assertTrue(np.allclose(P.transpose().dot(Ln), vals[np.newaxis,:]*Ln))
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"""
self.assertTrue(np.allclose(P.dot(Rn), np.dot(Rn, Dn)))
"""Left-eigenvectors"""
self.assertTrue(np.allclose(P.transpose().dot(Ln.transpose()).transpose(), np.dot(Dn, Ln)))
"""Orthonormality"""
self.assertTrue(np.allclose(Xn, np.eye(self.k)))
"""Probability vector"""
self.assertTrue(np.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"""
self.assertTrue(np.allclose(P.dot(Rn), np.dot(Rn, Dn)))
"""Left-eigenvectors"""
self.assertTrue(np.allclose(P.transpose().dot(Ln.transpose()).transpose(), np.dot(Dn, Ln)))
"""Orthonormality"""
self.assertTrue(np.allclose(Xn, np.eye(self.k)))
"""Probability vector"""
self.assertTrue(np.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"""
self.assertTrue(np.allclose(P.dot(Rn), np.dot(Rn, Dn)))
"""Left-eigenvectors"""
self.assertTrue(np.allclose(P.transpose().dot(Ln.transpose()).transpose(), np.dot(Dn, Ln)))
"""Orthonormality"""
self.assertTrue(np.allclose(Xn, np.eye(self.k)))
"""Probability vector"""
self.assertTrue(np.allclose(np.sum(Ln[0,:]), 1.0))
"""Reversibility"""
self.assertTrue(np.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"""
self.assertTrue(np.allclose(P.dot(Rn), np.dot(Rn, Dn)))
"""Left-eigenvectors"""
self.assertTrue(np.allclose(P.transpose().dot(Ln.transpose()).transpose(), np.dot(Dn, Ln)))
"""Orthonormality"""
self.assertTrue(np.allclose(Xn, np.eye(self.k)))
"""Probability vector"""
self.assertTrue(np.allclose(np.sum(Ln[0,:]), 1.0))
"""Reversibility"""
self.assertTrue(np.allclose(Ln.transpose(), mu[:,np.newaxis]*Rn))
def test_timescales(self):
P_dense=self.bdc.transition_matrix()
P=self.bdc.transition_matrix_sparse()
ev=eigvals(P_dense)
"""Sort with decreasing magnitude"""
ev=ev[np.argsort(np.abs(ev))[::-1]]
ts=-1.0/np.log(np.abs(ev))
"""k=None"""
with self.assertRaises(ValueError):
tsn=timescales(P)
"""k is not None"""
tsn=timescales(P, k=self.k)
self.assertTrue(np.allclose(ts[1:self.k], tsn[1:]))
"""k is not None, ncv is not None"""
tsn=timescales(P, k=self.k, ncv=self.ncv)
self.assertTrue(np.allclose(ts[1:self.k], tsn[1:]))
"""tau=7"""
"""k is not None"""
tsn=timescales(P, k=self.k, tau=7)
self.assertTrue(np.allclose(7*ts[1:self.k], tsn[1:]))
class TestDecompositionDense(unittest.TestCase):
def setUp(self):
self.dim=100
self.k=10
"""Set up meta-stable birth-death chain"""
p=np.zeros(self.dim)
p[0:-1]=0.5
q=np.zeros(self.dim)
q[1:]=0.5
p[self.dim/2-1]=0.001
q[self.dim/2+1]=0.001
self.bdc=BirthDeathChain(q, p)
def test_statdist(self):
P=self.bdc.transition_matrix()
mu=self.bdc.stationary_distribution()
mun=stationary_distribution(P)
self.assertTrue(np.allclose(mu, mun))
def test_eigenvalues(self):
P=self.bdc.transition_matrix()
ev=eigvals(P)
"""Sort with decreasing magnitude"""
ev=ev[np.argsort(np.abs(ev))[::-1]]
"""k=None"""
evn=eigenvalues(P)
self.assertTrue(np.allclose(ev, evn))
"""k is not None"""
evn=eigenvalues(P, k=self.k)
self.assertTrue(np.allclose(ev[0:self.k], evn))
def test_eigenvectors(self):
P=self.bdc.transition_matrix()
ev, L, R=eig(P, left=True, right=True)
ind=np.argsort(np.abs(ev))[::-1]
R=R[:,ind]
L=L[:,ind]
"""k=None"""
Rn=eigenvectors(P)
self.assertTrue(np.allclose(R, Rn))
Ln=eigenvectors(P, right=False)
self.assertTrue(np.allclose(L, Ln))
"""k is not None"""
Rn=eigenvectors(P, k=self.k)
self.assertTrue(np.allclose(R[:,0:self.k], Rn))
Ln=eigenvectors(P, right=False, k=self.k)
self.assertTrue(np.allclose(L[:,0:self.k], Ln))
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"""
self.assertTrue(np.allclose(np.dot(P, Rn), np.dot(Rn, Dn)))
"""Left-eigenvectors"""
self.assertTrue(np.allclose(np.dot(Ln, P), np.dot(Dn, Ln)))
"""Orthonormality"""
self.assertTrue(np.allclose(Xn, np.eye(self.dim)))
"""Probability vector"""
self.assertTrue(np.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"""
self.assertTrue(np.allclose(np.dot(P, Rn), np.dot(Rn, Dn)))
"""Left-eigenvectors"""
self.assertTrue(np.allclose(np.dot(Ln, P), np.dot(Dn, Ln)))
"""Orthonormality"""
self.assertTrue(np.allclose(Xn, np.eye(self.k)))
"""Probability vector"""
self.assertTrue(np.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"""
self.assertTrue(np.allclose(np.dot(P, Rn), np.dot(Rn, Dn)))
"""Left-eigenvectors"""
self.assertTrue(np.allclose(np.dot(Ln, P), np.dot(Dn, Ln)))
"""Orthonormality"""
self.assertTrue(np.allclose(Xn, np.eye(self.dim)))
"""Probability vector"""
self.assertTrue(np.allclose(np.sum(Ln[0,:]), 1.0))
"""Reversibility"""
self.assertTrue(np.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"""
self.assertTrue(np.allclose(np.dot(P, Rn), np.dot(Rn, Dn)))
"""Left-eigenvectors"""
self.assertTrue(np.allclose(np.dot(Ln, P), np.dot(Dn, Ln)))
"""Orthonormality"""
self.assertTrue(np.allclose(Xn, np.eye(self.k)))
"""Probability vector"""
self.assertTrue(np.allclose(np.sum(Ln[0,:]), 1.0))
"""Reversibility"""
self.assertTrue(np.allclose(Ln.transpose(), mu[:,np.newaxis]*Rn))
def test_timescales(self):
P=self.bdc.transition_matrix()
ev=eigvals(P)
"""Sort with decreasing magnitude"""
ev=ev[np.argsort(np.abs(ev))[::-1]]
ts=-1.0/np.log(np.abs(ev))
"""k=None"""
tsn=timescales(P)
self.assertTrue(np.allclose(ts[1:], tsn[1:]))
"""k is not None"""
tsn=timescales(P, k=self.k)
self.assertTrue(np.allclose(ts[1:self.k], tsn[1:]))
"""tau=7"""
"""k=None"""
tsn=timescales(P, tau=7)
self.assertTrue(np.allclose(7*ts[1:], tsn[1:]))
"""k is not None"""
tsn=timescales(P, k=self.k, tau=7)
self.assertTrue(np.allclose(7*ts[1:self.k], tsn[1:]))
class TestFingerprintSparse(unittest.TestCase):
def setUp(self):
self.k=4
p=np.zeros(10)
q=np.zeros(10)
p[0:-1]=0.5
q[1:]=0.5
p[4]=0.01
q[6]=0.1
self.bdc=BirthDeathChain(q, p)
self.mu = self.bdc.stationary_distribution()
self.T = self.bdc.transition_matrix_sparse()
R, D, L=rdl_decomposition(self.T, k=self.k)
self.L=L
self.R=R
self.ts=timescales(self.T, k=self.k)
self.times=np.array([1, 5, 10, 20])
ev=np.diagonal(D)
self.ev_t=ev[np.newaxis,:]**self.times[:,np.newaxis]
self.tau=7.5
"""Observables"""
obs1 = np.zeros(10)
obs1[0] = 1
obs1[1] = 1
obs2 = np.zeros(10)
obs2[8] = 1
obs2[9] = 1
self.obs1=obs1
self.obs2=obs2
"""Initial vector for relaxation"""
w0=np.zeros(10)
w0[0:4]=0.25
self.p0=w0
def test_fingerprint_correlation(self):
"""Autocorrelation"""
"""k=4, tau=1"""
k=self.k
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, k=k)
self.assertTrue(np.allclose(tsn, self.ts))
self.assertTrue(np.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)
self.assertTrue(np.allclose(tsn, tau*self.ts))
self.assertTrue(np.allclose(acorr_ampn, acorr_amp))
"""Cross-correlation"""
"""k=4, tau=1"""
k=self.k
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, k=k)
self.assertTrue(np.allclose(tsn, self.ts))
self.assertTrue(np.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)
self.assertTrue(np.allclose(tsn, tau*self.ts))
self.assertTrue(np.allclose(corr_ampn, corr_amp))
def test_fingerprint_relaxation(self):
one_vec=np.ones(self.T.shape[0])
relax_amp=np.dot(self.p0, self.R)*np.dot(self.L, self.obs1)
tsn, relax_ampn=fingerprint_relaxation(self.T, self.p0, self.obs1, k=self.k)
self.assertTrue(np.allclose(tsn, self.ts))
self.assertTrue(np.allclose(relax_ampn, relax_amp))
def setUp(self):
"""Store state of the rng"""
self.state = np.random.mtrand.get_state()
"""Reseed the rng to enforce 'deterministic' behavior"""
np.random.mtrand.seed(42)
"""Meta-stable birth-death chain"""
b = 2
q = np.zeros(7)
p = np.zeros(7)
q[1:] = 0.5
p[0:-1] = 0.5
q[2] = 1.0 - 10**(-b)
q[4] = 10**(-b)
p[2] = 10**(-b)
p[4] = 1.0 - 10**(-b)
bdc = BirthDeathChain(q, p)
P = bdc.transition_matrix()
dtraj = generate_traj(P, 10000, start=0)
tau = 1
"""Estimate MSM"""
C_MSM = cmatrix(dtraj, tau)
lcc_MSM = largest_connected_set(C_MSM)
Ccc_MSM = connected_cmatrix(C_MSM, lcc=lcc_MSM)
P_MSM = tmatrix(Ccc_MSM)
mu_MSM = statdist(P_MSM)
"""Meta-stable sets"""
A = [0, 1, 2]
B = [4, 5, 6]
w_MSM = np.zeros((2, mu_MSM.shape[0]))
w_MSM[0, A] = mu_MSM[A] / mu_MSM[A].sum()
w_MSM[1, B] = mu_MSM[B] / mu_MSM[B].sum()
K = 10
P_MSM_dense = P_MSM.toarray()
p_MSM = np.zeros((K, 2))
w_MSM_k = 1.0 * w_MSM
for k in range(1, K):
w_MSM_k = np.dot(w_MSM_k, P_MSM_dense)
p_MSM[k, 0] = w_MSM_k[0, A].sum()
p_MSM[k, 1] = w_MSM_k[1, B].sum()
"""Assume that sets are equal, A(\tau)=A(k \tau) for all k"""
w_MD = 1.0 * w_MSM
p_MD = np.zeros((K, 2))
eps_MD = np.zeros((K, 2))
p_MSM[0, :] = 1.0
p_MD[0, :] = 1.0
eps_MD[0, :] = 0.0
for k in range(1, K):
"""Build MSM at lagtime k*tau"""
C_MD = cmatrix(dtraj, k * tau, sliding=True) / (k * tau)
lcc_MD = largest_connected_set(C_MD)
Ccc_MD = connected_cmatrix(C_MD, lcc=lcc_MD)
c_MD = Ccc_MD.sum(axis=1)
P_MD = tmatrix(Ccc_MD).toarray()
w_MD_k = np.dot(w_MD, P_MD)
"""Set A"""
prob_MD = w_MD_k[0, A].sum()
c = c_MD[A].sum()
p_MD[k, 0] = prob_MD
eps_MD[k, 0] = np.sqrt(k * (prob_MD - prob_MD**2) / c)
"""Set B"""
prob_MD = w_MD_k[1, B].sum()
c = c_MD[B].sum()
p_MD[k, 1] = prob_MD
eps_MD[k, 1] = np.sqrt(k * (prob_MD - prob_MD**2) / c)
"""Input"""
self.P_MSM = P_MSM
self.lcc_MSM = lcc_MSM
self.dtraj = dtraj
self.tau = tau
self.K = K
self.A = A
self.B = B
"""Expected results"""
self.p_MSM = p_MSM
self.p_MD = p_MD
self.eps_MD = eps_MD
class TestDecompositionDense(unittest.TestCase):
def setUp(self):
self.dim = 100
self.k = 10
"""Set up meta-stable birth-death chain"""
p = np.zeros(self.dim)
p[0:-1] = 0.5
q = np.zeros(self.dim)
q[1:] = 0.5
p[self.dim / 2 - 1] = 0.001
q[self.dim / 2 + 1] = 0.001
self.bdc = BirthDeathChain(q, p)
def test_statdist(self):
P = self.bdc.transition_matrix()
mu = self.bdc.stationary_distribution()
mun = stationary_distribution(P)
assert_allclose(mu, mun)
def test_eigenvalues(self):
P = self.bdc.transition_matrix()
ev = eigvals(P)
"""Sort with decreasing magnitude"""
ev = ev[np.argsort(np.abs(ev))[::-1]]
"""k=None"""
evn = eigenvalues(P)
assert_allclose(ev, evn)
"""k is not None"""
evn = eigenvalues(P, k=self.k)
assert_allclose(ev[0:self.k], evn)
def test_eigenvectors(self):
P = self.bdc.transition_matrix()
ev, L, R = eig(P, left=True, right=True)
ind = np.argsort(np.abs(ev))[::-1]
R = R[:, ind]
L = L[:, ind]
"""k=None"""
Rn = eigenvectors(P)
assert_allclose(R, Rn)
Ln = eigenvectors(P, right=False)
assert_allclose(L, Ln)
"""k is not None"""
Rn = eigenvectors(P, k=self.k)
assert_allclose(R[:, 0:self.k], Rn)
Ln = eigenvectors(P, right=False, k=self.k)
assert_allclose(L[:, 0:self.k], Ln)
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_timescales(self):
P = self.bdc.transition_matrix()
ev = eigvals(P)
"""Sort with decreasing magnitude"""
ev = ev[np.argsort(np.abs(ev))[::-1]]
ts = -1.0 / np.log(np.abs(ev))
"""k=None"""
tsn = timescales(P)
assert_allclose(ts[1:], tsn[1:])
"""k is not None"""
tsn = timescales(P, k=self.k)
assert_allclose(ts[1:self.k], tsn[1:])
"""tau=7"""
"""k=None"""
tsn = timescales(P, tau=7)
assert_allclose(7 * ts[1:], tsn[1:])
"""k is not None"""
tsn = timescales(P, k=self.k, tau=7)
assert_allclose(7 * ts[1:self.k], tsn[1:])
