def updatedata(self, A):
if self.update:
if self.corr:
self.data.B = self.data.w*(linalg.norm(A,1)/linalg.norm(self.data.w,1))
self.data.C = self.data.v*(linalg.norm(A,Inf)/linalg.norm(self.data.v,1))
else:
# Note: Problem when singular vectors switch smallest singular value (See NewLorenz).
# To overcome this, I have implemented a 1e-8 random nudge.
try:
ALU = linalg.lu_factor(A)
BC = linalg.lu_solve(ALU, c_[linalg.lu_solve(ALU, self.data.B + 1e-8*self.data.Brand), \
self.data.C + 1e-8*self.data.Crand], trans=1)
C = linalg.lu_solve(ALU, BC[:,-1*self.data.q:])
B = BC[:,0:self.data.p]
except:
if self.C.verbosity >= 1:
print 'Warning: Problem updating border vectors. Using svd...'
U, S, Vh = linalg.svd(A)
B = U[:,-1*self.data.p:]
C = num_transpose(Vh)[:,-1*self.data.q:]
bmult = cmult = 1
if matrixmultiply(transpose(self.data.B), B) < 0:
bmult = -1
if matrixmultiply(transpose(self.data.C), C) < 0:
cmult = -1
self.data.B = bmult*B*(linalg.norm(A,1)/linalg.norm(B))
self.data.C = cmult*C*(linalg.norm(A,Inf)/linalg.norm(C))
def updatedata(self, A):
# Update b, c
try:
ALU = linalg.lu_factor(A)
BC = linalg.lu_solve(ALU, c_[linalg.lu_solve(ALU, self.data.b + 1e-8*self.data.Brand[:,:1]), \
self.data.c + 1e-8*self.data.Crand[:,:1]], trans=1)
C = linalg.lu_solve(ALU, BC[:,-1:])
B = BC[:,:1]
except:
if self.C.verbosity >= 1:
print 'Warning: Problem updating border vectors. Using svd...'
U, S, Vh = linalg.svd(A)
B = U[:,-1:]
C = num_transpose(Vh)[:,-1:]
bmult = cmult = 1
if matrixmultiply(transpose(self.data.b), B) < 0:
bmult = -1
if matrixmultiply(transpose(self.data.c), C) < 0:
cmult = -1
self.data.b = bmult*B*(linalg.norm(A,1)/linalg.norm(B))
self.data.c = cmult*C*(linalg.norm(A,Inf)/linalg.norm(C))
# Update
if self.update:
self.data.B[:,0] = self.data.b*(linalg.norm(A,1)/linalg.norm(self.data.b))
self.data.C[:,0] = self.data.c*(linalg.norm(A,Inf)/linalg.norm(self.data.c))
self.data.B[:,1] = self.data.w[:,2]*(linalg.norm(A,1)/linalg.norm(self.data.w,1))
self.data.C[:,1] = self.data.v[:,2]*(linalg.norm(A,Inf)/linalg.norm(self.data.v,1))
self.data.D[0,1] = self.data.g[0,1]
self.data.D[1,0] = self.data.g[1,0]
def process(self, X, V, C):
BifPoint.process(self, X, V, C)
# Finds the new branch
J_coords = C.CorrFunc.jac(X, C.coords)
J_params = C.CorrFunc.jac(X, C.params)
A = r_[c_[J_coords, J_params], [V]]
W, VR = linalg.eig(A)
W0 = [ind for ind, eig in enumerate(W) if abs(eig) < 1e-5]
V1 = real(VR[:,W0[0]])
H = C.CorrFunc.hess(X, C.coords+C.params, C.coords+C.params)
c11 = matrixmultiply(self.data.psi,[bilinearform(H[i,:,:], V, V) for i in range(H.shape[0])])
c12 = matrixmultiply(self.data.psi,[bilinearform(H[i,:,:], V, V1) for i in range(H.shape[0])])
c22 = matrixmultiply(self.data.psi,[bilinearform(H[i,:,:], V1, V1) for i in range(H.shape[0])])
beta = 1
alpha = -1*c22/(2*c12)
V1 = alpha*V + beta*V1
V1 /= linalg.norm(V1)
self.found[-1].eigs = W
self.found[-1].branch = todict(C, V1)
self.info(C, -1)
return True
def func(self, X, V):
H = self.F.sysfunc.hess(X, self.F.coords, self.F.coords)
q = self.F.testfunc.data.v/linalg.norm(self.F.testfunc.data.v)
p = self.F.testfunc.data.w/matrixmultiply(transpose(self.F.testfunc.data.w),q)
return array(0.5*matrixmultiply(transpose(p), reshape([bilinearform(H[i,:,:], q, q) \
for i in range(H.shape[0])],(H.shape[0],1)))[0])
def func(self, X, V):
k = self.C.TFdata.k
v1 = self.C.TFdata.v1
w1 = self.C.TFdata.w1
if k >=0:
J_coords = self.F.sysfunc.J_coords
w = sqrt(k)
q = v1 - (1j/w)*matrixmultiply(self.F.sysfunc.J_coords,v1)
p = w1 + (1j/w)*matrixmultiply(transpose(self.F.sysfunc.J_coords),w1)
p /= linalg.norm(p)
q /= linalg.norm(q)
p = reshape(p,(p.shape[0],))
q = reshape(q,(q.shape[0],))
direc = conjugate(1/matrixmultiply(transpose(conjugate(p)),q))
p = direc*p
l1 = firstlyapunov(X, self.F.sysfunc, w, J_coords=J_coords, p=p, q=q)
return array([l1])
else:
return array([1])
def __locate_newton(self, X, C):
"""x[0:self.dim] = (x,alpha)
x[self.dim] = beta
x[self.dim+1:2*self.dim] = p
"""
J_coords = C.CorrFunc.jac(X[0:C.dim], C.coords)
J_params = C.CorrFunc.jac(X[0:C.dim], C.params)
return r_[C.CorrFunc(X[0:C.dim]) + X[C.dim]*X[C.dim+1:], \
matrixmultiply(transpose(J_coords),X[C.dim+1:]), \
matrixmultiply(transpose(X[C.dim+1:]),J_params), \
matrixmultiply(transpose(X[C.dim+1:]),X[C.dim+1:]) - 1]
def bialttoeig(q, p, n, A): v1, v2 = invwedge(q, n) w1, w2 = invwedge(p, n) A11 = bilinearform(A,v1,v1) A22 = bilinearform(A,v2,v2) A12 = bilinearform(A,v1,v2) A21 = bilinearform(A,v2,v1) v11 = matrixmultiply(transpose(v1),v1) v22 = matrixmultiply(transpose(v2),v2) v12 = matrixmultiply(transpose(v1),v2) D = v11*v22 - v12*v12 k = (A11*A22 - A12*A21)/D return k[0][0], v1, w1
def bialttoeig(q, p, n, A):
v1, v2 = invwedge(q, n)
w1, w2 = invwedge(p, n)
A11 = bilinearform(A, v1, v1)
A22 = bilinearform(A, v2, v2)
A12 = bilinearform(A, v1, v2)
A21 = bilinearform(A, v2, v1)
v11 = matrixmultiply(transpose(v1), v1)
v22 = matrixmultiply(transpose(v2), v2)
v12 = matrixmultiply(transpose(v1), v2)
D = v11 * v22 - v12 * v12
k = (A11 * A22 - A12 * A21) / D
return k[0][0], v1, w1
def info(self, C, ind=None):
if ind is None:
ind = range(len(self.found))
elif isinstance(ind, int):
ind = [ind]
strlist = []
for n, i in enumerate(ind):
strlist.append('Period doubling branch angle = ' + repr(matrixmultiply(tocoords(C, self.found[i].V), \
tocoords(C, self.found[i].branch))))
BifPoint.info(self, C, ind, strlist)
def diff(self, X, ind=None):
try:
n = len(ind)
except:
n = self.n
ind = range(n)
F_n = zeros((self.period, self.n), Float)
F_n[0] = X
for k in range(1,self.period):
F_n[k] = c_[self.F(F_n[k-1]), X[self.F.params]]
xslice = slice(self.F.coords[0], self.F.coords[-1]+1, 1)
pslice = slice(self.F.params[0], self.F.params[-1]+1, 1)
J = self.F.jac(F_n[0])
for k in range(1,self.period):
J2 = self.F.jac(F_n[k])
J[:,xslice] = matrixmultiply(J2[:,xslice] ,J[:,xslice])
J[:,pslice] = matrixmultiply(J2[:,xslice], J[:,pslice]) + J2[:,pslice]
return J[:, ind[0]:ind[-1]+1]
def process(self, X, V, C):
"""Do I need to compute the branch, or will it always be in the direction of freepar = constant?"""
BifPoint.process(self, X, V, C)
F = DiscreteMap(C.sysfunc, period=2*C.sysfunc.period)
FP = FixedPointMap(F)
J_coords = FP.jac(X, C.coords)
J_params = FP.jac(X, C.params)
# Locate branch of double period map
W, VL = linalg.eig(J_coords, left=1, right=0)
ind = argsort([abs(eig) for eig in W])[0]
psi = real(VL[:,ind])
A = r_[c_[J_coords, J_params], [V]]
W, VR = linalg.eig(A)
W0 = argsort([abs(eig) for eig in W])[0]
V1 = real(VR[:,W0])
H = FP.hess(X, C.coords+C.params, C.coords+C.params)
c11 = matrixmultiply(psi,[bilinearform(H[i,:,:], V, V) for i in range(H.shape[0])])
c12 = matrixmultiply(psi,[bilinearform(H[i,:,:], V, V1) for i in range(H.shape[0])])
c22 = matrixmultiply(psi,[bilinearform(H[i,:,:], V1, V1) for i in range(H.shape[0])])
beta = 1
alpha = -1*c22/(2*c12)
V1 = alpha*V + beta*V1
V1 /= linalg.norm(V1)
J_coords = C.sysfunc.jac(X, C.coords)
W = linalg.eig(J_coords, right=0)
self.found[-1].eigs = W
self.found[-1].branch_period = 2*C.sysfunc.period
self.found[-1].branch = todict(C, V1)
self.info(C, -1)
return True
def process(self, X, V, C):
BifPoint.process(self, X, V, C)
# Compute normal form coefficient
# NOTE: These are for free when using bordering technique!)
# NOTE: Does not agree with MATCONT output! (if |p| = |q| = 1, then it does)
J_coords = C.CorrFunc.jac(X, C.coords)
W, VL, VR = linalg.eig(J_coords, left=1, right=1)
minW = min(abs(W))
ind = [(abs(eig) < minW+1e-8) and (abs(eig) > minW-1e-8) for eig in W].index(True)
p, q = real(VL[:,ind]), real(VR[:,ind])
p /= matrixmultiply(p,q)
B = C.CorrFunc.hess(X, C.coords, C.coords)
self.found[-1].a = abs(0.5*matrixmultiply(p,[bilinearform(B[i,:,:], q, q) for i in range(B.shape[0])]))
self.found[-1].eigs = W
numzero = len([eig for eig in W if abs(eig) < 1e-4])
if numzero > 1:
if C.verbosity >= 2:
print 'Fold-Fold!\n'
del self.found[-1]
return False
elif numzero == 0:
if C.verbosity >= 2:
print 'False positive!\n'
del self.found[-1]
return False
if C.verbosity >= 2:
print '\nChecking...'
print ' |q| = %f' % linalg.norm(q)
print ' <p,q> = %f' % matrixmultiply(p,q)
print ' |Aq| = %f' % linalg.norm(matrixmultiply(J_coords,q))
print ' |transpose(A)p| = %f\n' % linalg.norm(matrixmultiply(transpose(J_coords),p))
self.info(C, -1)
return True
def firstlyapunov(X, F, w, J_coords=None, V=None, W=None, p=None, q=None, check=False): if J_coords is None: J_coords = F.jac(X, F.coords) if p is None: alpha = bilinearform(transpose(J_coords),V[:,0],V[:,1]) - \ 1j*w*matrixmultiply(V[:,0],V[:,1]) beta = -1*bilinearform(transpose(J_coords),V[:,0],V[:,0]) + \ 1j*w*matrixmultiply(V[:,0],V[:,0]) q = alpha*V[:,0] + beta*V[:,1] alpha = bilinearform(J_coords,W[:,0],W[:,1]) + \ 1j*w*matrixmultiply(W[:,0],W[:,1]) beta = -1*bilinearform(J_coords,W[:,0],W[:,0]) - \ 1j*w*matrixmultiply(W[:,0],W[:,0]) p = alpha*W[:,0] + beta*W[:,1] p /= linalg.norm(p) q /= linalg.norm(q) direc = conjugate(1/matrixmultiply(conjugate(p),q)) p = direc*p if check: print 'Checking...' print ' |q| = %f' % linalg.norm(q) temp = matrixmultiply(conjugate(p),q) print ' |<p,q> - 1| = ', abs(temp-1) print ' |Aq - iwq| = %f' % linalg.norm(matrixmultiply(J_coords,q) - 1j*w*q) print ' |A*p + iwp| = %f\n' % linalg.norm(matrixmultiply(transpose(J_coords),p) + 1j*w*p) # Compute first lyapunov coefficient B = F.hess(X, F.coords, F.coords) D = hess3(F, X, F.coords) b1 = array([bilinearform(B[i,:,:], q, q) for i in range(B.shape[0])]) b2 = array([bilinearform(B[i,:,:], conjugate(q), linalg.solve(2*1j*w*eye(F.m) - J_coords, b1)) \ for i in range(B.shape[0])]) b3 = array([bilinearform(B[i,:,:], q, conjugate(q)) for i in range(B.shape[0])]) b4 = array([bilinearform(B[i,:,:], q, linalg.solve(J_coords, b3)) for i in range(B.shape[0])]) temp = array([trilinearform(D[i,:,:,:],q,q,conjugate(q)) for i in range(D.shape[0])]) + b2 - 2*b4 l1 = 0.5*real(matrixmultiply(conjugate(p), temp)) return l1
def process(self, X, V, C):
BifPoint.process(self, X, V, C)
J_coords = C.CorrFunc.sysfunc.jac(X, C.coords)
W, VL, VR = linalg.eig(J_coords, left=1, right=1)
self.found[-1].eigs = W
if C.verbosity >= 2:
if C.CorrFunc.testfunc.data.B.shape[1] == 2:
b = matrixmultiply(transpose(J_coords), C.CorrFunc.testfunc.data.w[:,0])
c = matrixmultiply(J_coords, C.CorrFunc.testfunc.data.v[:,0])
else:
b = C.CorrFunc.testfunc.data.w[:,0]
c = C.CorrFunc.testfunc.data.v[:,0]
print '\nChecking...'
print ' <b,c> = %f' % matrixmultiply(transpose(b), c)
print '\n'
self.info(C, -1)
return True
def process(self, X, V, C):
BifPoint.process(self, X, V, C)
J_coords = C.CorrFunc.sysfunc.jac(X, C.coords)
B = C.CorrFunc.sysfunc.hess(X, C.coords, C.coords)
W, VL, VR = linalg.eig(J_coords, left=1, right=1)
q = C.CorrFunc.testfunc.data.C/linalg.norm(C.CorrFunc.testfunc.data.C)
p = C.CorrFunc.testfunc.data.B/matrixmultiply(transpose(C.CorrFunc.testfunc.data.B),q)
self.found[-1].eigs = W
a = 0.5*matrixmultiply(transpose(p), reshape([bilinearform(B[i,:,:], q, q) \
for i in range(B.shape[0])],(B.shape[0],1)))[0][0]
if C.verbosity >= 2:
print '\nChecking...'
print ' |a| = %f' % a
print '\n'
self.info(C, -1)
return True
def subspace_angles(A, B):
"""
Return the principle angles and vectors between two subspaces.
See Bjorck and Golub, "Numerical Methods for Computing Between Linear
Subspaces" _Mathematics_of_Computation_, 27(123), 1973, pp. 579-594
Or, for a more understandable exposition, Golub and Van Loan,
_Matrix_Computations_ (3rd ed.) pp. 603-604
"""
A, B = scipy.asarray(A), scipy.asarray(B)
if A.shape[0] != B.shape[0]:
raise ValueError('Input subspaces must live in the same dimensional '\
'space.')
# Get orthogonal bases for our two subspaces.
QA, QB = scipy.linalg.orth(A), scipy.linalg.orth(B)
M = scipy.matrixmultiply(scipy.transpose(scipy.conjugate(QA)), QB)
Y, C, Zh = scipy.linalg.svd(M)
U = scipy.matrixmultiply(QA, Y)
V = scipy.matrixmultiply(QB, scipy.transpose(scipy.conjugate(Zh)))
return scipy.arccos(C), U, V
def process(self, X, V, C):
"""Tolerance for eigenvalues a possible problem when checking for neutral saddles."""
BifPoint.process(self, X, V, C)
J_coords = C.CorrFunc.jac(X, C.coords)
eigs, LV, RV = linalg.eig(J_coords,left=1,right=1)
# Check for neutral saddles
found = False
for i in range(len(eigs)):
if abs(imag(eigs[i])) < 1e-5:
for j in range(i+1,len(eigs)):
if C.verbosity >= 2:
if abs(eigs[i]) < 1e-5 and abs(eigs[j]) < 1e-5:
print 'Fold-Fold point found in Hopf!\n'
elif abs(imag(eigs[j])) < 1e-5 and abs(real(eigs[i]) + real(eigs[j])) < 1e-5:
print 'Neutral saddle found!\n'
elif abs(real(eigs[i])) < 1e-5:
for j in range(i+1, len(eigs)):
if abs(real(eigs[j])) < 1e-5 and abs(real(eigs[i]) - real(eigs[j])) < 1e-5:
found = True
w = abs(imag(eigs[i]))
if imag(eigs[i]) > 0:
p = conjugate(LV[:,j])/linalg.norm(LV[:,j])
q = RV[:,i]/linalg.norm(RV[:,i])
else:
p = conjugate(LV[:,i])/linalg.norm(LV[:,i])
q = RV[:,j]/linalg.norm(RV[:,j])
if not found:
del self.found[-1]
return False
direc = conjugate(1/matrixmultiply(conjugate(p),q))
p = direc*p
# Alternate way to compute 1st lyapunov coefficient (from Kuznetsov [4])
#print (1./(w*w))*real(1j*matrixmultiply(conjugate(p),b1)*matrixmultiply(conjugate(p),b3) + \
# w*matrixmultiply(conjugate(p),trilinearform(D,q,q,conjugate(q))))
self.found[-1].w = w
self.found[-1].l1 = firstlyapunov(X, C.CorrFunc, w, J_coords=J_coords, p=p, q=q, check=(C.verbosity==2))
self.found[-1].eigs = eigs
self.info(C, -1)
return True
def func(self, X, V):
return array(matrixmultiply(transpose(self.F.testfunc.data.w), self.F.testfunc.data.v)[0])
def func(self, X, V):
BorderMethod.func(self, matrixmultiply(self.F.J_coords,self.F.J_coords) + X[-1]*eye(self.F.m))
return array([self.data.g[0,0], self.data.g[1,1]])
def setdata(self, X, V):
BorderMethod.setdata(self, matrixmultiply(self.F.J_coords,self.F.J_coords) + X[-1]*eye(self.F.m))
# for i in range(30):
# # ignore header
# k=f.readline()
# for j in range(1024):
# k=f.readline()
# s=k.split()
# for l in range(256):
# data4[j][l]=float(s[l])
# for i in range(1024):
# for j in range(256):
# summe4[i]+=data4[i][j]
#corrsumme=matrixmultiply(summe,corrmat)
corrsumme = matrixmultiply(summe, corrmat)
corrsumme2 = matrixmultiply(summe2, corrmat)
corrsumme3 = zeros([1024], Float)
for i in range(0, 1022):
corrsumme3[i] = corrsumme[i + 2]
cmgd = GridData(data)
data2grid = GridData(data)
gp = Gnuplot()
#gp("set logscale z")
#gp("set zrange[1:80]")
#gp("set palette rgbformula -3,-3,-3")
#gp("test palette")
#gp("set xrange[400:800]")
def firstlyapunov(X,
F,
w,
J_coords=None,
V=None,
W=None,
p=None,
q=None,
check=False):
if J_coords is None:
J_coords = F.jac(X, F.coords)
if p is None:
alpha = bilinearform(transpose(J_coords),V[:,0],V[:,1]) - \
1j*w*matrixmultiply(V[:,0],V[:,1])
beta = -1*bilinearform(transpose(J_coords),V[:,0],V[:,0]) + \
1j*w*matrixmultiply(V[:,0],V[:,0])
q = alpha * V[:, 0] + beta * V[:, 1]
alpha = bilinearform(J_coords,W[:,0],W[:,1]) + \
1j*w*matrixmultiply(W[:,0],W[:,1])
beta = -1*bilinearform(J_coords,W[:,0],W[:,0]) - \
1j*w*matrixmultiply(W[:,0],W[:,0])
p = alpha * W[:, 0] + beta * W[:, 1]
p /= linalg.norm(p)
q /= linalg.norm(q)
direc = conjugate(1 / matrixmultiply(conjugate(p), q))
p = direc * p
if check:
print 'Checking...'
print ' |q| = %f' % linalg.norm(q)
temp = matrixmultiply(conjugate(p), q)
print ' |<p,q> - 1| = ', abs(temp - 1)
print ' |Aq - iwq| = %f' % linalg.norm(
matrixmultiply(J_coords, q) - 1j * w * q)
print ' |A*p + iwp| = %f\n' % linalg.norm(
matrixmultiply(transpose(J_coords), p) + 1j * w * p)
# Compute first lyapunov coefficient
B = F.hess(X, F.coords, F.coords)
D = hess3(F, X, F.coords)
b1 = array([bilinearform(B[i, :, :], q, q) for i in range(B.shape[0])])
b2 = array([bilinearform(B[i,:,:], conjugate(q), linalg.solve(2*1j*w*eye(F.m) - J_coords, b1)) \
for i in range(B.shape[0])])
b3 = array(
[bilinearform(B[i, :, :], q, conjugate(q)) for i in range(B.shape[0])])
b4 = array([
bilinearform(B[i, :, :], q, linalg.solve(J_coords, b3))
for i in range(B.shape[0])
])
temp = array([
trilinearform(D[i, :, :, :], q, q, conjugate(q))
for i in range(D.shape[0])
]) + b2 - 2 * b4
l1 = 0.5 * real(matrixmultiply(conjugate(p), temp))
return l1
def bilinearform(A, x1, x2): return matrixmultiply(transpose(x2),matrixmultiply(A,x1))
def trilinearform(A, x1, x2, x3):
dim = A.shape
return matrixmultiply(
transpose([bilinearform(A[i, :, :], x1, x2) for i in range(dim[0])]),
x3)
def bilinearform(A, x1, x2):
return matrixmultiply(transpose(x2), matrixmultiply(A, x1))
def getMaps(pt, pttype, output=False, screen=False, cyclic=True):
jac0 = pt.labels['LC']['data'].jac0
jac1 = pt.labels['LC']['data'].jac1
flow = pt.labels[pttype]['flow']
n = jac0.shape[0]
# Compute jacobian times vec
J = linalg.solve(jac1, jac0)
if output:
print "Jacobian J*x"
print "------------\n"
print J
print "\n"
print "Check Jacobian"
print "--------------\n"
print " eigs = ", linalg.eig(J)[0]
print " eigs = ", pt.labels['LC']['data'].evals
# Compute composition of flow maps
print "Flow maps"
print "---------\n"
ntst = len(flow)/2
maps = []
if not cyclic:
for i in range(ntst):
I = identity(n)
for j in mod(arange(i, i + ntst), ntst):
j = int(j)
I = linalg.solve(flow[2*j+1], matrixmultiply(flow[2*j], I))
maps.append(I)
# Check eigs of maps
evals = []
levecs = []
revecs = []
for m in maps:
w, vl, vr = linalg.eig(m, left=1, right=1)
evals.append(w)
levecs.append(vl)
revecs.append(vr)
if output:
for i in range(ntst):
print evals[i]
# Get left evecs along curve associated with 1 evalue
evec1 = []
good = []
for i in range(ntst):
ind = argsort(abs(evals[i]-1.))[0]
if abs(evals[i][ind]-1) > 0.05:
print "Bad floquet multipliers!"
else:
good.append(i)
evec1.append(levecs[i][:,ind])
else:
# CYCLIC METHOD
print "Similarity method!\n"
I = identity(n)
for i in range(ntst):
I = linalg.solve(flow[2*i+1], matrixmultiply(flow[2*i], I))
evec1 = []
w, vl, vr = linalg.eig(I, left=1, right=1)
print w, vl
ind = argsort(abs(w-1.))[0]
if abs(w[ind]-1) > 0.05:
raise "Bad floquet multipliers!"
else:
v = vl[:,ind]
print v
for i in range(ntst):
v = matrixmultiply(transpose(flow[2*i]), linalg.solve(transpose(flow[2*i+1]), v))
evec1.append(v/linalg.norm(v))
# print "Cyclic method!\n"
# evals = []
# levecs = []
# revecs = []
# C0 = zeros((n*ntst, n*ntst), Float64)
# C1 = zeros((n*ntst, n*ntst), Float64)
# for i in range(ntst):
# C0[(n*i):(n*(i+1)), int(mod(n*(i+1), n*ntst)):int(mod(n*(i+2), n*ntst))] = flow[2*i]
# C1[(n*i):(n*(i+1)), (n*i):(n*(i+1))] = flow[2*i+1]
#
# w, vl, vr = linalg.eig(C0, C1, left=1, right=1)
# print w
# Same direction - if right eigenvector
cycle = pt.labels[pttype]['cycle']
coords = cycle.coordnames
#for i in range(ntst):
# if matrixmultiply(evec1[i], (cycle[4*i+1]-cycle[4*i]).toarray()) < 0:
# evec1[i] = -1*evec1[i]
if screen:
x = cycle[coords[0]]
y = cycle[coords[1]]
pylab.plot(x,y)
for i in good:
a = [x[4*i], x[4*i] + 10*evec1[i][0]]
b = [y[4*i], y[4*i] + 10*evec1[i][1]]
pylab.plot(a, b, 'r', linewidth=1)
pylab.plot([x[4*i]], [y[4*i]], 'gs')
#pylab.plot([x[4*i], x[4*i] + 0.5*vhd[0]], [y[4*i], y[4*i] + 0.5*vhd[1]], 'b')
#print evec1[i], vhd, "\n"
#print matrixmultiply(evec1[i], vhd)
if screen:
Je, JE = linalg.eig(jac0, jac1)
ind = argsort(abs(Je-1.))[0]
#if abs(Je[ind]-1) > 0.05:
if 0:
print "Jacobian: Bad floquet multipliers!"
else:
u, s, vh = linalg.svd(jac0-jac1, compute_uv=1)
evec2 = [transpose(vh)[:,-1]]
#evec2 = [JE[:,ind]]
for i in range(ntst):
evec2.append(linalg.solve(flow[2*i+1], matrixmultiply(flow[2*i], evec2[i])))
# Same direction
for i in range(ntst):
if matrixmultiply(evec2[i], (cycle[4*i+1]-cycle[4*i]).toarray()) < 0:
evec2[i] = -1*evec2[i]
for i in range(ntst):
a = [x[4*i], x[4*i] + 0.5*evec2[i][0]]
b = [y[4*i], y[4*i] + 0.5*evec2[i][1]]
#pylab.plot(a, b, 'r', linewidth=1)
#pylab.plot([x[4*i]], [y[4*i]], 'gs')
return J, maps, evec1
def getMaps(pt, pttype, output=False, screen=False, cyclic=True):
jac0 = pt.labels['LC']['data'].jac0
jac1 = pt.labels['LC']['data'].jac1
flow = pt.labels[pttype]['flow']
n = jac0.shape[0]
# Compute jacobian times vec
J = linalg.solve(jac1, jac0)
if output:
print "Jacobian J*x"
print "------------\n"
print J
print "\n"
print "Check Jacobian"
print "--------------\n"
print " eigs = ", linalg.eig(J)[0]
print " eigs = ", pt.labels['LC']['data'].evals
# Compute composition of flow maps
print "Flow maps"
print "---------\n"
ntst = len(flow) / 2
maps = []
if not cyclic:
for i in range(ntst):
I = identity(n)
for j in mod(arange(i, i + ntst), ntst):
j = int(j)
I = linalg.solve(flow[2 * j + 1],
matrixmultiply(flow[2 * j], I))
maps.append(I)
# Check eigs of maps
evals = []
levecs = []
revecs = []
for m in maps:
w, vl, vr = linalg.eig(m, left=1, right=1)
evals.append(w)
levecs.append(vl)
revecs.append(vr)
if output:
for i in range(ntst):
print evals[i]
# Get left evecs along curve associated with 1 evalue
evec1 = []
good = []
for i in range(ntst):
ind = argsort(abs(evals[i] - 1.))[0]
if abs(evals[i][ind] - 1) > 0.05:
print "Bad floquet multipliers!"
else:
good.append(i)
evec1.append(levecs[i][:, ind])
else:
# CYCLIC METHOD
print "Similarity method!\n"
I = identity(n)
for i in range(ntst):
I = linalg.solve(flow[2 * i + 1], matrixmultiply(flow[2 * i], I))
evec1 = []
w, vl, vr = linalg.eig(I, left=1, right=1)
print w, vl
ind = argsort(abs(w - 1.))[0]
if abs(w[ind] - 1) > 0.05:
raise "Bad floquet multipliers!"
else:
v = vl[:, ind]
print v
for i in range(ntst):
v = matrixmultiply(transpose(flow[2 * i]),
linalg.solve(transpose(flow[2 * i + 1]), v))
evec1.append(v / linalg.norm(v))
# print "Cyclic method!\n"
# evals = []
# levecs = []
# revecs = []
# C0 = zeros((n*ntst, n*ntst), Float64)
# C1 = zeros((n*ntst, n*ntst), Float64)
# for i in range(ntst):
# C0[(n*i):(n*(i+1)), int(mod(n*(i+1), n*ntst)):int(mod(n*(i+2), n*ntst))] = flow[2*i]
# C1[(n*i):(n*(i+1)), (n*i):(n*(i+1))] = flow[2*i+1]
#
# w, vl, vr = linalg.eig(C0, C1, left=1, right=1)
# print w
# Same direction - if right eigenvector
cycle = pt.labels[pttype]['cycle']
coords = cycle.coordnames
#for i in range(ntst):
# if matrixmultiply(evec1[i], (cycle[4*i+1]-cycle[4*i]).toarray()) < 0:
# evec1[i] = -1*evec1[i]
if screen:
x = cycle[coords[0]]
y = cycle[coords[1]]
pylab.plot(x, y)
for i in good:
a = [x[4 * i], x[4 * i] + 10 * evec1[i][0]]
b = [y[4 * i], y[4 * i] + 10 * evec1[i][1]]
pylab.plot(a, b, 'r', linewidth=1)
pylab.plot([x[4 * i]], [y[4 * i]], 'gs')
#pylab.plot([x[4*i], x[4*i] + 0.5*vhd[0]], [y[4*i], y[4*i] + 0.5*vhd[1]], 'b')
#print evec1[i], vhd, "\n"
#print matrixmultiply(evec1[i], vhd)
if screen:
Je, JE = linalg.eig(jac0, jac1)
ind = argsort(abs(Je - 1.))[0]
#if abs(Je[ind]-1) > 0.05:
if 0:
print "Jacobian: Bad floquet multipliers!"
else:
u, s, vh = linalg.svd(jac0 - jac1, compute_uv=1)
evec2 = [transpose(vh)[:, -1]]
#evec2 = [JE[:,ind]]
for i in range(ntst):
evec2.append(
linalg.solve(flow[2 * i + 1],
matrixmultiply(flow[2 * i], evec2[i])))
# Same direction
for i in range(ntst):
if matrixmultiply(
evec2[i],
(cycle[4 * i + 1] - cycle[4 * i]).toarray()) < 0:
evec2[i] = -1 * evec2[i]
for i in range(ntst):
a = [x[4 * i], x[4 * i] + 0.5 * evec2[i][0]]
b = [y[4 * i], y[4 * i] + 0.5 * evec2[i][1]]
#pylab.plot(a, b, 'r', linewidth=1)
#pylab.plot([x[4*i]], [y[4*i]], 'gs')
return J, maps, evec1
def trilinearform(A, x1, x2, x3): dim = A.shape return matrixmultiply(transpose([bilinearform(A[i,:,:],x1,x2) for i in range(dim[0])]),x3)