def get_response_content(fs):
# define the amount of time we will search
nseconds = 5
# set up print options
np.set_printoptions(
linewidth=1000000,
threshold=1000000,
)
out = StringIO()
# set up some process parameters
blink_birth = fs.blink_birth
blink_death = fs.blink_death
rate_01 = fs.rate_01
rate_12 = fs.rate_12
rate_20 = fs.rate_20
# define the original rate matrix
pre_Q = np.array([
[0, rate_01, 0],
[0, 0, rate_12],
[rate_20, 0, 0],
], dtype=float)
# construct the derived rate matrix
pre_blink = binarytolerance.blinkize(pre_Q, blink_birth, blink_death)
# check stationary distributions
Q = binarytolerance.pre_Q_to_Q(pre_Q)
W, V = scipy.linalg.eig(Q.T)
v = V[:, np.argmin(np.abs(W))]
v /= np.sum(v)
#print >> out, Q
#print >> out, W
print >> out, 'original process stationary distribution:'
print >> out, v
print >> out
Q_blink = binarytolerance.pre_Q_to_Q(pre_blink)
W, V = scipy.linalg.eig(Q_blink.T)
v = V[:, np.argmin(np.abs(W))]
v /= np.sum(v)
#print >> out, Q_blink
#print >> out, W
#print >> out, v
#print >> out
n = pre_Q.shape[0]
expo = binarytolerance.get_expanded_states(n)
x = np.zeros(n)
for i, (perm, mask) in enumerate(expo):
x[perm[0]] += v[i]
print >> out, 'blink-ized stationary distribution:'
print >> out, x
print >> out
# show the result
return out.getvalue()
def get_response_content(fs):
# define the amount of time we will search
nseconds = 5
# set up print options
np.set_printoptions(
linewidth=1000000,
threshold=1000000,
)
out = StringIO()
# set up some process parameters
blink_birth = fs.blink_birth
blink_death = fs.blink_death
rate_01 = fs.rate_01
rate_12 = fs.rate_12
rate_20 = fs.rate_20
# define the original rate matrix
pre_Q = np.array([
[0, rate_01, 0],
[0, 0, rate_12],
[rate_20, 0, 0],
],
dtype=float)
# construct the derived rate matrix
pre_blink = binarytolerance.blinkize(pre_Q, blink_birth, blink_death)
# check stationary distributions
Q = binarytolerance.pre_Q_to_Q(pre_Q)
W, V = scipy.linalg.eig(Q.T)
v = V[:, np.argmin(np.abs(W))]
v /= np.sum(v)
#print >> out, Q
#print >> out, W
print >> out, 'original process stationary distribution:'
print >> out, v
print >> out
Q_blink = binarytolerance.pre_Q_to_Q(pre_blink)
W, V = scipy.linalg.eig(Q_blink.T)
v = V[:, np.argmin(np.abs(W))]
v /= np.sum(v)
#print >> out, Q_blink
#print >> out, W
#print >> out, v
#print >> out
n = pre_Q.shape[0]
expo = binarytolerance.get_expanded_states(n)
x = np.zeros(n)
for i, (perm, mask) in enumerate(expo):
x[perm[0]] += v[i]
print >> out, 'blink-ized stationary distribution:'
print >> out, x
print >> out
# show the result
return out.getvalue()
def get_response_content(fs):
# define the amount of time we will search
nseconds = 5
# set up print options
np.set_printoptions(linewidth=1000000, threshold=1000000)
out = StringIO()
# set up some process parameters
blink_birth = fs.blink_birth
blink_death = fs.blink_death
if blink_birth < 0:
raise Exception
if blink_death < 0:
raise Exception
# define the original rate matrix
# pre_Q = np.exp(np.random.randn(3, 3))
pre_Q = binarytolerance.sample_reversible_pre_Q(4)
"""
pre_Q = np.array([
[0.0, 0.5],
[0.1, 0.0],
], dtype=float)
pre_Q = np.array([
[0.0, 0.3, 0.1],
[0.1, 0.0, 0.3],
[0.1, 0.1, 0.0],
], dtype=float)
pre_Q = np.array([
[0.0, 3.0, 0.1],
[0.1, 0.0, 3.0],
[0.1, 0.1, 0.0],
], dtype=float)
pre_Q = np.array([
[0.00, 6.00, 0.00],
[0.00, 0.00, 6.00],
[0.01, 0.00, 0.00],
], dtype=float)
"""
# construct the derived rate matrix
pre_blink = binarytolerance.blinkize(pre_Q, blink_birth, blink_death)
# check stationary distributions
Q = binarytolerance.pre_Q_to_Q(pre_Q)
W, V = scipy.linalg.eig(Q.T)
v = V[:, np.argmin(np.abs(W))]
v /= np.sum(v)
v_mutational = v
print >> out, Q
print >> out, W
print >> out, "mutational process amino acid stationary distribution:"
print >> out, v
print >> out, np.sum(v)
print >> out
Q_blink = binarytolerance.pre_Q_to_Q(pre_blink)
W, V = scipy.linalg.eig(Q_blink.T)
v = V[:, np.argmin(np.abs(W))]
v /= np.sum(v)
print >> out, Q_blink
print >> out, W
print >> out, "full stationary distribution:"
print >> out, v
print >> out, np.sum(v)
print >> out
n = pre_Q.shape[0]
expo = binarytolerance.get_expanded_states(n)
x = np.zeros(n)
for i, (perm, mask) in enumerate(expo):
x[perm[0]] += v[i]
print >> out, "marginal amino acid stationary distribution:"
print >> out, x
print >> out, np.sum(x)
print >> out
# Attempt to construct the full stationary distribution as the product
# of the mutational process amino acid stationary probability
# and a binomial stationary probability of the blinking process.
n = pre_Q.shape[0]
p_on = blink_birth / (blink_birth + blink_death)
p_off = blink_death / (blink_birth + blink_death)
blink_factorial = math.factorial(n - 1)
expo = binarytolerance.get_expanded_states(n)
x = np.ones(len(expo), dtype=float)
for i, (perm, mask) in enumerate(expo):
# Account for the amino acid residue mutational probability.
x[i] *= v_mutational[perm[0]]
# Account for the blinking permutations.
x[i] /= blink_factorial
# Account for the binomial probability of blinks.
n_on = sum(mask[1:])
n_off = (n - 1) - n_on
# x[i] *= scipy.special.binom(n_on, p_on)
# x[i] *= scipy.stats.binom.pmf(n_on, n-1, p_on)
x[i] *= p_on ** n_on
x[i] *= p_off ** n_off
print >> out, "attempt to construct the full stationary distribution:"
print >> out, x
print >> out, np.sum(x)
print >> out
# show the result
return out.getvalue()
def get_response_content(fs):
# define the amount of time we will search
nseconds = 5
# set up print options
np.set_printoptions(
linewidth=1000000,
threshold=1000000,
)
out = StringIO()
# set up some process parameters
blink_birth = fs.blink_birth
blink_death = fs.blink_death
if blink_birth < 0:
raise Exception
if blink_death < 0:
raise Exception
# define the original rate matrix
#pre_Q = np.exp(np.random.randn(3, 3))
pre_Q = binarytolerance.sample_reversible_pre_Q(4)
"""
pre_Q = np.array([
[0.0, 0.5],
[0.1, 0.0],
], dtype=float)
pre_Q = np.array([
[0.0, 0.3, 0.1],
[0.1, 0.0, 0.3],
[0.1, 0.1, 0.0],
], dtype=float)
pre_Q = np.array([
[0.0, 3.0, 0.1],
[0.1, 0.0, 3.0],
[0.1, 0.1, 0.0],
], dtype=float)
pre_Q = np.array([
[0.00, 6.00, 0.00],
[0.00, 0.00, 6.00],
[0.01, 0.00, 0.00],
], dtype=float)
"""
# construct the derived rate matrix
pre_blink = binarytolerance.blinkize(pre_Q, blink_birth, blink_death)
# check stationary distributions
Q = binarytolerance.pre_Q_to_Q(pre_Q)
W, V = scipy.linalg.eig(Q.T)
v = V[:, np.argmin(np.abs(W))]
v /= np.sum(v)
v_mutational = v
print >> out, Q
print >> out, W
print >> out, 'mutational process amino acid stationary distribution:'
print >> out, v
print >> out, np.sum(v)
print >> out
Q_blink = binarytolerance.pre_Q_to_Q(pre_blink)
W, V = scipy.linalg.eig(Q_blink.T)
v = V[:, np.argmin(np.abs(W))]
v /= np.sum(v)
print >> out, Q_blink
print >> out, W
print >> out, 'full stationary distribution:'
print >> out, v
print >> out, np.sum(v)
print >> out
n = pre_Q.shape[0]
expo = binarytolerance.get_expanded_states(n)
x = np.zeros(n)
for i, (perm, mask) in enumerate(expo):
x[perm[0]] += v[i]
print >> out, 'marginal amino acid stationary distribution:'
print >> out, x
print >> out, np.sum(x)
print >> out
# Attempt to construct the full stationary distribution as the product
# of the mutational process amino acid stationary probability
# and a binomial stationary probability of the blinking process.
n = pre_Q.shape[0]
p_on = blink_birth / (blink_birth + blink_death)
p_off = blink_death / (blink_birth + blink_death)
blink_factorial = math.factorial(n - 1)
expo = binarytolerance.get_expanded_states(n)
x = np.ones(len(expo), dtype=float)
for i, (perm, mask) in enumerate(expo):
# Account for the amino acid residue mutational probability.
x[i] *= v_mutational[perm[0]]
# Account for the blinking permutations.
x[i] /= blink_factorial
# Account for the binomial probability of blinks.
n_on = sum(mask[1:])
n_off = (n - 1) - n_on
#x[i] *= scipy.special.binom(n_on, p_on)
#x[i] *= scipy.stats.binom.pmf(n_on, n-1, p_on)
x[i] *= p_on**n_on
x[i] *= p_off**n_off
print >> out, 'attempt to construct the full stationary distribution:'
print >> out, x
print >> out, np.sum(x)
print >> out
# show the result
return out.getvalue()