def Hamiltonian():
H1 = E_0*diag(ones(q*L**2, complex))
H2q = t1*diag(ones(q-1, complex), -1)
H2xy= diag(ones(L*L, complex)).reshape(L**2,L**2)
H2 = ln.kron(H2xy, H2q)
H3q = diag([t2*exp(2*pi*k*1j/q) for k in range(q)])
H3x = diag(ones(L, complex))
H3y = diag(ones(L-1, complex), -1)
H3xy = ln.kron(H3x, H3y)
H3 = ln.kron(H3xy, H3q)
H4q = zeros(q**2).reshape(q,q)
H4q[0,q-1]= t1
H4x = diag(ones(L-1, complex), -1)
H4y = diag(ones(L, complex))
H4xy = ln.kron(H4x, H4y)
H4 = ln.kron(H4xy, H4q)
H = H1+ H2 + H3+ H4
H = H + array(matrix(H).getH())
return H
def lz(L,S,I):
gS=int(2*S+1)
Si=identity(gS)
Lz=jz(L)
gI=int(2*I+1)
Ii=identity(gI)
lz=kron(kron(Lz,Si),Ii)
return lz
def Iz(L,S,I):
gS=int(2*S+1)
gL=int(2*L+1)
Si=identity(gS)
Li=identity(gL)
Iz_num=jz(I)
Iz=kron(kron(Li,Si),Iz_num)
return Iz
def sz(L,S,I):
Sz=jz(S)
gL=int(2*L+1)
Li=identity(gL)
gI=int(2*I+1)
Ii=identity(gI)
sz=kron(kron(Li,Sz),Ii)
return sz
def test_basic(self):
a = kron(array([[1, 2], [3, 4]]), array([[1, 1, 1]]))
assert_array_equal(a, array([[1, 1, 1, 2, 2, 2], [3, 3, 3, 4, 4, 4]]))
m1 = array([[1, 2], [3, 4]])
m2 = array([[10], [11]])
a = kron(m1, m2)
expected = array([[10, 20], [11, 22], [30, 40], [33, 44]])
assert_array_equal(a, expected)
def fz(L,S,I):
gS=int(2*S+1)
Sz=jz(S)
Si=identity(gS)
gL=int(2*L+1)
Lz=jz(L)
Li=identity(gL)
gJ=gL*gS
Jz=kron(Lz,Si)+kron(Li,Sz)
Ji=identity(gJ)
gI=int(2*I+1)
Iz=jz(I)
Ii=identity(gI)
Fz=kron(Jz,Ii)+kron(Ji,Iz)
return Fz
def test_expect(self): exp=expect(self.mps,self.ops) OP=self.ops[0] for i in range(1,6): OP=kron(OP,self.ops[i]) exp2=self.ket.conjugate().transpose().dot(OP.dot(self.ket)) print exp print exp2
def Hfs(L,S,I):
"""Provides the L dot S matrix (fine structure)"""
gS=int(2*S+1) #number of mS values
Sx=jx(S)
Sy=jy(S)
Sz=jz(S)
Si=identity(gS)
gL=int(2*L+1)
Lx=jx(L)
Ly=jy(L)
Lz=jz(L)
Li=identity(gL)
gJ=gL*gS
Jx=kron(Lx,Si)+kron(Li,Sx)
Jy=kron(Ly,Si)+kron(Li,Sy)
Jz=kron(Lz,Si)+kron(Li,Sz)
J2=dot(Jx,Jx)+dot(Jy,Jy)+dot(Jz,Jz)
gI=int(2*I+1)
Ii=identity(gI)
gF=gJ*gI
Fi=identity(gF)
Hfs=0.5*(kron(J2,Ii)-L*(L+1)*Fi-S*(S+1)*Fi) # fine structure in m_L,m_S,m_I basis
return Hfs
def kron(self,x,y):
"""
Matrix Kroneker product between objects ``x`` and ``y``.
Symbolically this is expressed as :math:`x \\otimes y`.
Also, the bitwise or function has been redefined to now mean
a Kronecker product. For two operator objects ``x`` and
``y``, now ``x|y`` is their Kronecker product.
"""
prod = operator( kron(x,y) )
return prod
def __init__(self, m, l, d, mu, tilde_mu, B, c_shape, c_vel):
self.m = m
self.l = l
self.d = d
self.mu = mu
self.tilde_mu = tilde_mu
self.B = B
self.agents, self.edges = self.B.shape
self.S1 = self.make_S1()
self.S2 = self.make_S2()
self.Av = self.make_Av()
self.Aa = self.Av.dot(self.B.T).dot(self.Av)
self.Bb = la.kron(self.B, np.eye(self.m))
self.S1b = la.kron(self.S1, np.eye(self.m))
self.S2b = la.kron(self.S2, np.eye(self.m))
self.Avb = la.kron(self.Av, np.eye(self.m))
self.Aab = la.kron(self.Aa, np.eye(self.m))
self.Ed = np.zeros(self.edges)
self.Ev = np.zeros(self.edges*self.m)
self.c_shape = c_shape
self.c_vel = c_vel
def Bbhfs(L,S,I):
"""Calculates electric quadrupole matrix.
Calculates the part in square brakets from
equation (8) in manual
"""
gS=int(2*S+1)
Sx=jx(S)
Sy=jy(S)
Sz=jz(S)
Si=identity(gS)
gL=int(2*L+1)
Lx=jx(L)
Ly=jy(L)
Lz=jz(L)
Li=identity(gL)
gJ=gL*gS
Jx=kron(Lx,Si)+kron(Li,Sx)
Jy=kron(Ly,Si)+kron(Li,Sy)
Jz=kron(Lz,Si)+kron(Li,Sz)
gI=int(2*I+1)
gF=gJ*gI
Ix=jx(I)
Iy=jy(I)
Iz=jz(I)
Fi=identity(gF)
IdotJ=kron(Jx,Ix)+kron(Jy,Iy)+kron(Jz,Iz)
IdotJ2=dot(IdotJ,IdotJ)
if I != 0:
Bbhfs=1./(6*I*(2*I-1))*(3*IdotJ2+3./2*IdotJ-I*(I+1)*15./4*Fi)
else:
Bbhfs = 0
return Bbhfs
def hamilB(B0):
'''
Calculate hamiltonians for all 4 orientations for specific B field of the
P1 defec in diamond.
creates hamiltonians of the form:
H = alfa B @ S + A @ S @ I
with @ the tensor inproduct operation.
input: B-field vector
outputs: 4 hamiltonians
'''
# constants.
pi = n.pi
beta = 1 # Bohr magneton
g = 1 # spectroscopic splitting factor
alfa = 28.04
angle = pi -2 * arcsin(1 / sqrt(3)) #109.5 degrees angle between tetrahedral bonds.
# matrices.
Sx, Sy, Sz = spinhalf()
Ix, Iy, Iz = spin1()
R1 = transpose(rot(angle, axis = 'y'))
R2 = transpose(rot(pi * 2 / 3, axis = 'z') * rot(angle, axis = 'y'))
R3 = transpose(rot(-pi * 2 / 3, axis = 'z') * rot(angle, axis = 'y'))
B1_ = B0
B2_ = R1 * B1_
B3_ = R2 * B1_
B4_ = R3 * B1_
#hyperfine tensor
A = matrix([[81.33], [81.33], [114.03]])
# hyperfine interaction hamiltonian
H_ASI = A.item(0) * la.kron(Sx, Ix) + A.item(1) * la.kron(Sy, Iy) + A.item(2) * la.kron(Sz, Iz)
# hamiltonians work in electron spin half + nuclear spin 1 base, 6D
H1 = alfa * la.kron((B1_.item(0) * Sx + B1_.item(1) * Sy + B1_.item(2) * Sz), eye(3)) + H_ASI
H2 = alfa * la.kron((B2_.item(0) * Sx + B2_.item(1) * Sy + B2_.item(2) * Sz), eye(3)) + H_ASI
H3 = alfa * la.kron((B3_.item(0) * Sx + B3_.item(1) * Sy + B3_.item(2) * Sz), eye(3)) + H_ASI
H4 = alfa * la.kron((B4_.item(0) * Sx + B4_.item(1) * Sy + B4_.item(2) * Sz), eye(3)) + H_ASI
return H1, H2, H3, H4
from scipy.sparse import identity from copy import deepcopy from mps import MPS,ket2mps,overlap,expect from dmrg import DMRGEngine from testdmrg import lhgen,rhgen ket=np.random.rand(2**4) mps=ket2mps(ket,2,4,cano='mixed',div=2) ket2=np.random.rand(2**4) mps2=ket2mps(ket2,2,4,cano='mixed',div=2) opl=[np.array([[0.5,0.],[0.,-0.5]]),np.array([[1.,0.],[0.,1.]]),np.array([[1.,0.],[0.,1.]]),np.array([[1.,0.],[0.,1.]])] OP=deepcopy(opl[0]) for i in range(3): OP=kron(OP,np.array([[1.,0.],[0.,1.]])) def test_tomps(): dmrg=DMRGEngine(lhgen,rhgen) dmrg.finite(mwarmup=10,mlist=[10]) dmps=dmrg.tomps() return dmps def test_shape(mps): for M in mps.Ms: print M.shape def test_shift(mps): mps.shift(site=mps.L/2-1) test_shape(mps) test_cano(mps)
def Hamiltonian_Matrix(self):
self.hamiltonian = self.h0
self.hamiltonian = la.kron(self.omegatot_1[0] * self.sx + self.omegatot_1[1] * self.sy + self.omegatot_1[2] * self.sz, self.iden2) + la.kron(self.iden2, self.omegatot_2[0] * self.sx + self.omegatot_2[1] * self.sy + self.omegatot_2[2] * self.sz)-2.0*(self.J_couple)*self.s1_s2
return
def formation(self):
'''
formation control algorithm
'''
ready = True
for rc in self.rotorcrafts:
if not rc.initialized:
if self.verbose:
print("Waiting for state of rotorcraft ", rc.id)
sys.stdout.flush()
ready = False
if rc.timeout > 0.5:
if self.verbose:
print("The state msg of rotorcraft ", rc.id, " stopped")
sys.stdout.flush()
ready = False
if rc.initialized and 'geo_fence' in list(self.config.keys()):
geo_fence = self.config['geo_fence']
if not self.ignore_geo_fence:
if (rc.X[0] < geo_fence['x_min']
or rc.X[0] > geo_fence['x_max']
or rc.X[1] < geo_fence['y_min']
or rc.X[1] > geo_fence['y_max']
or rc.X[2] < geo_fence['z_min']
or rc.X[2] > geo_fence['z_max']):
if self.verbose:
print("The rotorcraft", rc.id,
" is out of the fence (", rc.X, ", ",
geo_fence, ")")
sys.stdout.flush()
ready = False
if not ready:
return
dim = 2 * len(self.rotorcrafts)
X = np.zeros(dim)
V = np.zeros(dim)
U = np.zeros(dim)
i = 0
for rc in self.rotorcrafts:
X[i] = rc.X[0]
X[i + 1] = rc.X[1]
V[i] = rc.V[0]
V[i + 1] = rc.V[1]
i = i + 2
Bb = la.kron(self.B, np.eye(2))
Z = Bb.T.dot(X)
Dz = rf.make_Dz(Z, 2)
Dzt = rf.make_Dzt(Z, 2, 1)
Dztstar = rf.make_Dztstar(self.d * self.scale, 2, 1)
Zh = rf.make_Zh(Z, 2)
E = rf.make_E(Z, self.d * self.scale, 2, 1)
# Shape and motion control
jmu_t1 = self.joystick.trans * self.t1[0, :]
jtilde_mu_t1 = self.joystick.trans * self.t1[1, :]
jmu_r1 = self.joystick.rot * self.r1[0, :]
jtilde_mu_r1 = self.joystick.rot * self.r1[1, :]
jmu_t2 = self.joystick.trans2 * self.t2[0, :]
jtilde_mu_t2 = self.joystick.trans2 * self.t2[1, :]
jmu_r2 = self.joystick.rot2 * self.r2[0, :]
jtilde_mu_r2 = self.joystick.rot2 * self.r2[1, :]
Avt1 = rf.make_Av(self.B, jmu_t1, jtilde_mu_t1)
Avt1b = la.kron(Avt1, np.eye(2))
Avr1 = rf.make_Av(self.B, jmu_r1, jtilde_mu_r1)
Avr1b = la.kron(Avr1, np.eye(2))
Avt2 = rf.make_Av(self.B, jmu_t2, jtilde_mu_t2)
Avt2b = la.kron(Avt2, np.eye(2))
Avr2 = rf.make_Av(self.B, jmu_r2, jtilde_mu_r2)
Avr2b = la.kron(Avr2, np.eye(2))
Avb = Avt1b + Avr1b + Avt2b + Avr2b
Avr = Avr1 + Avr2
if self.B.size == 2:
Zhr = np.array([-Zh[1], Zh[0]])
U = -self.k[1] * V - self.k[0] * Bb.dot(Dz).dot(Dzt).dot(
E) + self.k[1] * (Avt1b.dot(Zh) + Avt2b.dot(Zhr)) + np.sign(
jmu_r1[0]) * la.kron(
Avr1.dot(Dztstar).dot(self.B.T).dot(Avr1),
np.eye(2)).dot(Zhr)
else:
U = -self.k[1] * V - self.k[0] * Bb.dot(Dz).dot(Dzt).dot(
E) + self.k[1] * Avb.dot(Zh) + la.kron(
Avr.dot(Dztstar).dot(self.B.T).dot(Avr), np.eye(2)).dot(Zh)
if self.verbose:
#print "Positions: " + str(X).replace('[','').replace(']','')
#print "Velocities: " + str(V).replace('[','').replace(']','')
#print "Acceleration command: " + str(U).replace('[','').replace(']','')
print("Error distances: " +
str(E).replace('[', '').replace(']', ''))
sys.stdout.flush()
i = 0
for ac in self.rotorcrafts:
msg = PprzMessage("datalink", "DESIRED_SETPOINT")
msg['ac_id'] = ac.id
msg['flag'] = 0 # full 3D not supported yet
msg['ux'] = U[i]
msg['uy'] = U[i + 1]
msg['uz'] = self.altitude
self._interface.send(msg)
i = i + 2
def Hhfs(L, S, I):
"""Provides the I dot J matrix (magnetic dipole interaction)"""
gS = int(2 * S + 1)
Sx = jx(S)
Sy = jy(S)
Sz = jz(S)
Si = identity(gS)
gL = int(2 * L + 1)
Lx = jx(L)
Ly = jy(L)
Lz = jz(L)
Li = identity(gL)
gJ = gL * gS
Jx = kron(Lx, Si) + kron(Li, Sx)
Jy = kron(Ly, Si) + kron(Li, Sy)
Jz = kron(Lz, Si) + kron(Li, Sz)
Ji = identity(gJ)
J2 = dot(Jx, Jx) + dot(Jy, Jy) + dot(Jz, Jz)
gI = int(2 * I + 1)
gF = gJ * gI
Ix = jx(I)
Iy = jy(I)
Iz = jz(I)
Ii = identity(gI)
Fx = kron(Jx, Ii) + kron(Ji, Ix)
Fy = kron(Jy, Ii) + kron(Ji, Iy)
Fz = kron(Jz, Ii) + kron(Ji, Iz)
Fi = identity(gF)
F2 = dot(Fx, Fx) + dot(Fy, Fy) + dot(Fz, Fz)
Hhfs = 0.5 * (F2 - I * (I + 1) * Fi - kron(J2, Ii))
return Hhfs
def liouville(self):
self.ltot = la.kron((-1j*self.hamiltonian-self.haberkorn),self.iden4) + la.kron(self.iden4,np.transpose(+1j*self.hamiltonian-self.haberkorn)) - self.kstd*(la.kron(self.pro_trip,np.transpose(self.pro_sing))+la.kron(self.pro_sing,np.transpose(self.pro_trip)))
return
def tik_sep(B, PSF, center=None, alpha=None, BC=None):
"""TIK_SEP Tikhonov image deblurring using the Kronecker decomposition.
X, alpha = tik_sep(B, PSF, center, alpha, BC)
Compute restoration using a Kronecker product decomposition and a
Tikhonov filter, with the identity matrix as the regularization operator.
Input:
B Array containing blurred image.
PSF Array containing the point spread function.
center [row, col] = indices of center of PSF.
Optional Inputs:
alpha Regularization parameter.
Default parameter chosen by generalized cross validation.
BC String indicating boundary condition.
('zero', 'reflexive', or 'periodic')
Default is 'zero'.
Output:
X Array containing computed restoration.
alpha Regularization parameter used to construct restoration."""
#
# compute the center of the PSF if it is not provided
#
if center is None:
center = array(PSF.shape) / 2
#
# if PSF is smaller than B, pad it to the same size as B
#
if PSF.size < B.size:
PSF = padarray(PSF, array(B.shape) - array(PSF.shape),
direction='post')
#
# First compute the Kronecker product terms, Ar and Ac, where
# the blurring matrix A = kron(Ar, Ac).
# Note that if the PSF is not separable, this
# step computes a Kronecker product approximation to A.
#
Ar, Ac = kronDecomp(PSF, center, BC)
#
# Compute SVD of the blurring matrix.
#
Ur, sr, Vr = svd(Ar)
Uc, sc, Vc = svd(Ac)
bhat = dot( dot(Uc.transpose(), B), Ur )
bhat = bhat.flatten('f')
s = kron(matrix(sr),matrix(sc))
s = array(s.flatten('f'))
#
# If a regularization parameter is not given, use GCV to find one.
#
if alpha is None:
alpha = gcv_tik(s, bhat)
#
# Compute the Tikhonov regularized solution.
#
D = abs(s)**2 + abs(alpha)**2
bhat = s * bhat
xhat = bhat / D
xhat = reshape(xhat, shape(B))
xhat = xhat.transpose()
X = dot( dot(Vc.transpose(),xhat), Vr)
return X, alpha
def liouville(self):
self.l_vibronic = self.kisc * (-0.5*(np.kron((self.pro_sing+self.t0_t0),self.iden4) + np.kron(self.iden4,np.transpose(self.pro_sing+self.t0_t0)))+np.kron(self.s_t0,np.transpose(self.t0_s))+np.kron(self.t0_s,np.transpose(self.s_t0))-0.5*(np.kron((self.pro_sing+self.tplus_tplus),self.iden4) + np.kron(self.iden4,np.transpose(self.pro_sing+self.tplus_tplus)))+np.kron(self.s_tplus,np.transpose(self.tplus_s))+np.kron(self.tplus_s,np.transpose(self.s_tplus))-0.5*(np.kron((self.pro_sing+self.tminus_tminus),self.iden4) + np.kron(self.iden4,np.transpose(self.pro_sing+self.tminus_tminus)))+np.kron(self.s_tminus,np.transpose(self.tminus_s))+np.kron(self.tminus_s,np.transpose(self.s_tminus)))
self.ltot = la.kron((-1j*self.hamiltonian-self.haberkorn),self.iden4) + la.kron(self.iden4,np.transpose(+1j*self.hamiltonian-self.haberkorn)) - self.kstd*(la.kron(self.pro_trip,np.transpose(self.pro_sing))+la.kron(self.pro_sing,np.transpose(self.pro_trip))) + self.l_vibronic
return
def _Cry(sig_r, sig_s, sig_i, rho1, rho2, rho3, **kwargs): cov_FP = get_cov_FP2(sig_r, sig_s, sig_i, rho1, rho2, rho3) # 3x3 v = cov_FP[1:3,0].reshape(-1, 1) # shape = (2,1) return linalg.kron(v, np.eye(self.N))
def _Cyy(sig_r, sig_s, sig_i, rho1, rho2, rho3, **kwargs): cov_FP = get_cov_FP2(sig_r, sig_s, sig_i, rho1, rho2, rho3) # 3x3 return linalg.kron(cov_FP[1:3,1:3], np.eye(self.N))
# Storage for cost
Jt = zeros((3, res))
# Storage for cost
th[:] = th_r[:]
# reset parameters
# Get noise and simulate system (generate training data)
W = Noise(dt, T, 1, 1, 3, pd, [], [s * dt], seed)
w_tmp = W.getNoise()[1]
w[:, :] = w_tmp[0:2, :]
v[:, :] = w_tmp[2, :]
x, y = S.sim([0, 0], u, w, v)
# Generalize Model for predictions, derivatives and history
M_t = generalize(M, p, DTCM('GF', p, s))[0]
D = kron(eye(p, p, 1), eye(2))
# Generalize in- and output signals;
u_t = zeros((p * M.nu, N))
x_t = zeros((p * M.nx, N))
y_t = zeros((p * M.ny, N))
# Generalized signals (predictions)
for i in range(0, p):
u_t[M.nu * i:M.nu * (i + 1), 0:N - i] = u[:, i:N]
x_t[M.nx * i:M.nx * (i + 1), 0:N - i] = x[:, i:N]
y_t[M.ny * i:M.ny * (i + 1), 0:N - i] = y[:, i:N]
# Fetch Timer
Tim = Timer('Running cost estimates for case 5/16', 0, 3 * res, 3 * res)
def solvingStuffForPQRS(AA, BB, CC, DD, FF, GG, HH, JJ, KK, LL, MM, NN):
"""
Solves for P,Q,R, and S in Uhlig's paper on DSGE models.
P is found by solving the Matrix quadratic question. Note that
solutions may not be unique.
Special Case: FP^2+GP+H=0
General Case: ____________
Q is found using Kronkier products.
Special Case: FQN+(FP+G)Q+LN+M=0
General Case: ___________________
R,S are found only if Jump variables are included; otherwise,
they are returned as matrices of size 0 by ________.
R = -inv(C)*(AP+B)
S = -inv(C)*(AQ+D)
Note: C is assumed to be of full rank and thus invertable
Returns P,Q,R,S
"""
q_eqns = sp.shape(FF)[0]
m_states = sp.shape(FF)[1]
l_equ = sp.shape(CC)[0]
if l_equ == 0:
n_endog = 0
else:
n_endog = sp.shape(CC)[1]
k_exog = min(sp.shape(sp.mat(NN))[0], sp.shape(sp.mat(NN))[1])
if l_equ == 0:
PP, Diff = solve_P(FF, GG, HH)
PP = sp.real(PP)
else:
Cinv = la.inv(CC)
Fprime = FF - sp.dot(sp.dot(JJ, Cinv), AA)
Gprime = -(sp.dot(sp.dot(JJ, Cinv), BB) - GG + sp.dot(sp.dot(KK, Cinv), AA))
Hprime = -sp.dot(sp.dot(KK, Cinv), BB) + HH
PP, Diff = solve_P(Fprime, Gprime, Hprime)
PP = sp.real(PP)
# solve for QRS
if l_equ == 0:
RR = sp.zeros((0, m_states))
Left = FF
Right = sp.dot(FF, PP) + GG
VV = (la.kron(NN.T, Left)) + la.kron(sp.eye(k_exog), Right)
else:
RR = sp.dot(-Cinv, (sp.dot(AA, PP) + BB))
Left = FF - sp.dot(sp.dot(JJ, Cinv), AA)
Right = sp.dot(JJ, RR) + sp.dot(FF, PP) + G - sp.dot(sp.dot(KK, Cinv), AA)
VV = (la.kron(NN.T, Left)) + la.kron(sp.eye(k_exog), Right)
if False and (npla.matrix_rank(VV) < k_exog * (m_states + n_endog)):
print ("Sorry but V is note invertible. Can't solve for Q and S")
else:
if l_equ == 0:
Vector = (sp.dot(LL, NN) + MM).flatten()
QQSS_vec = sp.dot(la.inv(VV), Vector)
QQSS_vec = -QQSS_vec
else:
Vector = (sp.dot((sp.dot(sp.dot(JJ, Cinv), DD) - LL), NN) + sp.dot(sp.dot(KK, Cinv), DD) - MM).flatten()
QQSS_vec = sp.dot(la.inv(VV), Vector)
QQSS_vec = -QQSS_vec
QQ = sp.reshape(QQSS_vec, (m_states, k_exog))
if l_equ == 0:
SS = sp.zeros((0, 2))
else:
SS = sp.dot(-Cinv, (sp.dot(AA, QQ) + DD))
return PP, QQ, RR, SS
def formation(self):
'''
formation control algorithm
'''
ready = True
for rc in self.rotorcrafts:
if not rc.initialized:
if self.verbose:
print("Waiting for state of rotorcraft ", rc.id)
sys.stdout.flush()
ready = False
if rc.timeout > 0.5:
if self.verbose:
print("The state msg of rotorcraft ", rc.id, " stopped")
sys.stdout.flush()
ready = False
if rc.initialized and 'geo_fence' in self.config.keys():
geo_fence = self.config['geo_fence']
if not self.ignore_geo_fence:
if (rc.X[0] < geo_fence['x_min'] or rc.X[0] > geo_fence['x_max']
or rc.X[1] < geo_fence['y_min'] or rc.X[1] > geo_fence['y_max']
or rc.X[2] < geo_fence['z_min'] or rc.X[2] > geo_fence['z_max']):
if self.verbose:
print("The rotorcraft", rc.id, " is out of the fence (", rc.X, ", ", geo_fence, ")")
sys.stdout.flush()
ready = False
if not ready:
return
dim = 2 * len(self.rotorcrafts)
X = np.zeros(dim)
V = np.zeros(dim)
U = np.zeros(dim)
i = 0
for rc in self.rotorcrafts:
X[i] = rc.X[0]
X[i+1] = rc.X[1]
V[i] = rc.V[0]
V[i+1] = rc.V[1]
i = i + 2
Bb = la.kron(self.B, np.eye(2))
Z = Bb.T.dot(X)
Dz = rf.make_Dz(Z, 2)
Dzt = rf.make_Dzt(Z, 2, 1)
Dztstar = rf.make_Dztstar(self.d * self.scale, 2, 1)
Zh = rf.make_Zh(Z, 2)
E = rf.make_E(Z, self.d * self.scale, 2, 1)
# Shape and motion control
jmu_t1 = self.joystick.trans * self.t1[0,:]
jtilde_mu_t1 = self.joystick.trans * self.t1[1,:]
jmu_r1 = self.joystick.rot * self.r1[0,:]
jtilde_mu_r1 = self.joystick.rot * self.r1[1,:]
jmu_t2 = self.joystick.trans2 * self.t2[0,:]
jtilde_mu_t2 = self.joystick.trans2 * self.t2[1,:]
jmu_r2 = self.joystick.rot2 * self.r2[0,:]
jtilde_mu_r2 = self.joystick.rot2 * self.r2[1,:]
Avt1 = rf.make_Av(self.B, jmu_t1, jtilde_mu_t1)
Avt1b = la.kron(Avt1, np.eye(2))
Avr1 = rf.make_Av(self.B, jmu_r1, jtilde_mu_r1)
Avr1b = la.kron(Avr1, np.eye(2))
Avt2 = rf.make_Av(self.B, jmu_t2, jtilde_mu_t2)
Avt2b = la.kron(Avt2, np.eye(2))
Avr2 = rf.make_Av(self.B, jmu_r2, jtilde_mu_r2)
Avr2b = la.kron(Avr2, np.eye(2))
Avb = Avt1b + Avr1b + Avt2b + Avr2b
Avr = Avr1 + Avr2
if self.B.size == 2:
Zhr = np.array([-Zh[1],Zh[0]])
U = -self.k[1]*V - self.k[0]*Bb.dot(Dz).dot(Dzt).dot(E) + self.k[1]*(Avt1b.dot(Zh) + Avt2b.dot(Zhr)) + np.sign(jmu_r1[0])*la.kron(Avr1.dot(Dztstar).dot(self.B.T).dot(Avr1), np.eye(2)).dot(Zhr)
else:
U = -self.k[1]*V - self.k[0]*Bb.dot(Dz).dot(Dzt).dot(E) + self.k[1]*Avb.dot(Zh) + la.kron(Avr.dot(Dztstar).dot(self.B.T).dot(Avr), np.eye(2)).dot(Zh)
if self.verbose:
#print "Positions: " + str(X).replace('[','').replace(']','')
#print "Velocities: " + str(V).replace('[','').replace(']','')
#print "Acceleration command: " + str(U).replace('[','').replace(']','')
print "Error distances: " + str(E).replace('[','').replace(']','')
sys.stdout.flush()
i = 0
for ac in self.rotorcrafts:
msg = PprzMessage("datalink", "DESIRED_SETPOINT")
msg['ac_id'] = ac.id
msg['flag'] = 0 # full 3D not supported yet
msg['ux'] = U[i]
msg['uy'] = U[i+1]
msg['uz'] = self.altitude
self._interface.send(msg)
i = i+2
def inference(self, kern, likelihood, mean_function = None,W=None, Y_metadata=None,precision = None):
"""
Not sure about kronmagic yet
"""
"""
Not sure about design of kern yet.
Needs to contain something like "is_toeplitz" per grid dimension
and has to provide p different Kernel-matrices (p = #grid dimensions)
????? Do we even need partial grids for MSGP????? Probably not
TO-DO: Incomplete grids:
The M-matrix is usually used to lift incomplete grid information
to a complete grid (y-values only for parts of the grid)
"""
if not isinstance(likelihood,likelihoods.Gaussian):
raise NotImplementedError("Not sure what todo if likelihood is non-gaussian")
if kern.name != 'kern_grid':
raise ValueError("kernel type has to be kern_grid")
Z = kern.Z
X = kern.X
Y = kern.Y
W_x_z = kern.W_x_z
kronmagic = False
if mean_function is None:
m = 0
else:
m = mean_function.f(X)
if precision is None:
precision = likelihood.gaussian_variance()
p = len(Z)
n_grid = 1
n_data = np.shape(Y)[0]
D=0
for i in range(p):
n_grid=n_grid*np.shape(Z[i])[0]
D = D+np.shape(Z[i])[1]
K = kern.get_K_Z()
is_toeplitz = kern.get_toeplitz_dims()
#xe = np.dot(M,xe)
#n=np.shape(xe)[1]
for j in range(len(K)):
if is_toeplitz[i] == True:
K[j] = linalg.toeplitz(K[j])
sn2 = np.exp(2*precision)
V = []
E = []
#with Timer() as t:
for j in range(len(K)):
if is_toeplitz[i] == True:
V_j,E_j = msgp_linalg.eigr(linalg.toeplitz(K[j]))
else:
V_j,E_j = msgp_linalg.eigr(K[j])
V.append(np.matrix(V_j))
E.append(np.matrix(E_j))#
#print("Runtime eigendecomposition: {}".format(t.secs))
e = np.ones((1,1))
for ii in range(len(E)):
e = linalg.kron(np.matrix(np.diag(E[ii])).T,e)
e = np.ravel(e.astype(float))
if kronmagic:
"""
Problem: here we would need the eigendecomposition of the kernel
matrices. We would need to get those from the kernels.
"""
raise NotImplementedError
#s = 1/(e+sn2)
#order = range(1,N)
else:
sort_index = np.argsort(e)
sort_index = sort_index[::-1]
sort_index = np.ravel(sort_index)
eord = e[sort_index]
"""
if n<N: ##We dont need this here <- only for partial grid structure
eord = np.vstack((eord,np.zeros((n-N),1)))
order = np.vstack((order,range(N+1,n).T))
"""
s = 1./((float(n_data)/float(n_grid))*eord[0:n_data]+sn2)
if kronmagic:
## infGrid.m line 61
raise NotImplementedError
else:
kron_mvm_func = lambda x: msgp_linalg.mvm_K(x,K,sn2,W_x_z)
shape_mvm = (n_data,n_data) ## To-Do: what is the shape of the mvm?
L = lambda x: -msgp_linalg.solveMVM(x,kron_mvm_func,shape_mvm,cgtol = 1e-6,cgmit=1000) # ein - zuviel?
alpha = -L(Y-m)
lda = -np.sum(np.log(s))
#lda_exact = sum(np.log(np.diag(linalg.cholesky(W_x_z.dot(W_x_z.dot(msgp_linalg.kronmvm(K,np.eye(n_grid))).T).T+sn2*np.eye(n_data)))));
#lda = lda_exact
#log_marginal = np.dot((Y-m).T,alpha)/2 + n_data*np.log(2*np.pi)/2 + lda/2
#print("model fit: {}".format(np.dot((Y-m).T,alpha)/2))
#print("complexity: {}".format(lda/2))
#print("complexity exact: {}".format(lda_exact))
log_marginal = (np.dot((Y-m).T,alpha)/2 + n_data*np.log(2*np.pi)/2 + lda/2) *(-1)
#print(log_marginal)
#print(alpha)
#print(W_x_z.T)
#print(np.max(K[0]))
#alpha_pred = msgp_linalg.kronmvm(K,W_x_z.T.dot(alpha)) # we need the term K_Z_Z*W.T*alpha for the predictive mean
"""
Calculate the nu-term for predictive variance
TO-DO: not sure if the K_tilde kronmvm is correct
"""
grad_dict = dict()
grad_dict["V"] = V
grad_dict["E"] = E
grad_dict["S"] = dict()
grad_dict["S"]["s"] = s
grad_dict["S"]["eord"] = eord
grad_dict["S"]["sort_index"] = sort_index
post = dict()
post["alpha"] = alpha
return post, log_marginal, grad_dict
def __discretize(T, dt, method, PrewarpAt, q):
"""
Actually, I think that presenting this topic as a numerical
integration problem is confusing more than it explains. Most
items here can be presented as conformal mappings and nobody
needs to be limited to riemann sums of particular shape. As
I found that scipy version of this, adopts Zhang SICON 2007
parametrization which surprisingly fresh!
Here I "generalized" to any rational function representation
if you are into that mathematician lingo (see the 'fancy'
ASCII art below). I used LFTs instead, for all real rational
approx. mappings (for whoever wants to follow that rabbit).
"""
m, n = T.shape[1], T.NumberOfStates
if method == 'zoh':
"""
Zero-order hold is not much useful for linear systems and
in fact it should be discouraged since control problems
don't have boundary conditions as in stongly nonlinear
FEM simulations of CFDs so on. Most importantly it is not
stability-invariant which defeats its purpose. But whatever
This conversion is usually done via the expm() identity
[A | B] [ exp(A) | int(exp(A))*B ] [ Ad | Bd ]
expm[- - -] = [------------------------] = [---------]
[0 | 0] [ 0 | I ] [ C | D ]
"""
M = np.r_[np.c_[T.a, T.b], np.zeros((m, m + n))]
eM = expm(M * dt)
Ad, Bd, Cd, Dd = eM[:n, :n], eM[:n, n:], T.c, T.d
elif method == 'lft':
"""
Here we form the following star product
_
--------- |
| 1 | |
---| --- I |<-- |
| | z | | |
| --------- | |
| | |> this is the lft of (1/s)*I
| ------- | |
--->| |---- |
| q | |
--->| |---- |
| ------- | _|
| |
| ------- |
----| |<--|
| T |
<---| |<---
-------
Here q is whatever the rational mapping that links s to z in
the following sense:
1 1 1 1
--- = F_u(---,q) = q_22 + q_21 --- (I - --- q_11)⁻¹ q12
s z z z
where F_u denotes the upper linear fractional representation.
As an example, for the usual discretization cases, the map is
[ I | sqrt(T)*I ]
Q = [-----------|------------]
[ sqrt(T)*I | T*α*I ]
with α defined as in Zhang 2007 SICON.
α = 0 --> backward diff, (backward euler)
α = 0.5 --> Tustin,
α = 1 --> forward difference (forward euler)
"""
# TODO: Check if interconnection is well-posed !!!!
if q is None:
raise ValueError('\"lft\" method requires an interconnection '
'matrix \"q" between s and z variables.')
# Copy n times for n integrators
q11, q12, q21, q22 = (kron(np.eye(n), x)
for x in matrix_slice(q, (-1, -1)))
# Compute the star product
ZAinv = solve(np.eye(n) - q22.dot(T.a), q21)
AZinv = solve(np.eye(n) - T.a.dot(q22), T.b)
Ad = q11 + q12.dot(T.a.dot(ZAinv))
Bd = q12.dot(AZinv)
Cd = T.c.dot(ZAinv)
Dd = T.d + T.c.dot(q22.dot(AZinv))
elif method in ('bilinear', 'tustin', 'trapezoidal'):
if not PrewarpAt == 0.:
if 1 / (2 * dt) < PrewarpAt:
raise ValueError('Prewarping Frequency is beyond the Nyquist'
' rate. It has to satisfy 0 < w < 1/(2*Δt)'
' and Δt being the sampling period in '
'seconds. Δt={0} is given, hence the max.'
' allowed is {1} Hz.'.format(
dt, 1 / (2 * dt)))
TwoTanw_Over_w = np.tan(
2 * np.pi * PrewarpAt * dt / 2) / (2 * np.pi * PrewarpAt)
q = np.array([[1, np.sqrt(2 * TwoTanw_Over_w)],
[np.sqrt(2 * TwoTanw_Over_w), TwoTanw_Over_w]])
else:
q = np.array([[1, np.sqrt(dt)], [np.sqrt(dt), dt / 2]])
return __discretize(T, dt, "lft", 0., q)
elif method in ('forward euler', 'forward difference',
'forward rectangular', '>>'):
return __discretize(T,
dt,
"lft",
0,
q=np.array([[1, np.sqrt(dt)], [np.sqrt(dt), 0]]))
elif method in ('backward euler', 'backward difference',
'backward rectangular', '<<'):
return __discretize(T,
dt,
"lft",
0,
q=np.array([[1, np.sqrt(dt)], [np.sqrt(dt), dt]]))
else:
raise ValueError('I don\'t know that discretization method. But '
'I know {0} methods.'
''.format(_KnownDiscretizationMethods))
return Ad, Bd, Cd, Dd, dt
def periodic(self, f0, f_amp, fdofs):
"""Find periodic solution
NR iteration to solve:
# Solve h(z,ω)=A(ω)-b(z)=0 (ie find z that is root of this eq), eq. (21)
# NR solution: (h_z is the derivative of h wrt z)
# zⁱ⁺¹ = zⁱ - h(zⁱ,ω)/h_z(zⁱ,ω)
# h_z = A(ω) - b_z(z) = A - Γ⁺ ∂f/∂x Γ
# where the last exp. is in time domain. df/dx is thus available
# analytical. See eq (30)
Parameters
----------
f0: float
Forcing frequency in Hz
f_amp: float
Forcing amplitude
"""
self.f0 = f0
self.f_amp = f_amp
self.fdofs = fdofs
nu = self.nu
NH = self.NH
n = self.n
nz = self.nz
scale_x = self.scale_x
scale_t = self.scale_t
amp0 = self.amp0
stability = self.stability
tol_NR = self.tol_NR
max_it_NR = self.max_it_NR
w0 = f0 * 2*np.pi
omega = w0*scale_t
omega2 = omega / nu
t = self.assemblet(omega2)
nt = len(t)
u, _ = sineForce(f_amp, omega=omega, t=t)
force = toMDOF(u, n, fdofs)
# Assemble A, describing the linear dynamics. eq (20)
A = self.assembleA(omega2)
# Form Q(t), eq (8). Q is orthogonal trigonometric basis(harmonic
# terms) Then use Q to from the kron product Q(t) ⊗ Iₙ, eq (6)
mat_func_form = np.empty((n*nt, nz))
Q = np.empty((NH*2+1, 1))
for i in range(nt):
Q[0] = 1
for ii in range(1, NH+1):
Q[ii*2-1] = np.sin(omega * t[i]*ii)
Q[ii*2] = np.cos(omega * t[i]*ii)
# Stack the kron prod, so each block row is for time(i)
mat_func_form[i*n:(i+1)*n, :] = kron(Q.T, np.eye(n))
self.mat_func_form_sparse = csr_matrix(mat_func_form)
if stability:
hills = Hills(self)
self.hills = hills
# Initial guess for x. Here calculated by broadcasting. np.outer could
# be used instead to calculate the outer product
amp = np.ones(n)*amp0
x_guess = amp[:, None] * np.sin(omega * t)/scale_x
# Initial guess for z, z = Γ⁺x as given by eq (26). Γ is found as
# Q(t)⊗Iₙ, eq 6
# TODO use mat_func_form_sparse
z_guess, *_ = lstsq(mat_func_form, x_guess.ravel())
# Solve h(z,ω)=A(ω)-b(z)=0 (ie find z-root), eq. (21)
print('Newton-Raphson iterative solution')
Obj = 1
it_NR = 1
z = z_guess
while (Obj > tol_NR) and (it_NR <= max_it_NR):
H = self.state_sys(z, A, force)
H_z = self.hjac(z, A)
zsol, *_ = lstsq(H_z, H)
z = z - zsol
Obj = norm(H) / norm(z)
print('It. {} - Convergence test: {:e} ({:e})'.
format(it_NR, Obj, tol_NR))
it_NR = it_NR + 1
if it_NR > max_it_NR:
raise ValueError("Number of NR iterations exceeded {}."
" Change Harmonic Balance parameters".
format(max_it_NR))
if stability:
B = hills.stability(omega, H_z)
B_tilde, stab = hills.reduc(B)
self.stab_vec.append(stab)
self.lamb_vec.append(B_tilde)
# amplitude of hb components
c, cnorm, phi = hb_components(scale_x*z, n, NH)
x = hb_signal(omega, t, c, phi)
xamp = np.max(x, axis=1)
self.z_vec.append(z)
self.xamp_vec.append(xamp)
self.omega_vec.append(omega)
if stability:
return omega, z, stab, B
else:
return omega, z
# +
# set inputs
m_X = array([[-0.5], [1]]) # expectation of target variable X
s2_X = array([[1, .1], [.1, .2]]) # covariance of target variable X
beta = array([[1], [1]]) # loadings
n_ = m_X.shape[0] # target dimension
k_ = beta.shape[1] # number of factors
i_n = eye(n_)
i_k = eye(k_)
km = zeros((k_ * n_, k_ * n_)) # commutation matrix
for n in range(n_):
for k in range(k_):
km = km + kron(i_k[:, [k]] @ i_n[:, [n]].T,
i_n[:, [n]] @ i_k[:, [k]].T)
# set inputs for quadratic programming problem
invsigma2 = np.diagflat(1 / diag(s2_X))
pos = beta.T @ invsigma2 @ s2_X
g = -pos.flatten()
q = kron(s2_X, beta.T @ invsigma2 @ beta)
q_, _ = q.shape
# linear constraints
v = array([[-1, 1]])
d_eq = kron(i_k, v @ s2_X) @ km
b_eq = zeros((k_**2, 1))
# compute extraction matrix
# options = optimoptions(('quadprog','MaxIter.T, 2000, .TAlgorithm','interior-point-convex'))
def PortfolioMomentsLogN(v_tnow, h, LogN_loc, LogN_disp):
# This function computes the expectation, the standard deviation and the skewness
# of a portfolio's P&L which is lognormally distributed.
# INPUTS
# v_tnow : [vector] (n_ x 1) current values of the instruments
# h : [vector] (n_ x 1) portfolio's holdings
# LogN_loc : [vector] (n_ x 1) location parameter of the instruments lognormal distribution at the horizon
# LogN_disp : [vector] (n_ x n_) dispersion parameter of the instruments lognormal distribution at the horizon
# OPS
# muPL_h : [scalar] expectation of the portfolio's P&L
# sdPL_h : [scalar] standard deviation of the portfolio's P&L
# skPL_h : [scalar] skewness of the portfolio's P&L
# portfolio's P&L expectation
muV_thor = exp(
LogN_loc + 1 / 2 * diag(LogN_disp).reshape(-1, 1)
) # expectation of the portfolio's instruments at the horizon
muPL = muV_thor - v_tnow # expectation of one unit of the portfolio's P&L
muPL_h = h.T @ muPL # portfolio's P&L expectation
n_ = v_tnow.shape[0]
d = eye(n_) # canonical basis
noncent2ndPL = zeros((n_, n_))
noncent3rdPL = zeros((n_ * n_ * n_, 1))
cent2ndPL = zeros((n_, n_))
cent3rdPL = zeros((n_ * n_ * n_, 1))
i = 0
for n in range(n_):
for m in range(n_):
omega_nm = d[:, n] + d[:, m]
# second non-central moments
noncent2ndV_thor_nm = exp(omega_nm.T @ LogN_loc + 1 / 2 *
omega_nm.T @ LogN_disp @ omega_nm)
noncent2ndPL[n, m] = noncent2ndV_thor_nm - muV_thor[n] * v_tnow[
m] - muV_thor[m] * v_tnow[n] + v_tnow[m] * v_tnow[n]
# second central moment
cent2ndPL[n, m] = noncent2ndPL[n, m] - muPL[n] * muPL[m]
for l in range(n_):
omega_nl = d[:, n] + d[:, l]
omega_ml = d[:, m] + d[:, l]
omega_nml = d[:, n] + d[:, m] + d[:, l]
# second non-central moments that enter in the third non-central moments formulas
noncent2ndV_thor_nl = exp(omega_nl.T @ LogN_loc + 1 / 2 *
omega_nl.T @ LogN_disp @ omega_nl)
noncent2ndV_thor_ml = exp(omega_ml.T @ LogN_loc + 1 / 2 *
omega_ml.T @ LogN_disp @ omega_ml)
# third non-central moments
noncent3rdV_thor_nml = exp(omega_nml.T @ LogN_loc + 1 / 2 *
omega_nml.T @ LogN_disp @ omega_nml)
noncent3rdPL[i] = noncent3rdV_thor_nml - noncent2ndV_thor_nm*v_tnow[l] - noncent2ndV_thor_nl*v_tnow[m]+\
muV_thor[n]*v_tnow[m]*v_tnow[l] - noncent2ndV_thor_ml*v_tnow[n] +\
muV_thor[m]*v_tnow[n]*v_tnow[l] + muV_thor[l]*v_tnow[n]*v_tnow[m] -\
v_tnow[m]*v_tnow[n]*v_tnow[l]
# third central moment
cent3rdPL[i] = noncent3rdPL[i] - noncent2ndPL[n,m]*muPL[l] - noncent2ndPL[n,l]*muPL[m] -\
muPL[n]*noncent2ndPL[m,l] + 2*muPL[n]*muPL[m]*muPL[l]
i = i + 1
sdPL_h = sqrt(h.T @ cent2ndPL @ h) # portfolio's P&L standard deviation
dummy = kron(h, h) @ h.T
vec_h = dummy.flatten()
skPL_h = (vec_h.T @ cent3rdPL) / (sdPL_h**3) # portfolio's P&L skewness
return muPL_h, sdPL_h, skPL_h
def tsvd_sep(B, PSF, center=None, tol=None, BC='zero'):
"""TSVD_SEP Truncated SVD image deblurring using Kronecker decomposition.
X, tol = tsvd_sep(B, PSF, center, tol, BC)
Compute restoration using a Kronecker product decomposition and
a truncated SVD.
Input:
B Array containing blurred image.
PSF Array containing the point spread function.
Optional Inputs:
center [row, col] = indices of center of PSF.
tol Regularization parameter (truncation tolerance).
Default parameter chosen by generalized cross validation.
BC String indicating boundary condition.
('zero', 'reflexive', or 'periodic'; default is 'zero'.)
Output:
X Array containing computed restoration.
tol Regularization parameter used to construct restoration."""
#
# compute the center of the PSF if it is not provided
#
if center is None:
center = array(PSF.shape) / 2
#
# if PSF is smaller than B, pad it to the same size as B
#
if PSF.size < B.size:
PSF = padarray(PSF, array(B.shape) - array(PSF.shape),
direction='post')
#
# First compute the Kronecker product terms, Ar and Ac, where
# A = kron(Ar, Ac). Note that if the PSF is not separable, this
# step computes a Kronecker product approximation to A.
#
Ar, Ac = kronDecomp(PSF, center, BC)
#
# Compute SVD of the blurring matrix.
#
Ur, sr, Vr = svd(Ar)
Uc, sc, Vc = svd(Ac)
bhat = dot( dot( Uc.transpose(), B ), Ur )
bhat = bhat.flatten('f')
s = kron(matrix(sr),matrix(sc))
s = array(s.flatten('f'))
#
# If a regularization parameter is not given, use GCV to find one.
#
if tol is None:
tol = gcv_tsvd( s, bhat.flatten('f') )
#
# Compute the TSVD regularized solution.
#
idx = where(abs(s) >= tol)
Sfilt = zeros(shape(bhat),'d')
Sfilt[idx] = 1 / s[idx]
Bhat = reshape(bhat * Sfilt , shape(B))
Bhat = Bhat.transpose()
X = dot( dot(Vc.transpose(),Bhat), Vr )
return X, tol
def Hhfs(L,S,I):
"""Provides the I dot J matrix (magnetic dipole interaction)"""
gS=int(2*S+1)
Sx=jx(S)
Sy=jy(S)
Sz=jz(S)
Si=identity(gS)
gL=int(2*L+1)
Lx=jx(L)
Ly=jy(L)
Lz=jz(L)
Li=identity(gL)
gJ=gL*gS
Jx=kron(Lx,Si)+kron(Li,Sx)
Jy=kron(Ly,Si)+kron(Li,Sy)
Jz=kron(Lz,Si)+kron(Li,Sz)
Ji=identity(gJ)
J2=dot(Jx,Jx)+dot(Jy,Jy)+dot(Jz,Jz)
gI=int(2*I+1)
gF=gJ*gI
Ix=jx(I)
Iy=jy(I)
Iz=jz(I)
Ii=identity(gI)
Fx=kron(Jx,Ii)+kron(Ji,Ix)
Fy=kron(Jy,Ii)+kron(Ji,Iy)
Fz=kron(Jz,Ii)+kron(Ji,Iz)
Fi=identity(gF)
F2=dot(Fx,Fx)+dot(Fy,Fy)+dot(Fz,Fz)
Hhfs=0.5*(F2-I*(I+1)*Fi-kron(J2,Ii))
return Hhfs
def unbalance_emai(y,
xmat,
zmat,
kin,
init=None,
maxiter=30,
cc_par=1.0e-8,
cc_gra=1.0e-6,
em_weight_step=0.001):
num_var_pos = 1
for i in range(len(zmat)):
num_var_pos += len(zmat[i])
y_var = np.var(y) / num_var_pos
num_record = y.shape[0]
var_com = []
eff_ind = [[0, xmat.shape[1]]] # the index for all effects [start end]
zmat_con_lst = [] # combined random matrix
cov_dim = [] # the dim for covariance matrix
vari = []
varij = []
varik = []
i = 0
for i in range(len(zmat)):
temp = [eff_ind[i][-1]]
zmat_con_lst.append(hstack(zmat[i]))
cov_dim.append(len(zmat[i]))
for j in range(len(zmat[i])):
temp.append(temp[-1] + zmat[i][j].shape[1])
for k in range(j + 1):
vari.append(i + 1)
varij.append(j + 1)
varik.append(k + 1)
if j == k:
var_com.append(y_var)
else:
var_com.append(0.0)
eff_ind.append(temp)
var_com.append(y_var)
vari.append(i + 2)
varij.append(1)
varik.append(1)
if init is None:
var_com = np.array(var_com)
else:
if len(var_com) != len(init):
logging.info('ERROR: The length of initial variances should be' +
len(var_com))
exit()
else:
var_com = np.array(init)
var_com_update = np.array(var_com)
logging.info('***prepare the MME**')
zmat_con = hstack(zmat_con_lst) # design matrix for random effects
wmat = hstack([xmat, zmat_con]) # merged design matrix
cmat_pure = np.dot(wmat.T, wmat) # C matrix
rhs_pure = wmat.T.dot(y) # right hand
# em weight vector
if em_weight_step <= 0.0 or em_weight_step > 1.0:
logging.info(
'ERROR: The em weight step should be between 0 (not include) and 1 (include)'
)
exit()
iter_count = 0
cc_par_val = 1000.0
cc_gra_val = 1000.0
delta = 1000.0
logging.info("initial variances: " +
' '.join(np.array(var_com, dtype=str)))
covi_mat = pre_covi_mat(cov_dim, var_com)
if covi_mat is None:
logging.inf(
"ERROR: Initial variances is not positive define, please check!")
exit()
while iter_count < maxiter:
iter_count += 1
logging.info('***Start the iteration: ' + str(iter_count) + ' ***')
logging.info("Prepare the coefficient matrix")
cmat = (cmat_pure.multiply(1.0 / var_com[-1])).toarray()
for i in range(len(cov_dim)):
if isspmatrix(kin[i]):
temp = sparse.kron(covi_mat[i], kin[i])
temp = temp.toarray()
else:
temp = linalg.kron(covi_mat[i], kin[i])
cmat[eff_ind[i + 1][0]:eff_ind[i + 1][-1], \
eff_ind[i + 1][0]:eff_ind[i + 1][-1]] = \
np.add(cmat[eff_ind[i + 1][0]:eff_ind[i + 1][-1], \
eff_ind[i + 1][0]:eff_ind[i + 1][-1]], temp)
rhs_mat = np.divide(rhs_pure, var_com[-1])
cmati = linalg.inv(cmat)
eff = np.dot(cmati, rhs_mat)
e = y - xmat.dot(eff[:eff_ind[0][1], :]) - zmat_con.dot(
eff[eff_ind[0][1]:, :])
# first-order derivative
fd_mat = pre_fd_mat_x(cmati, kin, covi_mat, eff, eff_ind, e, cov_dim,
zmat_con_lst, wmat, num_record, var_com)
# AI matrix
ai_mat = pre_ai_mat(cmati, covi_mat, eff, eff_ind, e, cov_dim,
zmat_con_lst, wmat, var_com)
# EM matrix
em_mat = pre_em_mat(cov_dim, zmat_con_lst, num_record, var_com)
# Increase em weight to guarantee variances positive
gamma = -em_weight_step
while gamma < 1.0:
gamma = gamma + em_weight_step
if gamma >= 1.0:
gamma = 1.0
wemai_mat = (1 - gamma) * ai_mat + gamma * em_mat
delta = np.dot(linalg.inv(wemai_mat), fd_mat)
var_com_update = var_com + delta
covi_mat = pre_covi_mat(cov_dim, var_com_update)
if covi_mat is not None:
logging.info('EM weight value: ' + str(gamma))
break
logging.info('Updated variances: ' +
' '.join(np.array(var_com_update, dtype=str)))
if covi_mat is None:
logging.info("ERROR: Updated variances is not positive define!")
exit()
# Convergence criteria
cc_par_val = np.sum(pow(delta, 2)) / np.sum(pow(var_com_update, 2))
cc_par_val = np.sqrt(cc_par_val)
cc_gra_val = np.sqrt(np.sum(pow(fd_mat, 2))) / len(var_com)
var_com = var_com_update.copy()
logging.info("Change in parameters, Norm of gradient vector: " +
str(cc_par_val) + ', ' + str(cc_gra_val))
if cc_par_val < cc_par and cc_gra_val < cc_gra:
break
if cc_par_val < cc_par and cc_gra_val < cc_gra:
logging.info("Variances Converged")
else:
logging.info("Variances not Converged")
var_pd = {'vari': vari, "varij": varij, "varik": varik, "var_val": var_com}
var_pd = pd.DataFrame(var_pd,
columns=['vari', "varij", "varik", "var_val"])
return var_pd
# ## Compute statistics of the joint distribution of X,Z [m_XZ, s2_XZ] = FPmeancov(r_[X, Z], p) s2_X = s2_XZ[:n_, :n_] s_XZ = s2_XZ[:n_, n_:n_ + k_] s2_Z = s2_XZ[n_:n_ + k_, n_:n_ + k_] # ## Solve generalized regression LFM # ## set inputs for quadratic programming problem # + d = np.diagflat(1 / diag(s2_X)) pos = d @ s_XZ g = -pos.flatten() q = kron(s2_Z, d) q_, _ = q.shape # set constraints a_eq = ones((1, n_ * k_)) / (n_ * k_) b_eq = array([[1]]) lb = 0.8 * ones((n_ * k_, 1)) ub = 1.2 * ones((n_ * k_, 1)) # compute optimal loadings b = quadprog(q, g, a_eq, b_eq, lb, ub) b = np.array(b) beta = reshape(b, (n_, k_), 'F') alpha = m_XZ[:n_] - beta @ m_XZ[n_:n_ + k_] # -
def __init__(self, aniso_dipolar, g1_iso, g2_iso, aniso_g1, aniso_g2,
iso_h1, iso_h2, aniso_hyperfine_1, aniso_hyperfine_2,
spin_numbers_1, spin_numbers_2, field, J, ks, kt, temp, kstd):
# declare constants and identities
self.r_perp = 16.60409997886e-10
self.r_parr = 4.9062966e-10
self.prefact = 3.92904692e-03
self.beta = 9.96973104e+01
self.c = -4.92846450e-03
#self.visc = 1.0e-3*(-0.00625*temp+2.425)
self.visc = self.prefact * np.exp(self.beta / temp) + self.c
self.convert = 1.76e8
self.d_perp = self.convert * 1.38064852e-23 * temp / (8.0 * np.pi *
self.visc *
(self.r_perp**3))
self.d_parr = self.convert * 1.38064852e-23 * temp / (8.0 * np.pi *
self.visc *
(self.r_parr**3))
self.iden2 = np.eye(2)
self.iden4 = np.eye(4)
self.iden16 = np.eye(16)
#declare matrices
self.sx = np.array([[0, 0.5], [0.5, 0]])
self.sy = np.array([[0, -0.5j], [0.5j, 0]])
self.sz = np.array([[0.5, 0], [0, -0.5]])
self.s1_x = la.kron(self.sx, self.iden2)
self.s1_y = la.kron(self.sy, self.iden2)
self.s1_z = la.kron(self.sz, self.iden2)
self.s2_x = la.kron(self.iden2, self.sx)
self.s2_y = la.kron(self.iden2, self.sy)
self.s2_z = la.kron(self.iden2, self.sz)
self.s1_s2 = la.kron(self.sx, self.sx) + la.kron(
self.sy, self.sy) + la.kron(self.sz, self.sz)
self.pro_trip = 0.75 * np.eye(4) + self.s1_s2
self.pro_sing = 0.25 * np.eye(4) - self.s1_s2
# Declare Liouvillian density operators
self.p0_lou = 0.5 * (np.reshape(self.pro_sing, (16, 1)))
self.pt_lou = np.reshape(self.pro_trip, (1, 16))
self.ps_lou = np.reshape(self.pro_sing, (1, 16))
#Declare Hamiltonian and Louivillian
self.ltot = np.zeros([16, 16], dtype=complex)
self.h0 = np.zeros([4, 4], dtype=complex)
# Declare redfield and components
self.redfield = np.zeros([16, 16], dtype=complex)
self.B = np.zeros([16, 16], dtype=complex)
# Tensor terms
self.elec = np.zeros([5, 5, 4, 4], dtype=complex)
self.uq = np.zeros([5, 4, 4], dtype=complex)
# declare class variable
self.aniso_g1 = aniso_g1
self.aniso_g2 = aniso_g2
self.g_mat = np.zeros([5], dtype=complex)
self.g1_iso = g1_iso
self.g2_iso = g2_iso
self.hyperfine_1 = aniso_hyperfine_1
self.h1_size = np.size(self.hyperfine_1[:, 0, 0])
self.h1 = np.zeros([self.h1_size, 5], dtype=complex)
self.iso_h1 = iso_h1
self.hyperfine_2 = aniso_hyperfine_2
self.h2_size = np.size(self.hyperfine_2[:, 0, 0])
self.h2 = np.zeros([self.h2_size, 5], dtype=complex)
self.iso_h2 = iso_h2
self.dipolar = aniso_dipolar
self.d_rank_2 = np.zeros([5], dtype=complex)
self.ks = ks
self.kt = kt
self.kstd = kstd
self.J_couple = J
self.omega1 = [0.0, 0.0, field]
self.omega2 = [0.0, 0.0, field]
self.n1_nuclear_spins = self.h1_size
self.n2_nuclear_spins = self.h2_size
self.spin_numbers_1 = spin_numbers_1
self.spin_numbers_2 = spin_numbers_2
# Variables for sampling SW vectors
self.angles1 = np.zeros([2, self.n1_nuclear_spins])
self.angles2 = np.zeros([2, self.n2_nuclear_spins])
self.nuc_vecs_1 = np.zeros([3, self.n1_nuclear_spins])
self.nuc_vecs_2 = np.zeros([3, self.n2_nuclear_spins])
self.omegatot_1 = np.zeros_like(self.omega1)
self.omegatot_2 = np.zeros_like(self.omega2)
self.vec_len_1 = np.sqrt(
np.multiply(self.spin_numbers_1, (self.spin_numbers_1 + 1.0)))
self.vec_len_2 = np.sqrt(
np.multiply(self.spin_numbers_2, (self.spin_numbers_2 + 1.0)))
# Haberkorn
self.Haberkorn_Matrix()
return
# ## Specify the constraint function with random parameters
# +
a = randn(m_, n_)
q = randn(m_, 1)
# set constant matrices for derivatives
i_n = eye(n_)
i_k = eye(k_)
matrix = namedtuple('matrix', 'hm km1 hm2')
matrix.hm = diag(i_n.flatten())
matrix.km1 = zeros((k_ * n_, k_ * n_**2))
matrix.hm2 = zeros((n_, n_**2))
for n in range(n_):
matrix.hm2 = matrix.hm2 + kron(i_n[:, [n]].T, diagflat(i_n[:, [n]]))
matrix.km1 = matrix.km1 + kron(kron(
i_n[:, [n]].T, i_k), diagflat(i_n[:, [n]])) # constraint function
v = lambda theta: SigNoConstrLRD(theta, a, q, n_, k_, matrix)[0]
v3 = lambda theta: SigNoConstrLRD(theta, a, q, n_, k_, matrix)[2]
# -
# ## Main computations
err = zeros((j_, 1))
for j in trange(j_, desc='Simulations'): # Set random variables
theta_ = randn(n_ + n_ * k_ + n_, 1)
# Compute numerical Hessian
for m in range(m_):
g_m = lambda theta: SigNoConstrLRD(theta, a[[m], :], q[m], n_, k_)[0]
x = np.linspace(min_x,max_x,N)
y = np.sin(x)
ddx = derivative_op(min_x,max_x,N)
dy_dx = np.dot(ddx,y)
x_mid = midpoint_op(N).dot( x )
plt.plot( x_mid , dy_dx-np.cos(x_mid) , 'r-')
plt.title('error')
plt.show()
return 0
#unit_test_derivative_op( *span_x)
#quit()
from scipy.linalg import kron
partial_x = kron( midpoint_op(Nt), derivative_op( *span_x ) )
partial_t = kron( derivative_op( *span_t ), midpoint_op(Nx) )
def unit_test_partial_t():
x = np.linspace( *span_x )
x_mid = midpoint_op(Nx).dot(x)
t = np.linspace( *span_t )
t_mid = midpoint_op(Nt).dot(t)
#consider the function x*(t**2)
f = np.kron( t**2 , x )
df_dt_computed = np.dot( partial_t , f )
df_dt_computed.resize( Nt-1,Nx-1)
df_dt = np.kron( 2*t_mid , x_mid )
df_dt.resize(Nt-1,Nx-1)
plt.subplot(2,1,1)
plt.imshow( df_dt )
gates = {'I': I, 'X': X, 'Y': Y, 'Z': Z, 'H': H, 'CNOT': CNOT, 'SWAP': SWAP}
N = 10
lim = 0.2
XX = 500
solution = [
'0100010000', '0100000000', '0100000000', '0100000100', '0000100000',
'0000000001', '0000010000', '0000000000', '0100000000', '0000000100',
'0000100000', '0000000001'
]
solution = ['0100010000', '0100000000', '0000100000', '0000000001']
s001 = basis('0000000000')
IIX = kron(
H, kron(H, kron(H, kron(H, kron(H, kron(H, kron(H, kron(H, kron(H,
H)))))))))
A0, T0 = print_wf(IIX * s001)
def uncoupled(A0, T0, nbit):
D = get_directions(nbit)
C = []
result = []
for i in range(len(D)):
C.append(0)
for j in range(len(T0)):
if T0[j] == D[i]:
C[i] = (A0[j] / A0[0])**2
result.append((1 / (1 + C[i]**2)))
result.append((C[i]**2 / (1 + C[i]**2)))
def __init__(self,aniso_dipolar,g1_iso,g2_iso,aniso_g1,aniso_g2,iso_h1,iso_h2,aniso_hyperfine_1,aniso_hyperfine_2,spin_numbers_1,spin_numbers_2,field,J,dj,ks,kt,exchange_rate,lamb,temp):
# declare constants and identities
self.r_perp = 16.65552296e-10
self.r_parr = 8.130217003e-10
self.visc = 1.0e-3*(-0.00625*temp+2.425)
self.convert = 1.0e3/1.76e-11
self.d_perp = self.convert*1.38064852e-23*temp/(8.0*np.pi*self.visc*(self.r_perp**3))
self.d_parr = self.convert*1.38064852e-23*temp/(8.0*np.pi*self.visc*(self.r_parr**3))
self.iden2 = np.eye(2)
self.iden4 = np.eye(4)
self.iden16 = np.eye(16)
#declare matrices
self.sx = np.array([[0,0.5],[0.5,0]])
self.sy = np.array([[0,-0.5j],[0.5j,0]])
self.sz = np.array([[0.5,0],[0,-0.5]])
self.s1_x = la.kron(self.sx,self.iden2)
self.s1_y = la.kron(self.sy,self.iden2)
self.s1_z = la.kron(self.sz,self.iden2)
self.s2_x = la.kron(self.iden2,self.sx)
self.s2_y = la.kron(self.iden2,self.sy)
self.s2_z = la.kron(self.iden2,self.sz)
self.s1_s2 = la.kron(self.sx,self.sx) + la.kron(self.sy,self.sy) + la.kron(self.sz,self.sz)
self.pro_trip = 0.75 * np.eye(4) + self.s1_s2
self.pro_sing = 0.25 * np.eye(4) - self.s1_s2
# Declare Liouvillian density operators
self.p0_lou = np.zeros([32,1],dtype = complex)
self.pt_lou = np.zeros([1,32],dtype = complex)
self.ps_lou = np.zeros([1,32],dtype = complex)
self.lamb = lamb
self.p0_lou[:16,:] = 0.5 * ((1.0-self.lamb)*np.reshape(self.pro_sing,(16,1))+(self.lamb/3.0)*np.reshape(self.pro_trip,(16,1)))
self.p0_lou[16:,:] = 0.5 * ((1.0-self.lamb)*np.reshape(self.pro_sing,(16,1))+(self.lamb/3.0)*np.reshape(self.pro_trip,(16,1)))
self.pt_lou[:,:16] = np.reshape(self.pro_trip,(1,16))
self.pt_lou[:,16:] = np.reshape(self.pro_trip,(1,16))
self.ps_lou[:,:16] = np.reshape(self.pro_sing,(1,16))
self.ps_lou[:,16:] = np.reshape(self.pro_sing,(1,16))
#Declare Hamiltonian and Louivillian
self.ltot = np.zeros([32,32], dtype = complex)
self.h0 = np.zeros([4,4], dtype = complex)
# Declare redfield and components
self.redfield = np.zeros([32,32], dtype = complex)
self.B = np.zeros([32,32], dtype = complex)
# Tensor terms
self.elec = np.zeros([5,5,4,4],dtype = complex)
self.uq = np.zeros([5,4,4],dtype = complex)
# declare class variable
self.aniso_g1 = aniso_g1
self.aniso_g2 = aniso_g2
self.g_mat = np.zeros([5],dtype = complex)
self.g1_iso = g1_iso
self.g2_iso = g2_iso
self.hyperfine_1 = aniso_hyperfine_1
self.h1_size = np.size(self.hyperfine_1[:,0,0])
self.h1 = np.zeros([self.h1_size,5], dtype = complex)
self.iso_h1 = iso_h1
self.hyperfine_2 = aniso_hyperfine_2
self.h2_size = np.size(self.hyperfine_2[:,0,0])
self.h2 = np.zeros([self.h2_size,5], dtype = complex)
self.iso_h2 = iso_h2
self.dipolar = aniso_dipolar
self.d_rank_2 = np.zeros([5],dtype = complex)
self.ks = ks
self.kt = kt
self.J_couple = J
self.del_J_couple = dj
self.exchange_rate = exchange_rate
self.omega1 = [0.0,0.0,field]
self.omega2 = [0.0,0.0,field]
self.n1_nuclear_spins = self.h1_size
self.n2_nuclear_spins = self.h2_size
self.spin_numbers_1 = spin_numbers_1
self.spin_numbers_2 = spin_numbers_2
# Variables for sampling SW vectors
self.angles1 = np.zeros([2,self.n1_nuclear_spins])
self.angles2 = np.zeros([2,self.n2_nuclear_spins])
self.nuc_vecs_1 = np.zeros([3,self.n1_nuclear_spins])
self.nuc_vecs_2 = np.zeros([3,self.n2_nuclear_spins])
self.omegatot_1 = np.zeros_like(self.omega1)
self.omegatot_2 = np.zeros_like(self.omega2)
self.vec_len_1 = np.sqrt(np.multiply(self.spin_numbers_1,(self.spin_numbers_1+1.0)))
self.vec_len_2 = np.sqrt(np.multiply(self.spin_numbers_2,(self.spin_numbers_2+1.0)))
# Haberkorn
self.Haberkorn_Matrix()
return
for i in range(len(misalignments)):
phi = misalignments[i]
R = np.array([[np.cos(phi), -np.sin(phi)], [np.sin(phi), np.cos(phi)]])
if i == 0:
DR_2D = R
else:
DR_2D = la.block_diag(DR_2D, R)
return DR_2D
misalignments = np.random.uniform(-0.17, 0.17, numAgents)
DR = build_DR_2D(misalignments)
# Kronecker products
Bb = la.kron(B, np.eye(m))
Lb = la.kron(L, np.eye(m))
Mb = la.kron(M, np.eye(m))
Lambdab = la.kron(Lambda, np.eye(m))
Dab = la.kron(Da, np.eye(m))
Dx = Dab.dot(DR)
# Initial conditions
p0 = np.random.uniform(-20, 20, numAgents * m)
# ODE(s)
def displacement_based(p, t, Lb, p_star):
dpdt = -Lb.dot(p - p_star)
return dpdt
def projection_shifts(A, E, Z, W, prev_shifts, shift_options):
"""Find further shift parameters for low-rank ADI iteration using
Galerkin projection on spaces spanned by LR-ADI iterates.
See [PK16]_, pp. 92-95.
Parameters
----------
A
The |Operator| A from the corresponding Lyapunov equation.
E
The |Operator| E from the corresponding Lyapunov equation.
Z
A |VectorArray| representing the currently computed low-rank solution factor.
W
A |VectorArray| representing the currently computed low-rank residual factor.
prev_shifts
A |NumPy array| containing the set of all previously used shift parameters.
shift_options
The shift options to use (see :func:`lyap_solver_options`).
Returns
-------
shifts
A |NumPy array| containing a set of stable shift parameters.
"""
u = shift_options['z_columns']
L = prev_shifts.size
r = len(W)
d = L - u
if d < 0:
u = L
d = 0
if prev_shifts[-u].imag < 0:
u = u + 1
Vu = Z[-u * r:] # last u matrices V added to solution factor Z
if shift_options['implicit_subspace']:
B = np.zeros((u, u))
G = np.zeros((u, 1))
Ir = np.eye(r)
iC = np.where(np.imag(prev_shifts) > 0)[0] # complex shifts indices (first shift of complex pair)
iR = np.where(np.isreal(prev_shifts))[0] # real shifts indices
iC = iC[iC >= d]
iR = iR[iR >= d]
i = 0
while i < u:
rS = iR[iR < d + i]
cS = iC[iC < d + i]
rp = prev_shifts[d + i].real
cp = prev_shifts[d + i].imag
G[i, 0] = np.sqrt(-2 * rp)
if cp == 0:
B[i, i] = rp
if rS.size > 0:
B[i, rS - d] = -2 * np.sqrt(rp*np.real(prev_shifts[rS]))
if cS.size > 0:
B[i, cS - d] = -2 * np.sqrt(2*rp*np.real(prev_shifts[cS]))
i = i + 1
else:
sri = np.sqrt(rp**2+cp**2)
B[i: i + 2, i: i + 2] = [[2*rp, -sri], [sri, 0]]
if rS.size > 0:
B[i, rS - d] = -2 * np.sqrt(2*rp*np.real(prev_shifts[rS]))
if cS.size > 0:
B[i, cS - d] = -4 * np.sqrt(rp*np.real(prev_shifts[cS]))
i = i + 2
B = spla.kron(B, Ir)
G = spla.kron(G, Ir)
s, v = spla.svd(Vu.gramian(), full_matrices=False)[1:3]
P = v.T.dot(np.diag(1. / np.sqrt(s)))
Q = Vu.to_numpy().T.dot(P)
E_V = E.apply(Vu).to_numpy().T
T = Q.T.dot(E_V)
Ap = Q.T.dot(W.to_numpy().T).dot(G.T).dot(P) + T.dot(B.dot(P))
Ep = T.dot(P)
else:
Q = gram_schmidt(Vu, atol=0, rtol=0)
Ap = A.apply2(Q, Q)
Ep = E.apply2(Q, Q)
shifts = spla.eigvals(Ap, Ep)
shifts = shifts[np.real(shifts) < 0]
if shifts.size == 0:
return np.concatenate((prev_shifts, prev_shifts))
else:
return np.concatenate((prev_shifts, shifts))
print(x) ## ## Determinant ## =========== det_a = linalg.det(a) print(det_a) ## ## Kronecker product ## ================= kron = linalg.kron(a, a_inv) print(kron) ## ## Others ## ====== # (1): tril # --- # Make a copy of a matrix with elements above the k-th diagonal zeroed. # k == 0 is the main diagonal, k < 0 subdiagonal and k > 0 superdiagonal. print(linalg.tril(kron)) print(linalg.tril(kron, k=-1)) print(linalg.tril(kron, k=1))
def solvingStuffForPQRS(AA, BB, CC, DD, FF, GG, HH, JJ, KK, LL, MM, NN):
q_eqns = sp.shape(FF)[0]
m_states = sp.shape(FF)[1]
l_equ = sp.shape(CC)[0]
n_endog = sp.shape(CC)[1]
k_exog = min(sp.shape(sp.mat(NN))[0], sp.shape(sp.mat(NN))[1])
if n_endog > 0 and npla.matrix_rank(CC)<n_endog:
print('CC is not of rank n. Cannot solve. Quitting. Goodbye')
else:
if l_equ==0:
# CC_plus = la.pinv(CC)
# CC_0 = nullSpaceBasis(CC.T)
Psi_mat = FF
Gamma_mat=- GG
Theta_mat = -HH
Xi_mat = sp.vstack(( sp.hstack((Gamma_mat, Theta_mat)), sp.hstack((sp.eye(m_states), sp.zeros((m_states,m_states))))))
Delta_mat = sp.vstack((sp.hstack((Psi_mat, sp.mat(sp.zeros((m_states,m_states))))), sp.hstack((sp.zeros((m_states,m_states)), sp.eye(m_states)))))
else:
CC_plus = la.pinv(CC)
CC_0 = nullSpaceBasis(CC.T)
Psi_mat = sp.vstack((sp.zeros((l_equ - n_endog, m_states)), FF - sp.dot(sp.dot(JJ,CC_plus),AA)))
if sp.size(CC_0) !=0:
Gamma_mat = sp.vstack((sp.dot(CC_0,AA), sp.dot(sp.dot(JJ,CC_plus),BB) - GG + sp.dot(sp.dot(KK,CC_plus),AA) ))
Theta_mat = sp.vstack((sp.dot(CC_0,AA), sp.dot(sp.dot(KK,CC_plus),BB) - HH))
else:
Gamma_mat = sp.dot(sp.dot(JJ,CC_plus),BB) - GG + sp.dot(sp.dot(KK,CC_plus),AA)
Theta_mat = sp.dot(sp.dot(KK,CC_plus),BB) - HH
Xi_mat = sp.vstack(( sp.hstack((Gamma_mat, Theta_mat)), sp.hstack((sp.eye(m_states), sp.zeros((m_states,m_states))))))
Delta_mat = sp.vstack((sp.hstack((Psi_mat, sp.mat(sp.zeros((m_states,m_states))))), sp.hstack((sp.zeros((m_states,m_states)), sp.eye(m_states)))))
eVals, eVecs = la.eig(Xi_mat, Delta_mat)
if npla.matrix_rank(eVecs)<m_states:
print('Error: Xi is not diagonalizable, stopping')
else:
Xi_sortabs = sp.sort(abs(eVals))
Xi_sortindex = sp.argsort(abs(eVals))
Xi_sortedVec = sp.array([eVecs[:,i] for i in Xi_sortindex])
Xi_sortval = Xi_sortabs
Xi_select = np.arange(0,m_states)
if sp.imag(Xi_sortedVec[m_states-1]).any():
if (abs(Xi_sortval[m_states-1] - sp.conj(Xi_sortval[m_states])) <TOL):
drop_index = 1
while (abs(sp.imag(Xi_sortval[drop_index]))>TOL) and (drop_index < m_states):
drop_index+=1
if drop_index >= m_states:
print('There is an error. Too many complex eigenvalues. Quitting')
else:
print('droping the lowest real eigenvalue. Beware of sunspots')
Xi_select = np.array([np.arange(0,drop_index-1),np.arange(drop_index+1,m_states)])
# Here Uhlig computes stuff if user chose "Manual roots" I am skipping it.
if max(abs(Xi_sortval[Xi_select]))> 1 + TOL:
print('It looks like we have unstable roots. This might not work')
if abs(max(abs(Xi_sortval[Xi_select])) -1) < TOL:
print('Check the model to make sure you have a unique steady state'\
,'we are having problems with convergence.')
Lambda_mat = sp.diag(Xi_sortval[Xi_select])
Omega_mat = sp.mat(sp.hstack((Xi_sortedVec[(m_states):(2*(m_states)),Xi_select])))
print Omega_mat
# Omega_mat = sp.reshape(Omega_mat,(Omega_mat.size**1/2,Omega_mat.size**1/2))
if npla.matrix_rank(Omega_mat) < m_states:
PP, Diff = solve_P(FF, GG, HH)
PP = sp.real(PP)
FFPP_plus_GG = sp.dot(FF,PP) + GG
print FFPP_plus_GG
print PP
print("Omega matrix is not invertible, Can't solve for P")
else:
PP = sp.dot(sp.dot(Omega_mat,Lambda_mat),la.inv(Omega_mat))
PP_imag = sp.imag(PP)
PP = sp.real(PP)
if sum(sum(abs(PP_imag))) / sum(sum(abs(PP))) > .000001:
print("A lot of P is complex. We will continue with the real part and hope we don't lose too much information")
#The code below was from he Uhlig file cacl_qrs.m. I think for python it fits better here.
if l_equ ==0:
RR = sp.zeros((0,m_states))
Bleh = (la.kron(sp.mat(NN.T), sp.mat(FF)))
print Bleh
#Don't you dare delete bleh and meh... They are the reason it works!!!
Meh = la.kron(NN.T, FFPP_plus_GG)
#100000000 strong for the matrices bleh and meh. Click HERE to join
print FFPP_plus_GG
VV = Bleh + Meh
# VV = mparray2npfloat(VV)
print VV, 'death'
#VV = sp.kron(NN.T,FF)+sp.kron(sp.eye(k_exog),sp.dot(FF,PP)+GG) #sp.kron(NN.T,JJ)+sp.kron(sp.eye(k_exog),KK)))
else:
RR = - sp.dot(CC_plus,(sp.dot(AA,PP)+BB))
VV = sp.vstack((sp.hstack((sp.kron(eye(k_exog),AA), sp.kron(eye(k_exog),CC))),\
sp.hstack((sp.kron(NN.T,FF)+sp.kron(sp.eye(k_exog),sp.dot(FF,PP)+sp.dot(JJ,RR)+GG), sp.kron(NN.T,JJ)+sp.kron(sp.eye(k_exog),KK)))))
if False and (npla.matrix_rank(VV) < k_exog*(m_states + n_endog)):
print("Sorry but V is note invertible. Can't solve for Q and S")
else:
LLNN_plus_MM = sp.dot(sp.mat(LL.T),sp.mat(NN)) + sp.mat(MM.T)
QQSS_vec = sp.dot(la.inv(sp.mat(VV)), sp.mat(LLNN_plus_MM))
QQSS_vec = -QQSS_vec
if max(abs(QQSS_vec)) == sp.inf:
print("We have issues with Q and S. Entries are undefined. Probably because V is no inverible.")
QQ = sp.reshape(QQSS_vec[0:m_states*k_exog],(m_states,k_exog))
SS = sp.reshape(QQSS_vec[(m_states*k_exog):((m_states+n_endog)*k_exog)],(n_endog,k_exog))
# The vstack and hstack's below are ugly, but safe. If you have issues with WW uncomment the first definition and comment out the second one.
#WW = sp.vstack((\
#sp.hstack((sp.eye(m_states), sp.zeros((m_states,k_exog)))),\
#sp.hstack((sp.dot(RR,sp.pinv(PP)), (SS-sp.dot(sp.dot(RR,sp.pinv(PP)),QQ)))),\
#sp.hstack((sp.zeros((k_exog,m_states)),sp.eye(k_exog)))))
WW = sp.array([[sp.eye(m_states), sp.zeros((m_states,k_exog))],\
[sp.dot(RR,la.pinv(PP)), (SS-sp.dot(sp.dot(RR,la.pinv(PP)),QQ))],\
[sp.zeros((k_exog,m_states)),sp.eye(k_exog)]])
return PP, QQ, RR, SS
#def solveQRS():
#if l_equ ==0:
# RR = sp.zeros((0,m_states))
# VV = sp.hstack((sp.kron(NN.T,FF)+sp.kron(sp.eye(k_exog),sp.dot(FF,PP)+GG), sp.kron(NN.T,JJ)+sp.kron(sp.eye(k_exog),KK)))
#else:
# RR = - sp.dot(CC_plus,(sp.dot(AA,PP)+BB))
# VV = sp.vstack((sp.hstack((sp.kron(eye(k_exog),AA), sp.kron(eye(k_exog),CC))),\
# sp.hstack((sp.kron(NN.T,FF)+sp.kron(sp.eye(k_exog),sp.dot(FF,PP)+sp.dot(JJ,RR)+GG), sp.kron(NN.T,JJ)+sp.kron(sp.eye(k_exog),KK)))))
#
#if (np.matrix_rank(VV) < k_exog*(m_states + n_endog)):
# print("Sorry but V is note invertible. Can't solve for Q and S")
#else:
# LLNN_plus_MM = LL*NN + MM
# QQSS_vec = - sp.dot(la.inv(VV), sp.vstack((DD,LLNN_plus_MM )))
# if max(abs(QQSS_vec)) == sp.inf:
# print("We have issueswith Q and S. Entries are undefined. Probably because V is no inverible.")
#
# QQ = sp.reshape(QQSS_vec[0:m_states*k_exog],(m_states,k_exog))
# SS = sp.reshape(QQSS_vec[(m_states*k_exog+1):((m_states+n_endog)*k_endog)],(n_endog,k_endog))
# WW = sp.vstack((\
# sp.hstack((sp.eye(m_states), sp.zeros((m_states,k_exog)))),\
# sp.hstack((sp.dot(RR,sp.pinv(PP)), (SS-sp.dot(sp.dot(RR,sp.pinv(PP)),QQ)))),\
# sp.hstack((sp.zeros((k_exog,m_states)),sp.eye(k_exog)))))
#
if __name__ == "__main__":
# Shape
m = 2
#ps = np.array([2,0,1,1,1,-1,0,1,0,-1,-1,1,-1,-1])
ps = np.array([2, 0, 1, 1, 1, -1, 0, 1, 0, -1, -1, 1, -1, -1, -2, 0])
numAgents = len(ps) / m
#list_edges = ((1,2),(1,3),(1,4),(1,5),(2,4),(2,7),(3,5),(3,6),(4,5),(4,6),(5,7),(6,7))
list_edges = ((1, 2), (1, 3), (1, 4), (1, 5), (2, 4), (2, 7), (3, 5),
(3, 6), (4, 5), (4, 6), (5, 7), (6, 8), (7, 8), (4, 8), (5,
8))
B = build_B(list_edges, numAgents)
w = find_w_from_ps(ps, B, m)
L = build_Laplacian(B, w)
Bb = la.kron(B, np.eye(m))
Lb = la.kron(L, np.eye(m))
Mr = np.zeros_like(B)
Mr[0, 0] = -0.5
Mr[0, 1] = 0.5
Mr[1, 0] = -1 / np.sqrt(2)
Mr[2, 1] = 1 / np.sqrt(2)
Mr[3, 4] = -1
Mr[4, 6] = 1
Mr[5, 11] = -1 / np.sqrt(2)
Mr[6, 12] = 1 / np.sqrt(2)
Mr[7, 11] = -0.5
Mr[7, 12] = 0.5
kr = 0.0
bend_loc = seg/2 voltage = 1 e0 = 8.854e-12 col = 1.602176565e-19 ##digitize physical space dl = line_len / seg cl = np.cos(pi * bend_ang / 180) sl = np.sin(pi * bend_ang / 180) x_quad2 = linalg.toeplitz(np.arange(0, bend_loc) * dl) xy_quad4 = linalg.toeplitz(np.arange(0, seg - bend_loc)) quad13 = kron(np.ones((bend_loc,1)), xy_quad4[0,:]) quad13 = quad13.reshape((bend_loc,seg - bend_loc)) y_quad13 = quad13 * sl*dl + sl*dl x_quad13 = quad13 * cl*dl + cl*dl+ x_quad2[:,-1:] x = np.vstack( (np.hstack( (x_quad2,x_quad13) ), np.hstack((x_quad13.T,xy_quad4 * cl*dl) ) ) ) y = np.vstack( (np.hstack( (np.zeros(np.shape(x_quad2)),y_quad13) ),np.hstack( (y_quad13.T,xy_quad4 * sl*dl) ) )) ##build coefficient matrix coeff_mat = np.sqrt(x**2 + y**2) coeff_mat = 2 * line_dia * dl / coeff_mat coeff_mat[np.diag_indices(seg)] = 4 * pi * line_dia * np.log(dl / line_dia) # coeff_mat[0,:] = 2 * line_dia * dl / opoint
def projection_shifts(A, E, Z, W, prev_shifts, shift_options):
"""Find further shift parameters for low-rank ADI iteration using
Galerkin projection on spaces spanned by LR-ADI iterates.
See [PK16]_, pp. 92-95.
Parameters
----------
A
The |Operator| A from the corresponding Lyapunov equation.
E
The |Operator| E from the corresponding Lyapunov equation.
Z
A |VectorArray| representing the currently computed low-rank
solution factor.
W
A |VectorArray| representing the currently computed low-rank
residual factor.
prev_shifts
A |NumPy array| containing the set of all previously used shift
parameters.
shift_options
The shift options to use (see :func:`lyap_lrcf_solver_options`).
Returns
-------
shifts
A |NumPy array| containing a set of stable shift parameters.
"""
u = shift_options['z_columns']
L = prev_shifts.size
r = len(W)
d = L - u
if d < 0:
u = L
d = 0
if prev_shifts[-u].imag < 0:
u = u + 1
Vu = Z[-u * r:] # last u matrices V added to solution factor Z
if shift_options['implicit_subspace']:
B = np.zeros((u, u))
G = np.zeros((u, 1))
Ir = np.eye(r)
iC = np.where(np.imag(prev_shifts) > 0)[
0] # complex shifts indices (first shift of complex pair)
iR = np.where(np.isreal(prev_shifts))[0] # real shifts indices
iC = iC[iC >= d]
iR = iR[iR >= d]
i = 0
while i < u:
rS = iR[iR < d + i]
cS = iC[iC < d + i]
rp = prev_shifts[d + i].real
cp = prev_shifts[d + i].imag
G[i, 0] = np.sqrt(-2 * rp)
if cp == 0:
B[i, i] = rp
if rS.size > 0:
B[i, rS - d] = -2 * np.sqrt(rp * np.real(prev_shifts[rS]))
if cS.size > 0:
B[i,
cS - d] = -2 * np.sqrt(2 * rp * np.real(prev_shifts[cS]))
i = i + 1
else:
sri = np.sqrt(rp**2 + cp**2)
B[i:i + 2, i:i + 2] = [[2 * rp, -sri], [sri, 0]]
if rS.size > 0:
B[i,
rS - d] = -2 * np.sqrt(2 * rp * np.real(prev_shifts[rS]))
if cS.size > 0:
B[i, cS - d] = -4 * np.sqrt(rp * np.real(prev_shifts[cS]))
i = i + 2
B = spla.kron(B, Ir)
G = spla.kron(G, Ir)
s, v = spla.svd(Vu.gramian(), full_matrices=False)[1:3]
P = v.T.dot(np.diag(1. / np.sqrt(s)))
Q = Vu.lincomb(P.T)
T = E.apply2(Q, Vu)
Ap = Q.dot(W).dot(G.T).dot(P) + T.dot(B.dot(P))
Ep = T.dot(P)
else:
Q = gram_schmidt(Vu, atol=0, rtol=0)
Ap = A.apply2(Q, Q)
Ep = E.apply2(Q, Q)
shifts = spla.eigvals(Ap, Ep)
shifts = shifts[shifts.real < 0]
if shifts.size == 0:
return np.concatenate((prev_shifts, prev_shifts))
else:
return np.concatenate((prev_shifts, shifts))
# +
mu_ = randn(n_, 1) # expectation
c = randn(n_, n_)
invs2_ = c @ c.T # inverse covariance
# set constant matrices for second derivatives
i_n = eye(n_)
i_k = eye(k_)
matrix = namedtuple('matrix', 'hm1 km')
matrix.hm1 = zeros((n_**2, n_))
matrix.km = zeros((k_ * n_, k_ * n_))
for k in range(k_):
matrix.km = matrix.km + kron(kron(i_k[:, [k]], i_n), i_k[:, [k]].T)
for n in range(n_):
matrix.hm1 = matrix.hm1 + kron(i_n[:, [n]], diagflat(
i_n[:, [n]])) # relative entropy
e = lambda theta: REnormLRD(theta, mu_, invs2_, n_, k_, matrix)[0]
e3 = lambda theta: REnormLRD(theta, mu_, invs2_, n_, k_, matrix)[2]
# -
# ## Main computations
err = zeros((j_, 1))
for j in trange(j_, desc='Simulations'):
# Set random variables
theta_ = randn(n_ + n_ * k_ + n_, 1)
#N for Walking times
N = 1000
#picture lim for y
lim = 0.18
#showing interval(ms)
timess = 40
#definition about the searching targets and basis
solution = ['10010100', '01000100', '01011110', '10100000', '11000000']
s001 = basis('00000000')
nbit = len(solution[0])
nspace = 2**nbit
#genearate Hilbert space
H_single_coin = H
for i in range(nbit - 1):
H_single_coin = kron(H, H_single_coin)
A0, T0 = print_wf(H_single_coin * s001)
#geneate initial_states
Coin = []
for i in range(nspace):
Coin.append([])
for j in range(nbit):
Coin[i].append(1 / np.sqrt(nbit * nspace))
Directions = get_directions(nbit)
Quantum = [Coin, Directions, T0]
print(Quantum)
results = []
results.append(get_Prob(Quantum))
