def prob_1(): #problem 1 #part 1 A = np.array([[.75, .5], [.25, .5]]) print A.dot(A)[0,0] #part 2 print la.matrix_power(A, 20)[0,0]
def make_propagators(pb=0.0, kex=0.0, dw=0.0, r_hxy=5.0, dr_hxy=0.0,
r_cz=1.5, r_2hzcz=0.0, etaxy=0.0, etaz=0.0,
j_hc=0.0, cs_offset=0.0):
w1 = 2.0 * pi / (4.0 * pw)
l_free, l_w1x, l_w1y = compute_liouvillians(
pb=pb,
kex=kex,
dw=dw,
r_hxy=r_hxy,
dr_hxy=dr_hxy,
r_cz=r_cz,
r_2hzcz=r_2hzcz,
etaxy=etaxy,
etaz=etaz,
j_hc=j_hc,
cs_offset=cs_offset,
w1=w1
)
p_neg = expm(l_free * -2.0 * pw / pi)
p_90px = expm((l_free + l_w1x) * pw)
p_90py = expm((l_free + l_w1y) * pw)
p_90mx = expm((l_free - l_w1x) * pw)
p_180py = matrix_power(p_90py, 2)
p_180pmx = 0.5 * (matrix_power(p_90px, 2) +
matrix_power(p_90mx, 2))
ps = p_neg, p_90px, p_90py, p_90mx, p_180py, p_180pmx
return l_free, ps
def jointpmf2(pe, pb, n):
# pWL(w, l) = Pr{W = w, L = l}
# = Pr{W = w | L = l} * Pr{L = l}
# = pW(w - 2; l - 2) * pL(l; n)
T = mmbittm(pe, pb)
Pss = mmss(T)
pW = errpmf(pe, pb, n)
pWL = np.zeros((n + 1, n + 1))
pWL[0, 0] = pW[0]
pWL[1, 1] = pW[1]
for l in range(2, n + 1):
Tw = mmstep(T, l - 2)
#print('Tw =\n', Tw)
for x in range(n - l + 1):
y = n - l - x
#print('0' * x + '1' + 'x' * (l - 2) + '1' + '0' * y)
Tx = LA.matrix_power(T[0], x)
Ty = LA.matrix_power(T[0], y)
#Twl = Tx.dot(T[1]).dot(Tw).dot(T[1]).dot(Ty)
#print('Tx =\n', Tx)
#print('Ty =\n', Ty)
#print('Twl =\n', Twl)
#Pwl = Pss.dot(Twl).sum(axis=1)
for w in range(2, l + 1):
Twl = Tx.dot(T[1]).dot(Tw[w - 2]).dot(T[1]).dot(Ty)
Pwl = Pss.dot(Twl).sum()
#print('Twl =\n', Twl)
#print('Pwl =\n', Pwl)
pWL[w, l] += Pwl
return pWL
def make_propagators(pb=0.0, pc=0.0, kex_ab=0.0, kex_bc=0.0, kex_ac=0.0,
dw_ab=0.0, dw_ac=0.0, r_nxy=5.0, dr_nxy_ab=0.0,
dr_nxy_ac=0.0, r_nz=1.5, r_2hznz=5.0, etaxy=0.0,
etaz=0.0, j_hn=-93.0, dj_hn_ab=0.0, dj_hn_ac=0.0,
cs_offset=0.0):
w1 = 2.0 * pi / (4.0 * pw)
l_free, l_w1x, l_w1y = compute_liouvillians(
pb=pb, pc=pc, kex_ab=kex_ab, kex_bc=kex_bc, kex_ac=kex_ac,
dw_ab=dw_ab, dw_ac=dw_ac, r_nxy=r_nxy, dr_nxy_ab=dr_nxy_ab,
dr_nxy_ac=dr_nxy_ac, r_nz=r_nz, r_2hznz=r_2hznz, etaxy=etaxy,
etaz=etaz, j_hn=j_hn, dj_hn_ab=dj_hn_ab, dj_hn_ac=dj_hn_ac,
cs_offset=cs_offset, w1=w1,
)
p_equil = expm(l_free * time_equil)
p_neg = expm(l_free * -2.0 * pw / pi)
p_taub = expm(l_free * (taub - 2.0 * pw - 2.0 * pw / pi))
p_90px = expm((l_free + l_w1x) * pw)
p_90py = expm((l_free + l_w1y) * pw)
p_90mx = expm((l_free - l_w1x) * pw)
p_90my = expm((l_free - l_w1y) * pw)
p_180px = matrix_power(p_90px, 2)
p_180py = matrix_power(p_90py, 2)
p_element = reduce(dot, [P180_S, p_taub, p_90py, p_90px, P180_S, p_90px,
p_90py, p_taub])
ps = (p_equil, p_neg, p_90px, p_90py, p_90mx, p_90my, p_180px, p_180py,
p_element)
return l_free, ps
def make_propagators(pb=0.0, kex=0.0, dw=0.0, r_coxy=5.0, dr_coxy=0.0,
r_nz=1.5, r_2coznz=0.0, etaxy=0.0, etaz=0.0,
j_nco=0.0, dj_nco=0.0, cs_offset=0.0):
w1 = 2.0 * pi / (4.0 * pwco90)
l_free, l_w1x, l_w1y = compute_liouvillians(pb=pb, kex=kex, dw=dw,
r_coxy=r_coxy, dr_coxy=dr_coxy,
r_nz=r_nz, r_2coznz=r_2coznz,
etaxy=etaxy, etaz=etaz,
j_nco=j_nco, dj_nco=dj_nco,
cs_offset=cs_offset, w1=w1)
p_equil = expm(l_free * time_equil)
p_taucc = expm(l_free * taucc)
p_neg = expm(l_free * -2.0 * pwco90 / pi)
p_90py = expm((l_free + l_w1y) * pwco90)
p_90my = expm((l_free - l_w1y) * pwco90)
p_180px = P180X # Perfect 180 for CPMG blocks
p_180py = matrix_power(p_90py, 2)
p_180my = matrix_power(p_90py, 2)
ps = (p_equil, p_taucc, p_neg, p_90py, p_90my,
p_180px, p_180py, p_180my)
return l_free, ps
def test_regress_mutation_probability_endpoint_conditioning(self):
ngenerations = 10
selection = 2.0
mutation = 0.0001
recombination = 0.001
nchromosomes = 2
npositions = 4
K_initial = np.array([
[1,1,1,1],
[0,0,0,0]], dtype=np.int8)
K_final = np.array([
[1,1,0,0],
[0,0,1,1]], dtype=np.int8)
#
ngenboundaries = ngenerations - 1
no_mutation_prior = (1 - mutation)**(
npositions*ngenboundaries*nchromosomes)
#
initial_long = popgenmarkov.bin2d_to_int(K_initial)
final_long = popgenmarkov.bin2d_to_int(K_final)
ci_to_short, short_to_count, sorted_chrom_lists = get_state_space_info(
nchromosomes, npositions)
initial_ci = chroms_to_index(
sorted(popgenmarkov.bin_to_int(row) for row in K_initial),
npositions)
initial_short = ci_to_short[initial_ci]
final_ci = chroms_to_index(
sorted(popgenmarkov.bin_to_int(row) for row in K_final),
npositions)
final_short = ci_to_short[final_ci]
# get an answer using the less efficient methods
P_sr = popgenmarkov.get_selection_recombination_transition_matrix(
selection, recombination, nchromosomes, npositions)
P_m = popgenmarkov.get_mutation_transition_matrix(
mutation, nchromosomes, npositions)
p_b_given_a = linalg.matrix_power(np.dot(P_sr, P_m), ngenerations-1)[
initial_long, final_long]
p_b_given_a_no_mutation = linalg.matrix_power(P_sr, ngenerations-1)[
initial_long, final_long]
no_mutation_posterior = (
no_mutation_prior * p_b_given_a_no_mutation) / p_b_given_a
# get an answer using the more efficient methods
P_sr_s = get_selection_recombination_transition_matrix_s(
ci_to_short, short_to_count, sorted_chrom_lists,
selection, recombination, nchromosomes, npositions)
P_m_s = get_mutation_transition_matrix_s(
ci_to_short, short_to_count, sorted_chrom_lists,
mutation, nchromosomes, npositions)
p_b_given_a_s = linalg.matrix_power(
np.dot(P_sr_s, P_m_s), ngenerations-1)[
initial_short, final_short]
p_b_given_a_no_mutation_s = linalg.matrix_power(
P_sr_s, ngenerations-1)[
initial_short, final_short]
no_mutation_posterior_s = (
no_mutation_prior * p_b_given_a_no_mutation_s) / p_b_given_a_s
#
self.assertTrue(
np.allclose(no_mutation_posterior, no_mutation_posterior_s))
def test_matrix_power_operator(self):
random.seed(1234)
n = 5
k = 2
p = 3
nsamples = 10
for i in range(nsamples):
A = np.random.randn(n, n)
B = np.random.randn(n, k)
op = MatrixPowerOperator(A, p)
assert_allclose(op.matmat(B), matrix_power(A, p).dot(B))
assert_allclose(op.T.matmat(B), matrix_power(A, p).T.dot(B))
def __call__(self, options, pars):
"""Evaluate the model for a given set of parameters."""
self.max_T = int(pars.get('max_T', 100)) # range of sample sizes
T = np.arange(1., self.max_T + 1)
N = map(int, np.floor(T))
self.set_statespace(pars) # threshold and state space
# which option is sampled first? [0, 1, None]
firstoption = pars.get('firstoption', None)
# evaluate the starting distribution
Z = self.Z(self.m, {'theta': self.theta + 1, 'tau': pars.get('tau', .5)})
# repeat Z for both options, and re-normalize
if firstoption is None:
Z = np.concatenate((Z, Z), axis=1)
elif firstoption is 0:
Z = np.concatenate((Z, np.matrix(np.zeros(self.m - 2))), axis=1)
elif firstoption is 1:
Z = np.concatenate((np.matrix(np.zeros(self.m - 2)), Z), axis=1)
Z = Z / float(np.sum(Z))
# transition matrix
tm = self.transition_matrix_reflecting(options, pars)
# min-steps
if 'minsamplesize' in pars:
min_ss = pars.get('minsamplesize')
if min_ss == 2:
Z = Z * tm
else:
Z = Z * matrix_power(tm, min_ss - 1)
assert np.isclose(Z.sum(), 1.)
# evaluate evolution in states
M = [Z * matrix_power(tm, 0)]
for n in N[1:]:
M.append( np.dot(M[-1], tm) )
p_state_t = np.array(M).reshape((len(N), self.m * 2))
p_0 = p_state_t[:,self.theta] + p_state_t[:,self.m + self.theta]
p_L = p_state_t[:,:self.theta].sum(axis=1) + p_state_t[:,self.m:(self.m+self.theta)].sum(axis=1) + p_0 * 0.5
p_H = p_state_t[:,(1+self.theta):self.m].sum(axis=1) + p_state_t[:,(self.m+self.theta+1):].sum(axis=1) + p_0 * 0.5
p_LH = np.transpose((p_L, p_H))
assert np.isclose(p_LH.sum(), p_LH.shape[0])
return {'T': T,
'states_t': p_state_t,
'p_resp_t': p_LH}
def DiagonalNewton(d0,d1,Q,tolerance):
if tolerance <= 0:
print "tolerance <= 0, algorithm won't terminate"
return None
#verify if Q is positive semidefinite, correct dimensions
try:
y = linalg.cholesky(Q)
except linalg.LinAlgError:
print "Matrix is either not positive semidefinite, or nonsquare"
return None
e = np.ones(d1.size)
w = linalg.norm(d1 -d0)
D = np.diag(d1)
w = linalg.norm(np.dot(np.dot(np.dot(D,Q),D),e)-e)
iterationcounter = 0
while(w > tolerance):
d0 = d1
D = np.diag(d1)
try:
y = np.dot(linalg.matrix_power((linalg.matrix_power(D,-2)+Q),-1), np.diag( linalg.matrix_power(D,-1 ))-np.dot(Q,d1))
except:
return None
# print np.dot(np.dot(np.transpose(y) ,linalg.matrix_power(D,-2)),y)
lamb = np.dot(
np.dot(np.transpose(y) ,linalg.matrix_power(D,-2)),
y) + np.dot(np.dot(np.transpose(y),Q),y) #computing lambda
#lamb < 1, a = 1 lamb >=1 1, a = 1/2
#print lamb
if lamb > 1:
d1 = d0 + float(1)/(1 + lamb**(0.5))*y
else:
d1 = d0 + y
w = linalg.norm(np.dot(np.dot(np.dot(D,Q),D),e)-e)
iterationcounter += 1
return (w, d1,iterationcounter)
def randmatstat(t):
n = 5
v = zeros(t)
w = zeros(t)
for i in range(t):
a = randn(n, n)
b = randn(n, n)
c = randn(n, n)
d = randn(n, n)
P = concatenate((a, b, c, d), axis=1)
Q = concatenate((concatenate((a, b), axis=1), concatenate((c, d), axis=1)), axis=0)
v[i] = trace(matrix_power(dot(P.T,P), 4))
w[i] = trace(matrix_power(dot(Q.T,Q), 4))
return (std(v)/mean(v), std(w)/mean(w))
def directed_weighted_clustering(g,weightString):
n = g.number_of_nodes()
from numpy import linalg as LA
#adjacency matrix
A = nx.to_numpy_matrix(g,nodelist=g.nodes(),weight=None)
A2 = LA.matrix_power(A,2)
AT = A.T
Asum = AT + A
cVector = [i for i in range(n)]
cVector = np.asmatrix(cVector)
kin = {i:np.dot(AT[i],cVector.T) for i in range(n)}
kout = {i:np.dot(A[i],cVector.T)for i in range(n)}
kparallel = {i:np.dot(Asum[i],cVector.T)for i in range(n)}
#print "kin"
#print kin
#weight matrix
W = nx.to_numpy_matrix(g,nodelist=g.nodes(),weight=weightString)
WT = W.T
W2 = LA.matrix_power(W,2)
W3 = LA.matrix_power(W,3)
WWTW = W*WT*W
WTW2 = WT*W2
W2WT = W2*WT
ccycle = {i:0 for i in range(n)}
cmiddle = {i:0 for i in range(n)}
cin = {i:0 for i in range(n)}
cout = {i:0 for i in range(n)}
for i in range(n):
if kin[i]*kout[i] - kparallel[i] > 0:
ccycle[i] = W3[i,i] / float((kin[i]*kout[i] - kparallel[i]))
cmiddle[i] = WWTW[i,i] / float((kin[i]*kout[i] - kparallel[i]))
if kin[i] > 1:
cin[i] = WTW2[i,i] / float((kin[i]*(kin[i]-1)))
if kout[i] > 1:
cout[i] = W2WT[i,i] / float((kout[i]*(kout[i]-1)))
#print type((np.mean(ccycle.values()),np.mean(cmiddle.values()),np.mean(cin.values()),np.mean(cout.values())))
#print "here"
#input()
#return (np.mean(ccycle.values()),np.mean(cmiddle.values()),np.mean(cin.values()),np.mean(cout.values()))
return (ccycle,cmiddle,cin,cout)
def _calc_observable(pb=0.0, kex=0.0, dwh=0.0, dwc=0.0, r_2hxycxy=5.0, dr_2hxycxy=0.0, ncyc=0):
"""
Calculate the intensity in presence of exchange during a cpmg-type pulse
train. Based on the sequence "hmqc_CH3_exchange_bigprotein_600_lek_v2.c".
Parameter names from the sequence are:
chemex procpar
------ -------
time_T2 time_T2
ncyc ncyc_cp
Parameters
----------
i0 : float
Initial intensity
pb : float
Fractional population of state b
kex : float
Exchange rate between state a and b in /s
dwh : float
Proton chemical shift difference between states A and B in ppm
dwc : float
Carbon chemical shift difference between states A and B in ppm
r_2hxycxy : float
Multiple quantum relaxation rate in /s
dr_2hxycxy : float
Multiple quantum relaxation rate difference between a and b in /s
smallflg: string ['y', 'n']
Flag to include small_protein_flg block in fitting
Returns
-------
out : float
Intensity after the CPMG block
"""
dwh *= ppm_to_rads_h
dwc *= ppm_to_rads_c
l_free = make_propagators(
pb=pb, kex=kex, dwh=dwh, dwc=dwc, r_2hxycxy=r_2hxycxy, dr_2hxycxy=dr_2hxycxy,
)
mag_eq = compute_2hxcy_eq(pb)
if ncyc == 0:
mag = mag_eq
else:
t_cp = time_t2 / (4.0 * ncyc)
p_free = expm(l_free * t_cp)
p_cpy = matrix_power(p_free.dot(P180_CY).dot(p_free), ncyc)
mag = reduce(dot, [p_cpy, P180_HX, p_cpy, mag_eq])
magz_a, _ = get_2hxcy(mag)
return magz_a
def build_rand_sparse_diag_mat_and_multiply():
array = diags(random.random_sample(25).tolist(), 0).toarray()
#print array
heat_map_data1 = [go.Heatmap(z=np.flipud(array).tolist())]
heat_map_data2 = [go.Heatmap(z=np.flipud((LA.matrix_power(array, 2))).tolist())] #multiply with itself.
plot_url = plotly.offline.plot(heat_map_data1, filename='basic-heatmap1.html')
plot_url = plotly.offline.plot(heat_map_data2, filename='basic-heatmap2.html')
def simulate_evolution(dna_sequence, alpha, time, dt, threads=1):
tree = Tree([PhylogeneticNode(dna_sequence)], [])
transition_matrix = build_transition_matrix(alpha)
power_matrix = LA.matrix_power(transition_matrix, dt)
while time > 0:
i = 0
fixed_length = len(tree.get_nodes())
node_list = tree.get_nodes()
if fixed_length > 10:
return tree
while i < fixed_length:
node = node_list[i]
origin_sequence = node.get_sequence()
wrapper = list(origin_sequence)
next_node = mutate_module(power_matrix, wrapper, threads=threads)
if next_node != -1:
tree.add_node(next_node)
tree.add_edge(node, next_node)
gc.collect()
i += 1
time -= dt
print time
return tree
def calc_normal(self, data, power):
""" The normal way to do the calculation """
# Extract shapes from data.
NE, NS, NM, NO, ND, Row, Col = data.shape
# Make array to store results
calc = zeros([NE, NS, NM, NO, ND, Row, Col])
# Normal way, by loop of loops.
for ei in range(NE):
for si in range(NS):
for mi in range(NM):
for oi in range(NO):
for di in range(ND):
# Get the outer square data matrix,
data_i = data[ei, si, mi, oi, di]
# Get the power.
power_i = power[ei, si, mi, oi, di]
# Do power calculation with numpy method.
data_power_i = matrix_power(data_i, power_i)
# Store result.
calc[ei, si, mi, oi, di] = data_power_i
return calc
def calc_strided(self, data, power):
""" The strided way to do the calculation """
# Extract shapes from data.
NE, NS, NM, NO, ND, Row, Col = data.shape
# Make array to store results
calc = zeros([NE, NS, NM, NO, ND, Row, Col])
# Get the data view, from the helper function.
data_view = self.stride_help_square_matrix(data)
# Get the power view, from the helpwer function.
power_view = self.stride_help_element(power)
# The index view could be pre formed in init.
index = self.index
index_view = self.stride_help_array(index)
# Zip them together and iterate over them.
for data_i, power_i, index_i in zip(data_view, power_view, index_view):
# Do power calculation with numpy method.
data_power_i = matrix_power(data_i, int(power_i))
# Extract index from index_view.
ei, si, mi, oi, di = index_i
# Store the result.
calc[ei, si, mi, oi, di] = data_power_i
return calc
def basis(H, v): basisset=[] for l in range(M): basisset.extend(np.dot(LA.matrix_power(H,l),v)) basisset=np.reshape(basisset,(M,2*N)) return (basisset)
def power_method(file_name, error_tol, u0):
# Creates a matrix from the .dat file
A = np.genfromtxt(file_name, delimiter=" ")
m = int(A.shape[0]) #rows of A
u = np.asarray(np.asmatrix(u0))
uRows = int(u.shape[0]) #rows of u
uCols = int(u.shape[1]) #columns of u
# Sets the tolerance
tol = error_tol
# Sets the initial number of iterations
iteration = 0
# Sets an array with one entry 0 to use for the error in the while loop
eigenvalues = [0]
# While number of iterations is less than 100, the matrix
# A is raised to a power equal to the iteration and multiplied
# by the original u0 that was given as an input. The dominant
# eigenvector is found and from that, the dominant eigenvalue
# is found.
while iteration < 100:
copyA = LA.matrix_power(A, iteration+1)
x = np.zeros(shape=(m, uCols))
for i in range(m):
for j in range(uCols):
for k in range(uRows):
x[i][j] += (copyA[i][k] * u[k][j]) #Multiplies matrix A and u
eigenvector = x / LA.norm(x) # Finds the dominant eigenvector
eigenRows = int(eigenvector.shape[0]) #rows of dominant eigenvector
eigenCols = int(eigenvector.shape[1]) #columns of eigenvector
Ax = np.zeros(shape = (m, eigenCols))
for i in range(m):
for j in range(eigenCols):
for k in range(eigenRows):
Ax[i][j] += A[i][k] * eigenvector[k][j]
Axx = np.vdot(Ax, eigenvector)
xx = np.vdot(eigenvector, eigenvector)
eigenvalue = Axx / xx # Finds the dominant eigenvalue
eigenvalues.append(eigenvalue)
if (np.absolute(eigenvalues[iteration+1] - eigenvalues[iteration])) <= tol:
break
iteration += 1
print "Dominant eigenvalue = ", eigenvalue
print "Dominant eigenvector =\n", eigenvector
if iteration >= 100:
print "Did not converge after 100 iterations."
else:
print "Took " + str(iteration) + " iterations to converge."
def spectralAnalysis(self):
# Assumes adjacency matrix is already made
for i in range(2,self.numNodes+1):
m = linalg.matrix_power(self.adjMatrix,i)/i
print "Spectral analysis, k= " + str(i) + ":\n" + str(m)
print ""
return m.diagonal()
def prob_3: #problem 3 A = np.array([[0, 0, 1, 0, 1, 0, 1], [1, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1, 0], [1, 0, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0], [0, 0, 1, 0, 0, 0, 1], [0, 1, 0, 0, 0, 0, 0]], dtype=np.int64) A5 = la.matrix_power(A,5) coords = np.where(A5==np.max(A5)) #note: indexing from 0 print "maximum of 5 step connections at: ", zip(coords[0], coords[1]) A7 = la.matrix_power(A,7) coords = np.where(A7==0) print "no 7 step connection for: ", zip(coords[0], coords[1])
def pam_matrix(d, scale=float(np.log(2)/2), as_ints=False):
"""Creates PAM scoring matrix.
Values calculated from (natural) log-odds ratio of PAM{d}:PAM{inf}. The
output will be this matrix *divided* by the scale parameter (this seems
to be the convention, but I am not sure why).
Args:
d: int. Mutation distance (number of time steps in the Markov chain
model).
scale: float. Units of returned matrix, relative to "natural" units
of the log-odds ration. Returned matrix will be the log-odds
values *divided* by the scale. Defaults to ln(2)/2 (half-bit
units), because that's what I've seen everywhere.
as_ints: bool. If true, entries will be rounded to the nearest integer.
"""
# Calculate matrix
dayhoff_n = matrix_power(dayhoff_matrix, d)
matrix = np.log(dayhoff_n / dayhoff_stationary[:, None]) / scale
# Doesn't seem to be completely symmetrical, hopefully just due to
# floating-point errors. Fudge it a bit.
matrix += matrix.transpose()
matrix *= .5
# Round if requested
if as_ints:
matrix = np.round(matrix)
return SubstitutionMatrix(aa_symbols, matrix.astype(np.float32))
def _calc_observable(pb=0.0, kex=0.0, dw=0.0, r_ixy=5.0, dr_ixy=0.0,
ncyc=0):
"""
Calculate the intensity in presence of exchange during a cpmg-type pulse
train.
Parameters
----------
i0 : float
Initial intensity.
pb : float
Fractional population of state B,
0.0 for 0%, 1.0 for 100%
kex : float
Exchange rate between state A and B in /s.
dw : float
Chemical shift difference between states A and B in rad/s.
r_ixy : float
Transverse relaxation rate of state a in /s.
dr_ixy : float
Transverse relaxation rate difference between states a and b in /s.
Returns
-------
out : float
Intensity after the CPMG block
"""
dw *= ppm_to_rads
mag_eq = compute_iy_eq(pb)
if ncyc == 0:
mag = mag_eq
else:
l_free = compute_liouvillians(
pb=pb,
kex=kex,
dw=dw,
r_ixy=r_ixy,
dr_ixy=dr_ixy
)
t_cp = time_t2 / (4.0 * ncyc)
p_free = expm(l_free * t_cp)
mag = matrix_power(
p_free
.dot(P_180Y)
.dot(p_free),
2 * ncyc
).dot(mag_eq)
magy_a, _ = get_iy(mag)
return magy_a
def _calculate_unscaled_profile(self, params_local, **kwargs):
"""TODO: class docstring."""
self.liouv.update(params_local)
# Calculation of the propagators corresponding to all the delays
delays = dict(zip(self.delays, self.liouv.delays(self.delays)))
d_zeta = delays[self.t_zeta]
# Calculation of the propagators corresponding to all the pulses
p180_sx = self.liouv.perfect180["sx"]
p180_ix = self.liouv.perfect180["ix"]
p180_iy = self.liouv.perfect180["iy"]
# Calculate starting magnetization vector
mag0 = self.liouv.compute_mag_eq(params_local, term="2iysx")
if self.small_protein:
mag0 = d_zeta @ p180_sx @ p180_ix @ d_zeta @ mag0
# Calculating the cpmg trains
cp = {0: self.liouv.identity}
for ncyc in set(self.data["ncycs"][~self.reference]):
tau_cp = delays[self.tau_cps[ncyc]]
echo = tau_cp @ p180_iy @ tau_cp
cp_train = la.matrix_power(echo, int(ncyc))
cp[ncyc] = cp_train @ p180_sx @ cp_train
profile = [
self.liouv.collapse(self.detect @ cp[ncyc] @ mag0)
for ncyc in self.data["ncycs"]
]
return np.asarray(profile)
def apply_to_char(self, char):
assert char in ['A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y']
char_map = {'A':0, 'R':1, 'N':2, 'D':3, 'C':4, 'Q':5, 'E':6, 'G':7, 'H':8, 'I':9, 'L':10, 'K':11, 'M':12, 'F':13, 'P':14, 'S':15, 'T':16, 'W':17, 'Y':18, 'V':19}
base_vector = [.074, .042, .044, .059, .033, .058, .037, .074, .029, .038, .076, .072, .018, .04, .05, .081, .062, .013, .033, .068] #observed frequencies in vertebrates
power_matrix = LA.matrix_power(self.transition_matrix, self.time)
transformation_vector = power_matrix[index]
new_char = np.random.choice(char_map.keys(), p=transformation_vector)
return new_char
def rand_mat_stat(t):
n = 5
v = np.empty(t)
w = np.empty(t)
for i in range(t):
a = randn(n, n)
b = randn(n, n)
c = randn(n, n)
d = randn(n, n)
P = concatenate((a, b, c, d), axis=1)
Q = concatenate((concatenate((a, b), axis=1),
concatenate((c, d), axis=1)), axis=0)
# v[i] = trace(matrix_power(P.T @ P, 4))
# w[i] = trace(matrix_power(Q.T @ Q, 4))
v[i] = trace(matrix_power(dot(P.T, P), 4))
w[i] = trace(matrix_power(dot(Q.T, Q), 4))
return np.std(v)/np.mean(v), np.std(w)/np.mean(w)
def approximate_stationary(N, d, iterations=None, power_multiple=15):
"""Approximate the stationary distribution by computing a large power of
the transition matrix, using successive squaring."""
power = int((log(N) + power_multiple) / log(2))
# Use successive squaring to a large power
m = matrix_power(d, 2**power)
# Each row is the stationary distribution
return m[0]
def _calc_observable(pb=0.0, kex=0.0, dw=0.0, r_cxy=5.0, dr_cxy=0.0, r_cz=1.5, cs=0.0, ncyc=0):
"""
Calculate the intensity in presence of exchange during a cpmg-type pulse train.
_______________________________________________________________________
1H : | / / / / / / / / CW / / / / / / / / |
15N: Nx { tauc 2Ny tauc }*ncyc 2Nx { tauc 2Ny tauc }*ncyc -Nx time_equil
Parameters
----------
i0 : float
Initial intensity.
pb : float
Fractional population of state B,
0.0 for 0%, 1.0 for 100%
kex : float
Exchange rate between state A and B in /s.
dw : float
Chemical shift difference between states A and B in rad/s.
r_cz : float
Longitudinal relaxation rate of state {a,b} in /s.
r_cxy : float
Transverse relaxation rate of state a in /s.
dr_cxy : float
Transverse relaxation rate difference between states a and b in /s.
cs_offset : float
Offset from the carrier in rad/s.
Returns
-------
out : float
Intensity after the CPMG block
"""
dw *= ppm_to_rads
cs_offset = (cs - carrier) * ppm_to_rads
l_free, ps = make_propagators(pb=pb, kex=kex, dw=dw, r_cxy=r_cxy, dr_cxy=dr_cxy, r_cz=r_cz, cs_offset=cs_offset)
p_equil, p_neg, p_90px, p_90mx, p_180pmx, p_180py = ps
mag_eq = compute_cz_eq(pb)
if ncyc == 0:
# The +/- phase cycling of the first 90 and the receiver is taken care
# by setting the thermal equilibrium to 0
mag = reduce(dot, [p_equil, p_90px, p_180pmx, p_90px, mag_eq])
else:
t_cp = time_t2 / (4.0 * ncyc) - pw
p_free = expm(l_free * t_cp)
p_cp = matrix_power(p_free.dot(p_180py).dot(p_free), ncyc)
mag = reduce(dot, [p_equil, p_90px, p_neg, p_cp, p_180pmx, p_cp, p_neg, p_90px, mag_eq])
magz_a, _ = get_cz(mag)
return magz_a
def LagkJointMomentsFromMRAP (H, K=0, L=1):
"""
Returns the lag-L joint moments of a marked rational
arrival process.
Parameters
----------
H : list/cell of matrices of shape(M,M), length(N)
The H0...HN matrices of the MRAP to check
K : int, optional
The dimension of the matrix of joint moments to
compute. If K=0, the MxM joint moments will be
computed. The default value is 0
L : int, optional
The lag at which the joint moments are computed.
The default value is 1
prec : double, optional
Numerical precision to check if the input is valid.
The default value is 1e-14
Returns
-------
Nm : list/cell of matrices of shape(K+1,K+1), length(N)
The matrices containing the lag-L joint moments,
starting from moment 0.
"""
if butools.checkInput and not CheckMRAPRepresentation (H):
raise Exception("LagkJointMomentsFromMRAP: Input is not a valid MRAP representation!")
if K==0:
K = H[0].shape[0]-1
M = len(H)-1
H0 = H[0]
sumH = ml.zeros(H[0].shape)
for i in range(M):
sumH += H[i+1]
H0i = la.inv(-H0)
P = H0i*sumH
pi = DRPSolve(P)
Pw = ml.eye(H0.shape[0])
H0p = [ml.matrix(Pw)]
for i in range(1,K+1):
Pw *= i*H0i
H0p.append(ml.matrix(Pw))
Pl = la.matrix_power (P, L-1)
Nm = []
for m in range(M):
Nmm = ml.zeros ((K+1,K+1))
for i in range(K+1):
for j in range(K+1):
Nmm[i,j] = np.sum (pi * H0p[i] * H0i * H[m+1] * Pl * H0p[j])
Nm.append(ml.matrix(Nmm))
return Nm
def converge(self, tol=1e-12, maxiter = 100):
'''
:return: converged transition matrix
uses the method of exponentiation by squaring
'''
u = la.matrix_power(self.transition_matrix, 2**20)
u[u<1e-6] = 0
return u
def cycle_mobility(g): from numpy import linalg as LA A = nx.to_numpy_matrix(g) A2 = LA.matrix_power(A,2) A3 = LA.matrix_power(A,3) Ap = A for i in range(g.number_of_nodes()): for j in range(g.number_of_nodes()): Ap[i,j] = 0 Ap[i,j] = A[i,j]*A[j,i] Ap3 = LA.matrix_power(Ap,3) cycleMobility = 0.5*A3.trace() - np.trace(Ap*A2) + np.trace(Ap*Ap*A2) - 0.33333333333 *np.trace(Ap3) return float(cycleMobility)
C = np.array([[-4, 1], [6, 5]])
D = np.array([[-6, 3, 1], [8, 9, -2], [6, -1, 5]])
print('a')
print((A @ B).T)
print('b')
print((B @ C).T)
print('c')
print(C - C.T)
print('d')
print(D - D.T)
print('e')
print(D.T.T)
print('f')
print((2 * C).T)
print('g')
print(A.T + B)
print('h')
print(A + B.T)
print('i')
print((A.T + B).T)
print('j')
print((2 * A.T - 5 * B).T)
print('k')
print((-D).T)
print('l')
print(-D.T)
print('m')
print(matrix_power(C, 2).T)
print('n')
print(matrix_power(C.T, 2))
def get_Avg_system(R, u10, u11):
p1 = np.array([u10, u11])
total_avg = 0
for ind in range(1, 500):
total_avg += ind * np.sum(np.dot(p1, matrix_power(R, ind - 1)))
return total_avg
import numpy as np from numpy.linalg import matrix_power import matrix_power P=np.matrix([[0.25, 0.40],[0.75, 0.60]]) print(P) N=np.matrix([[50],[50]]) print(N) N=P*N print(N) P10=matrix_power(P,10) N=P10*N print(N) N=P10*N print(N)
def eigen(self):
powmatrix = LA.matrix_power(self.adjMatrix, 1)
powmatrix = np.transpose(powmatrix)
eigenval, eigenvec = LA.eig(powmatrix)
return eigenval, eigenvec
#indices = np.array([20,70,90]) * nx//100
numindices = len(indices)
Khatlarge = np.zeros((numindices*nt,nx))
yinlarge = np.zeros(numindices*nt)
for numid in range(numindices):
print('Processing timeseries %i ' % (numid+1))
i = indices[numid]
yinlarge[numid*nt:(numid+1)*nt] = m1.results[:,i]
K = np.zeros((nt,2*nx))
for ni in range(nt):
#print(ni)
K[ni] = matrix_power(F,ni)[i]
Khat = K[:,100:]
Khatlarge[numid*nt:(numid+1)*nt,:] = Khat
# add additive and multiplicative noise
yinlarge = yinlarge * (1 + noisemult * np.random.uniform(low=-1,high=1,size=len(yinlarge))) + noiseadd * np.random.uniform(low=-1,high=1,size=len(yinlarge))
# Compute best estimate
xa = np.zeros(nx) # all zeros, no prior knowledge
#Sa = np.diag(sigmaxa*np.ones(2*nx))
Sa = np.diag(sigmaxa*np.ones(nx))
Se = np.diag(sigmaxe*np.ones(nt*numindices))
print('Computing best estimate')
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0
], [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0
], [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0
], [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0
])
sum1 = sum
for x in range(1, 31):
current = (LA.matrix_power(graph1, x))
sum1 = current + sum1
output = np.count_nonzero(sum1)
if (output == 900): # If there's 900 nonzero elements, graph is connected.
print('Graph 1 is connected.')
else:
print('Graph 1 is disconnected')
graph2 = ([
0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
1, 0, 1, 0, 1
], [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0
], [
def laplacian(A):
S = np.sum(A, 0)
D = np.diag(S)
D = LA.matrix_power(D, -1)
L = np.dot(D, A)
return L
def mat_rot(angle):
nb = angle // 90
ang = np.radians(90)
r = np.array(( (int(np.cos(ang)), int(-np.sin(ang))),
(int(np.sin(ang)), int(np.cos(ang))) ))
return alg.matrix_power(r,nb).astype(int)
(x[1] * np.cos(t) + y[1] * np.sin(t))**2)
z1 = self.head[0] + (1 / phi**2) * (x[0] * np.cos(t) +
y[0] * np.sin(t)) / norm
z2 = self.head[1] + (1 / phi**2) * (x[1] * np.cos(t) +
y[1] * np.sin(t)) / norm
plt.plot(z1, z2, color='tab:orange', linestyle='-', alpha=0.6)
ace = [
Kite(orient=15).translate(e2),
Kite(orient=11).translate(e2),
Dart(orient=3).translate(-(1 / phi) * e2)
]
deuce = [
Kite(orient=19).translate(matrix_power(m, 11) @ e1),
Kite(orient=7).translate(matrix_power(m, 19) @ e1),
Dart(orient=11).translate(e2),
Dart(orient=15).translate(e2)
]
sun = [
Kite(orient=3),
Kite(orient=7),
Kite(orient=11),
Kite(orient=15),
Kite(orient=19)
]
star = [
Dart(orient=3),
if len(edge) == 4:
if edge[3][:-1] == "1":
A1[edge[0], edge[1]] += 1
elif edge[3][:-1] == "0":
A0[edge[0], edge[1]] += 1
# to improve this I'd like to read the final states
A = A0 + A1
numstr = np.int64(2**n2)
prod = np.zeros((n**2,n**2), dtype=np.int64)
for j in range(n2):
prod += np.kron(LA.matrix_power(np.transpose(A), n2-(j+1)),LA.matrix_power(A, j))
G0 = np.zeros((n,n), dtype=np.int64)
for k in range(n):
for l in range(n):
G0 += prod[k*n:(k+1)*n,l*n:(l+1)*n]*A0[k,l]
num0s = G0.dot(np.ones((n,1)))
G1 = np.zeros((n,n), dtype=np.int64)
for k in range(n):
for l in range(n):
G1 += prod[k*n:(k+1)*n,l*n:(l+1)*n]*A1[k,l]
def markovCalculate(singles, doubles, triples, hr, walks, hbp, plateAppearences):
pSingle = singles/float(plateAppearences) if singles else 0
pDouble = doubles/float(plateAppearences) if doubles else 0
pTriple = triples/float(plateAppearences) if triples else 0
pHR = hr/float(plateAppearences) if hr else 0
pOut = 1 - ((singles+doubles+triples+hr + walks)/float(plateAppearences)) if singles+doubles+triples+hr+walks else 0
pWalk = (walks + hbp)/float(plateAppearences) if walks+hbp else 0
pWalkSingle = (walks+singles+hbp)/float(plateAppearences) if walks+singles+hbp else 0
#print("Stats", pSingle, pDouble, pTriple, pHR, pWalkSingle, pOut, pWalk, (pSingle + pDouble + pTriple + pHR + pWalkSingle + pOut + pWalk))
transition = numpy.matrix([
[pHR,pWalkSingle,pDouble,pTriple,0,0,0,0,pOut,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[pHR,0,0,pTriple,pWalkSingle,0,pDouble,0,0,pOut,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[pHR,pSingle,pDouble,pTriple,pWalk,0,0,0,0,0,pOut,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[pHR,pSingle,pDouble,pTriple,0,pWalk,0,0,0,0,0,pOut,0,0,0,0,0,0,0,0,0,0,0,0,0],
[pHR,0,0,pTriple,pSingle,0,pDouble,pWalk,0,0,0,0,pOut,0,0,0,0,0,0,0,0,0,0,0,0],
[pHR,0,0,pTriple,pSingle,0,pDouble,pWalk,0,0,0,0,0,pOut,0,0,0,0,0,0,0,0,0,0,0],
[pHR,pSingle,pDouble,pTriple,0,0,0,pWalk,0,0,0,0,0,0,pOut,0,0,0,0,0,0,0,0,0,0],
[pHR,0,0,pTriple,pSingle,0,pDouble,pWalk,0,0,0,0,0,0,0,pOut,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,pHR,pWalkSingle,pDouble,pTriple,0,0,0,0,pOut,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,pHR,0,0,pTriple,pWalkSingle,0,pDouble,0,0,pOut,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,pHR,pSingle,pDouble,pTriple,pWalk,0,0,0,0,0,pOut,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,pHR,pSingle,pDouble,pTriple,0,pWalk,0,0,0,0,0,pOut,0,0,0,0,0],
[0,0,0,0,0,0,0,0,pHR,0,0,pTriple,pSingle,0,pDouble,pWalk,0,0,0,0,pOut,0,0,0,0],
[0,0,0,0,0,0,0,0,pHR,0,0,pTriple,pSingle,0,pDouble,pWalk,0,0,0,0,0,pOut,0,0,0],
[0,0,0,0,0,0,0,0,pHR,pSingle,pDouble,pTriple,0,0,0,pWalk,0,0,0,0,0,0,pOut,0,0],
[0,0,0,0,0,0,0,0,pHR,0,0,pTriple,pSingle,0,pDouble,pWalk,0,0,0,0,0,0,0,pOut,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,pHR,pWalkSingle,pDouble,pTriple,0,0,0,0,pOut],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,pHR,0,0,pTriple,pWalkSingle,0,pDouble,0,pOut],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,pHR,pSingle,pDouble,pTriple,pWalk,0,0,0,pOut],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,pHR,pSingle,pDouble,pTriple,0,pWalk,0,0,pOut],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,pHR,0,0,pTriple,pSingle,0,pDouble,pWalk,pOut],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,pHR,0,0,pTriple,pSingle,0,pDouble,pWalk,pOut],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,pHR,pSingle,pDouble,pTriple,0,0,0,pWalk,pOut],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,pHR,0,0,pTriple,pSingle,0,pDouble,pWalk,pOut],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]
])
runVector = numpy.matrix([
[pHR],
[2*pHR + pTriple],
[2*pHR + pSingle + pDouble + pTriple],
[2*pHR + pSingle + pDouble + pTriple],
[3*pHR + pSingle + pDouble + 2*pTriple],
[3*pHR + pSingle + pDouble + 2*pTriple],
[3*pHR + 2*pSingle + 2*pDouble + 2*pTriple],
[4*pHR + 2*pSingle + 2*pDouble + 3*pTriple + pWalk],
[pHR],
[2*pHR + pTriple],
[2*pHR + pSingle + pDouble + pTriple],
[2*pHR + pSingle + pDouble + pTriple],
[3*pHR + pSingle + pDouble + 2*pTriple],
[3*pHR + pSingle + pDouble + 2*pTriple],
[3*pHR + 2*pSingle + 2*pDouble + 2*pTriple],
[4*pHR + 2*pSingle + 2*pDouble + 3*pTriple + pWalk],
[pHR],
[2*pHR + pTriple],
[2*pHR + pSingle + pDouble + pTriple],
[2*pHR + pSingle + pDouble + pTriple],
[3*pHR + pSingle + pDouble + 2*pTriple],
[3*pHR + pSingle + pDouble + 2*pTriple],
[3*pHR + 2*pSingle + 2*pDouble + 2*pTriple],
[4*pHR + 2*pSingle + 2*pDouble + 3*pTriple + pWalk],
[0]
])
resultMatrix = runVector
for z in range(1,12):
curentTransition = linalg.matrix_power(transition, z)
tempMatrix = numpy.dot(curentTransition,runVector)
resultMatrix = numpy.add(resultMatrix,tempMatrix)
return resultMatrix
def test_large_power(self):
assert_equal(matrix_power(self.R90, 2**100 + 2**10 + 2**5 + 1),
self.R90)
def tz(M):
mz = matrix_power(M, -1)
assert_almost_equal(identity(M.shape[0]), dot(mz, M))
transProb[i][j] = trans[i][j] / sum(list(trans[i]))
return transProb
# B
transitionMatrix = getMatrixTransitions(acciones)
print(transitionMatrix)
# # C
[autovalores,autovectores] = LA.eig(transitionMatrix)
# como |lambak| < 1 con k-1 pi p = pi
print(autovectores)
print(np.transpose(autovectores))
print(autovalores)
# pelevado = autovectores * matrix_power(autovaloresMat,100) * matrix_power(np.transpose(autovectores),-1)
print(matrix_power(transitionMatrix,100))
#D
difAccionA = list(accionesA["DeltaA"])
difAccionA.pop(0)
plt.title("Diferencia Acciones A")
plt.hist(difAccionA,bins=100)
plt.show()
difAccionB = list(accionesB["DeltaB"])
difAccionB.pop(0)
plt.title("Diferencia Acciones B")
plt.hist(difAccionB,bins=100)
plt.show()
def tz(M):
mz = matrix_power(M, 2)
assert_equal(mz, dot(M, M))
assert_equal(mz.dtype, M.dtype)
def gaussSeidel(tolerance, x0, iterations, matrix, b, rel):
n = len(matrix)
det = linalg.det(matrix)
if det == 0:
return (
1,
"The system does not have an unique solution. Determinant is ZERO")
diagonal_matrix = diag(diag(matrix))
l_matrix = diagonal_matrix - tril(matrix)
u_matrix = diagonal_matrix - triu(matrix)
helper = diagonal_matrix - (rel * l_matrix)
helper2 = ((1 - rel) * diagonal_matrix) + (rel * u_matrix)
power = linalg.matrix_power(helper, -1)
t_matrix = matmul(power, helper2)
Z = [[abs(matrix[i][j]) for i in range(n)] for j in range(n)]
helper3 = asarray(Z)
suma = helper3.sum(axis=1)
a = 0
for i in range(n):
aux2 = (2 * (Z[i][i]))
if all(aux2 > suma):
a = 1
else:
a = 2
RE = 0
if a == 2:
RE = max(abs(LA.eigvals(t_matrix)))
if RE > 1:
return (1, "The spectral radio is larger than 1 (" + str(RE) +
"). Method won't converge\n \
The matrix is not dominant on its diagonal")
title = ['n']
aux = 0
cont = 0
while aux < len(x0):
title.append("x" + str(aux))
aux += 1
title.append("Error")
table = PrettyTable(title)
result = [title]
table.add_row([cont] + x0 + ["Doesn't exist"])
result.append([cont] + x0 + ["Doesn't exist"])
error = tolerance + 1
while error > tolerance and cont < iterations:
x1 = newGaussSeidel(x0, matrix, b, rel)
error = norma(x0, x1)
cont += 1
table.add_row([cont] + x1 + ['%.2E' % Decimal(str(error))])
result.append([cont] + x1 + ['%.2E' % Decimal(str(error))])
x0 = copy(x1)
return 0, x0, result, cont, t_matrix, RE
# m = [[5,3,1],[3,4,-1],[1,-1,4]]
# b = [24,30,-24]
# gaussSeidel(6e-063, [0,0,0], 40, m, b, 1)
def Rodrigues(w_hat, theta):
return (np.identity(3) + w_hat * np.sin(theta) + matrix_power(w_hat, 2) *
(1 - np.cos(theta)))
def _calc_observable(pb=0.0,
kex=0.0,
dw=0.0,
r_nxy=5.0,
dr_nxy=0.0,
r_nz=1.5,
r_2hznz=0.0,
etaxy=0.0,
etaz=0.0,
j_hn=0.0,
dj_hn=0.0,
cs=0.0,
ncyc=0):
"""
Calculate the intensity in presence of exchange during a cpmg-type pulse train.
_______________________________________________________________________
1H : | / / / / / / / / CW / / / / / / / / |
15N: Nx { tauc 2Ny tauc }*ncyc 2Nx { tauc 2Ny tauc }*ncyc -Nx time_equil
Parameters
----------
i0 : float
Initial intensity.
pb : float
Fractional population of state B,
0.0 for 0%, 1.0 for 100%
kex : float
Exchange rate between state A and B in /s.
dw : float
Chemical shift difference between states A and B in rad/s.
r_nz : float
Longitudinal relaxation rate of state {a,b} in /s.
r_nxy : float
Transverse relaxation rate of state a in /s.
dr_nxy : float
Transverse relaxation rate difference between states a and b in /s.
cs_offset : float
Offset from the carrier in rad/s.
Returns
-------
out : float
Intensity after the CPMG block
"""
dw *= ppm_to_rads
cs_offset = (cs - carrier) * ppm_to_rads - pi * j_hn
l_free, ps = make_propagators(pb=pb,
kex=kex,
dw=dw,
r_nxy=r_nxy,
dr_nxy=dr_nxy,
r_nz=r_nz,
r_2hznz=r_2hznz,
etaxy=etaxy,
etaz=etaz,
j_hn=j_hn,
dj_hn=dj_hn,
cs_offset=cs_offset)
(p_equil, p_neg, p_90px, p_90py, p_90mx, p_90my, p_180px, p_180py,
p_element) = ps
mag_eq = compute_2hznz_eq(pb)
if ncyc == 0:
# The +/- phase cycling of the first 90 and the receiver is taken care
# by setting the thermal equilibrium to 0
mag = -reduce(dot, [p_equil, p_90py, p_element, p_90px, mag_eq])
else:
t_cp = time_t2 / (4.0 * ncyc) - pw
p_free = expm(l_free * t_cp)
p_cpx = matrix_power(p_free.dot(p_180px).dot(p_free), ncyc)
p_cpy = matrix_power(p_free.dot(p_180py).dot(p_free), ncyc)
p_element_pc = 0.5 * (p_90px.dot(p_element).dot(p_90py) +
p_90mx.dot(p_element).dot(p_90my))
mag = -reduce(dot, [
p_equil, p_90py, p_neg, p_cpx, p_neg, p_element_pc, p_neg,
p_cpy, p_neg, p_90px, mag_eq
])
magz_a, _magz_b = get_atrz(mag)
return magz_a
def raisematrix(self, nth):
#raise transition matrix to the "nth" power
powmatrix = LA.matrix_power(self.adjMatrix, nth)
return powmatrix
def MPC(
trajectory,
heading_error,
lateral_error,
dt,
state_matrix,
input_matrix,
drift_matrix,
prediction_horizon=5,
):
# Implementation of MPC, please see the following ref:
# Convex Optimization – Boyd and Vandenberghe
# https://markcannon.github.io/assets/downloads/teaching/C21_Model_Predictive_Control/mpc_notes.pdf
matrix_A = np.eye(state_matrix.shape[0]) + dt * state_matrix
matrix_B = dt * input_matrix
matrix_B0 = dt * drift_matrix
matrix_M = matrix_A
matrix_C = np.concatenate(
(
matrix_B,
np.zeros([
matrix_B.shape[0],
(prediction_horizon - 1) * matrix_B.shape[1]
]),
),
axis=1,
)
matrix_T_tilde = matrix_B0[:, 0]
for i in range(prediction_horizon - 1):
matrix_M = np.concatenate(
(matrix_M, matrix_power(matrix_A, i + 2)), axis=0)
matrix_T_tilde = np.concatenate(
(
matrix_T_tilde,
np.matmul(
matrix_A,
matrix_T_tilde[matrix_T_tilde.shape[0] -
matrix_B0.shape[0]:matrix_T_tilde.
shape[0]],
matrix_B0[:, i + 1],
),
),
axis=0,
)
temp = np.matmul(matrix_power(matrix_A, i + 1), matrix_B)
for j in range(i + 1, 0, -1):
temp = np.concatenate(
(temp, np.matmul(matrix_power(matrix_A, j - 1), matrix_B)),
axis=1)
temp = np.concatenate(
(
temp,
np.zeros([
matrix_B.shape[0],
(prediction_horizon - i - 2) * matrix_B.shape[1],
]),
),
axis=1,
)
matrix_C = np.concatenate((matrix_C, temp), axis=0)
# Q_tilde contains the MPC state cost weights. The ordering of
# gains are as [lateral_error,lateral_velocity,heading_error,yaw_rate].
# Increasing the lateral_error weight can cause oscillations which can
# be damped out by increasing yaw_rate weight.
Q_tilde = np.kron(np.eye(prediction_horizon),
0.1 * np.diag([354, 0, 14, 250]))
# R_tilde contain the steering input weight.
R_tilde = np.kron(np.eye(prediction_horizon), np.eye(1))
matrix_H = (
np.transpose(matrix_C)).dot(Q_tilde).dot(matrix_C) + R_tilde
matrix_F = (np.transpose(matrix_C)).dot(Q_tilde).dot(matrix_M)
matrix_F1 = (np.transpose(matrix_C)).dot(Q_tilde).dot(matrix_T_tilde)
# This is the solution to the unconstrained optimization problem
# for the MPC.
unconstrained_optimal_solution = np.matmul(
np.linalg.inv(2 * matrix_H),
np.matmul(matrix_F,
np.array([[lateral_error], [0], [heading_error], [0]])) +
np.reshape(matrix_F1, (-1, 1)),
)[0][0]
return np.clip(-unconstrained_optimal_solution, -1, 1)
def _calc_observable(pb=0.0,
kex=0.0,
dwh=0.0,
dwc=0.0,
r_2hxycxy=5.0,
dr_2hxycxy=0.0,
ncyc=0):
"""
Calculate the intensity in presence of exchange during a cpmg-type pulse
train. Based on the sequence "hmqc_CH3_exchange_bigprotein_600_lek_v2.c".
Parameter names from the sequence are:
chemex procpar
------ -------
time_T2 time_T2
ncyc ncyc_cp
Parameters
----------
i0 : float
Initial intensity
pb : float
Fractional population of state b
kex : float
Exchange rate between state a and b in /s
dwh : float
Proton chemical shift difference between states A and B in ppm
dwc : float
Carbon chemical shift difference between states A and B in ppm
r_2hxycxy : float
Multiple quantum relaxation rate in /s
dr_2hxycxy : float
Multiple quantum relaxation rate difference between a and b in /s
smallflg: string ['y', 'n']
Flag to include small_protein_flg block in fitting
Returns
-------
out : float
Intensity after the CPMG block
"""
dwh *= ppm_to_rads_h
dwc *= ppm_to_rads_c
l_free = make_propagators(
pb=pb,
kex=kex,
dwh=dwh,
dwc=dwc,
r_2hxycxy=r_2hxycxy,
dr_2hxycxy=dr_2hxycxy,
)
mag_eq = compute_2hxcy_eq(pb)
if ncyc == 0:
mag = mag_eq
else:
t_cp = time_t2 / (4.0 * ncyc)
p_free = expm(l_free * t_cp)
p_cpy = matrix_power(p_free.dot(P180_CY).dot(p_free), ncyc)
mag = reduce(dot, [p_cpy, P180_HX, p_cpy, mag_eq])
magz_a, _ = get_2hxcy(mag)
return magz_a
def test_square(self):
A = array([[True, False], [True, True]])
assert_equal(matrix_power(A, 2), A)
def energy_H(H):
S = 0
for i in range(distance):
S += weights[i] * LA.norm(H_vec_observed[i] -
LA.matrix_power(H, i + 1))
return S
def test_invert_noninvertible(self):
import numpy.linalg
assert_raises(numpy.linalg.linalg.LinAlgError,
lambda: matrix_power(self.noninv, -1))
def test_large_power_trailing_zero(self):
assert_equal(matrix_power(self.R90, 2**100 + 2**10 + 2**5),
identity(2))
def test_returntype(self):
a = np.array([[0, 1], [0, 0]])
assert_(type(matrix_power(a, 2)) is np.ndarray)
a = mat(a)
assert_(type(matrix_power(a, 2)) is matrix)
def tz(M):
mz = matrix_power(M, 0)
assert_equal(mz, identity(M.shape[0]))
assert_equal(mz.dtype, M.dtype)
def tz(M):
mz = matrix_power(M, 1)
assert_equal(mz, M)
assert_equal(mz.dtype, M.dtype)
def test_list(self):
assert_array_equal(matrix_power([[0, 1], [0, 0]], 2), [[0, 0], [0, 0]])
def _find_erg_sets(self):
"""
This method finds all of the ergodic sets for a given transition
matrix P. It saves the ergodic sets in the class object.
Note: This method is still undergoing testing and improvement. If
you find a bug or an example where it doesn't work please let us
know so we can amend our code to do the right thing.
Parameters
----------
self
Returns
-------
None
"""
P = self.P
num_states = P.shape[0]
# We are going to use graph theory to find ergodic sets
# We first find where there is positive probability of
# the sets
pos_prob_P = np.where(P > 0)
# Put a one in a matrix everywhere there is positive
# probability of going from state i to state j
connect_mat = np.zeros(P.shape)
connect_mat[pos_prob_P] = 1.
sets_mat = np.zeros(P.shape)
# We want to know whether they can get from any given
# state to the other so we need to add each exponent
# of connect_mat^n for n up to the num_states. This is
# equivalent to (I - P)^{-1}(I - P^n)
# TODO: If matrix is singular that doesn't work
for i in xrange(num_states):
sets_mat += matrix_power(connect_mat, i + 1)
# Now we know where they really are connected in num_states steps
true_connected = np.zeros(P.shape)
true_index = np.where(sets_mat > 0)
true_connected[true_index] = 1.
# Create a dictionary where every state will have a set
# we will use these sets to establish which sets of
# elements are in the same ergodic set
conn_states = {'state_%s' % st: set() for st in xrange(num_states)}
possible_ergodic = set(np.arange(num_states))
trans_states = set()
ergodic_sets = []
num_erg_sets = 0
# We need to first remove the transient states
# TODO: Think more about this loop. Can this be vectorized?
# Find all of the connected both ways states and the ones that
# aren't connected both ways should be transient
for row in possible_ergodic:
for col in possible_ergodic:
if abs(true_connected[row, col] - 1) < 1e-10 \
and abs(true_connected[col, row] - 1) < 1e-10:
conn_states['state_%s' % row].add(col)
elif abs(true_connected[row, col] - 1) > 1e-10 \
and abs(true_connected.T[row, col] - 1) < 1e-10:
trans_states.add(col)
# Take the transient states out of the possible ergodic states
for i in trans_states:
possible_ergodic.remove(i)
# Now we need to see whether the sets match up like we want them to
for i in possible_ergodic:
check_equiv = []
for t in conn_states['state_%s' % i]:
if conn_states['state_%s' % i] == conn_states['state_%s' % t]:
check_equiv.append(t)
if conn_states['state_%s' %i] == set(check_equiv) \
and check_equiv not in ergodic_sets:
ergodic_sets.append(check_equiv)
self.ergodic_sets = ergodic_sets
return None
