def pad(a):
b = tuck.tensor()
b.n = [2 * a.n[0], 2 * a.n[1], 2 * a.n[2]]
b.r = a.r
b.u[0] = np.zeros((b.n[0], b.r[0]), dtype=np.complex128)
b.u[1] = np.zeros((b.n[1], b.r[1]), dtype=np.complex128)
b.u[2] = np.zeros((b.n[2], b.r[2]), dtype=np.complex128)
b.u[0][:a.n[0], :] = a.u[0]
b.u[1][:a.n[1], :] = a.u[1]
b.u[2][:a.n[2], :] = a.u[2]
b.core = a.core
return b
def pad(a):
b = tuck.tensor()
b.n = [2*a.n[0], 2*a.n[1], 2*a.n[2]]
b.r = a.r
b.u[0] = np.zeros((b.n[0], b.r[0]), dtype=np.complex128)
b.u[1] = np.zeros((b.n[1], b.r[1]), dtype=np.complex128)
b.u[2] = np.zeros((b.n[2], b.r[2]), dtype=np.complex128)
b.u[0][:a.n[0], :] = a.u[0]
b.u[1][:a.n[1], :] = a.u[1]
b.u[2][:a.n[2], :] = a.u[2]
b.core = a.core
return b
def read_psi_old(molecule_name, folder):
g = np.load(folder+'/' + molecule_name + '_' + 'g.npy')
norb = len(g)
psi = [None]*norb
for i in xrange(norb):
psi[i] = tuck.tensor()
psi[i].core = g[i]
psi[i].u[0] = np.load(folder+'/' + molecule_name + '_' +str(i)+ '_' + 'u1.npy')
psi[i].u[1] = np.load(folder+'/' + molecule_name + '_' +str(i)+ '_' + 'u2.npy')
psi[i].u[2] = np.load(folder+'/' + molecule_name + '_' +str(i)+ '_' + 'u3.npy')
psi[i].n = (len(psi[i].u[0]), len(psi[i].u[1]), len(psi[i].u[2]))
psi[i].r = copy.copy(psi[i].core.shape)
return psi
def read_psi(molecule_name, folder):
#g = np.load(folder+'/' + molecule_name + '_' + 'g.npy')
#norb = len(g)
psi = []
i = 0
while True:
try:
psi.append(tuck.tensor())
psi[i].core = np.load(folder+'/' + molecule_name + '_' +str(i)+ '_' + 'g.npy')
psi[i].u[0] = np.load(folder+'/' + molecule_name + '_' +str(i)+ '_' + 'u1.npy')
psi[i].u[1] = np.load(folder+'/' + molecule_name + '_' +str(i)+ '_' + 'u2.npy')
psi[i].u[2] = np.load(folder+'/' + molecule_name + '_' +str(i)+ '_' + 'u3.npy')
psi[i].n = (len(psi[i].u[0]), len(psi[i].u[1]), len(psi[i].u[2]))
psi[i].r = copy.copy(psi[i].core.shape)
i += 1
except:
break
return psi[:-1]
def multifun(X, delta_cross, fun, r_add = 4, y0 = None, pr = None):
# For X = [X_1,...,X_d], where X_i - tensors in the Tucker format
# cross_func computes y = func(X) == func(x_1,...,x_d) in the Tucker format by using cross3d
#
# delta_cross - accuracy for cross3D
# r_add - number of computed columns on each iteration of cross3d. May be used to improve time performing.
d = len(X)
if type(r_add) == int:
r_add = [r_add, r_add, r_add]
elif len(r_add) == 3:
None
else:
raise Exception('r_add must be of type int or list of len = 3')
eps_cross = 1
if pr <> None:
print 'cross multifun... \n'
r = copy.copy(r_add)
n = X[0].n
N = int((min(n)+1)/2)
if y0 <> None:
############################################################
############################################################
############################################################
Q1, R = np.linalg.qr(y0.u[0]);
row_order_U1 = np.sort(tuck.mv.maxvol(Q1));
Q2, R = np.linalg.qr(y0.u[1]);
row_order_U2 = np.sort(tuck.mv.maxvol(Q2));
Q3, R = np.linalg.qr(y0.u[2]);
row_order_U3 = np.sort(tuck.mv.maxvol(Q3));
r0 = [len(row_order_U1), len(row_order_U2), len(row_order_U3)]
A = [None]*d
for alpha in xrange(d):
A[alpha] = np.tensordot(X[alpha].core, np.transpose(X[alpha].u[2][row_order_U3,:]), (2, 0))
A[alpha] = np.tensordot(np.transpose(A[alpha], [2,0,1]), np.transpose(X[alpha].u[1][row_order_U2,:]), (2, 0))
A[alpha] = np.tensordot(np.transpose(A[alpha], [0,2,1]), np.transpose(X[alpha].u[0][row_order_U1,:]), (2, 0))
A[alpha] = np.transpose(A[alpha], [2,1,0])
Ar = fun(A)
A1 = np.reshape(Ar, [r0[0],-1], order='f')
A1 = np.transpose(A1)
Q_A1, R = np.linalg.qr(A1)
column_order_U1 = tuck.mv.maxvol(Q_A1)
A1_11 = A1[column_order_U1, :]
A2 = np.reshape(np.transpose(Ar, [1,0,2]), [r0[1],-1], order='f')
A2 = np.transpose(A2)
Q_A2, R = np.linalg.qr(A2)
column_order_U2 = tuck.mv.maxvol(Q_A2)
A2_11 = A2[column_order_U2, :]
A3 = np.reshape(np.transpose(Ar, [2,0,1]), [r0[2],-1], order='f')
A3 = np.transpose(A3)
Q_A3, R = np.linalg.qr(A3)
column_order_U3 = tuck.mv.maxvol(Q_A3)
A3_11 = A3[column_order_U3, :]
u1 = np.zeros((n[0], r0[0]), dtype=np.complex128)
for i in xrange(r0[0]):
for alpha in xrange(d):
k1_order, j1_order = mod(column_order_U1[i], r0[1])
A[alpha] = np.dot(X[alpha].core,np.transpose(X[alpha].u[2][row_order_U3[k1_order]:row_order_U3[k1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [2,0,1]), np.transpose(X[alpha].u[1][row_order_U2[j1_order]:row_order_U2[j1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [0,2,1]), np.transpose(X[alpha].u[0]), (2,0))
A[alpha] = np.transpose(A[alpha], [2,1,0])[:, 0, 0]
u1[:,i] = fun(A)
u2 = np.zeros((n[1], r0[1]), dtype=np.complex128)
for j in xrange(r0[1]):
for alpha in xrange(d):
k1_order, i1_order = mod(column_order_U2[j], r0[0])
A[alpha] = np.dot(X[alpha].core, np.transpose(X[alpha].u[2][row_order_U3[k1_order]:row_order_U3[k1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [2,1,0]),np.transpose(X[alpha].u[0][row_order_U1[i1_order]:row_order_U1[i1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [0,2,1]),np.transpose(X[alpha].u[1]), (2, 0))
A[alpha] = np.transpose(A[alpha], [1,2,0])[0, :, 0]
u2[:,j] = fun(A)
u3 = np.zeros((n[2], r0[2]), dtype=np.complex128)
for k in xrange(r0[2]):
for alpha in xrange(d):
j1_order, i1_order = mod(column_order_U3[k], r0[0])
A[alpha] = np.dot(np.transpose(X[alpha].core, [2,1,0]),np.transpose(X[alpha].u[0][row_order_U1[i1_order]:row_order_U1[i1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [0,2,1]),np.transpose(X[alpha].u[1][row_order_U2[j1_order]:row_order_U2[j1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [1,2,0]),np.transpose(X[alpha].u[2]), (2, 0))[0,0,:]
u3[:,k] = fun(A)
else:
############################################################
############################################################
############################################################
GG = np.zeros(r, dtype=np.complex128)
u1 = np.zeros((n[0], r_add[0]), dtype=np.complex128)
u2 = np.zeros((n[1], r_add[1]), dtype=np.complex128)
u3 = np.zeros((n[2], r_add[2]), dtype=np.complex128)
u1[:N,:] = np.random.random((N,r_add[0]))
u2[:N,:] = np.random.random((N,r_add[1]))
u3[:N,:] = np.random.random((N,r_add[2]))
u1, R = np.linalg.qr(u1)
u2, R = np.linalg.qr(u2)
u3, R = np.linalg.qr(u3)
row_order_U1 = tuck.mv.maxvol(u1)
row_order_U2 = tuck.mv.maxvol(u2)
row_order_U3 = tuck.mv.maxvol(u3)
r0 = [len(row_order_U1), len(row_order_U1), len(row_order_U1)]
A = [None]*d
for alpha in xrange(d):
A[alpha] = np.tensordot(X[alpha].core, np.transpose(X[alpha].u[2][row_order_U3,:]), (2, 0))
A[alpha] = np.tensordot(np.transpose(A[alpha], [2,0,1]), np.transpose(X[alpha].u[1][row_order_U2,:]), (2, 0))
A[alpha] = np.tensordot(np.transpose(A[alpha], [0,2,1]), np.transpose(X[alpha].u[0][row_order_U1,:]), (2, 0))
A[alpha] = np.transpose(A[alpha], [2,1,0])
Ar = fun(A)
A1 = np.reshape(Ar, [r0[0],-1], order='f')
A1 = np.transpose(A1)
Q_A1, R = np.linalg.qr(A1)
column_order_U1 = tuck.mv.maxvol(Q_A1)
A1_11 = A1[column_order_U1, :]
A2 = np.reshape(np.transpose(Ar, [1,0,2]), [r0[1],-1], order='f')
A2 = np.transpose(A2)
Q_A2, R = np.linalg.qr(A2)
column_order_U2 = tuck.mv.maxvol(Q_A2)
A2_11 = A2[column_order_U2, :]
A3 = np.reshape(np.transpose(Ar, [2,0,1]), [r0[2],-1], order='f')
A3 = np.transpose(A3)
Q_A3, R = np.linalg.qr(A3)
column_order_U3 = tuck.mv.maxvol(Q_A3)
A3_11 = A3[column_order_U3, :]
#################################################################################
U1 = u1
U2 = u2
U3 = u3
U1_hat = np.linalg.solve(U1[row_order_U1, :].T, U1.T).T
U2_hat = np.linalg.solve(U2[row_order_U2, :].T, U2.T).T
U3_hat = np.linalg.solve(U3[row_order_U3, :].T, U3.T).T
u1 = np.random.random((n[0],r_add[0]))
u2 = np.random.random((n[1],r_add[1]))
u3 = np.random.random((n[2],r_add[2]))
UU1, ind_update_1 = column_update(U1_hat, u1, row_order_U1)
UU2, ind_update_2 = column_update(U2_hat, u2, row_order_U2)
UU3, ind_update_3 = column_update(U3_hat, u3, row_order_U3)
U1 = np.concatenate((U1, u1), 1)
U2 = np.concatenate((U2, u2), 1)
U3 = np.concatenate((U3, u3), 1)
A1_12 = np.zeros((r0[0], r_add[0]),dtype=np.complex128)
for ii in xrange(r0[0]):
for alpha in xrange(d):
k1_order, j1_order = mod(column_order_U1[ii], r0[1])
A[alpha] = np.dot(X[alpha].core, np.transpose(X[alpha].u[2][row_order_U3[k1_order]:row_order_U3[k1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [2,0,1]),np.transpose(X[alpha].u[1][row_order_U2[j1_order]:row_order_U2[j1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [0,2,1]),np.transpose(X[alpha].u[0][ind_update_1, :]), (2, 0))
A[alpha] = np.transpose(A[alpha], [2,1,0])[:,0,0]
A1_12[ii,:] = fun(A)
A2_12 = np.zeros((r0[1], r_add[1]),dtype=np.complex128)
for ii in xrange(r0[1]):
for alpha in xrange(d):
k1_order, i1_order = mod(column_order_U2[ii], r0[0])
A[alpha] = np.dot(X[alpha].core, np.transpose(X[alpha].u[2][row_order_U3[k1_order]:row_order_U3[k1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [2,1,0]), np.transpose(X[alpha].u[0][row_order_U1[i1_order]:row_order_U1[i1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [0,2,1]), np.transpose(X[alpha].u[1][ind_update_2, :]), (2, 0))
A[alpha] = np.transpose(A[alpha], [1,2,0])[0,:,0]
A2_12[ii, :] = fun(A)
A3_12 = np.zeros((r0[2], r_add[2]),dtype=np.complex128)
for ii in xrange(r0[2]):
for alpha in xrange(d):
j1_order, i1_order = mod(column_order_U3[ii], r0[0])
A[alpha] = np.dot(np.transpose(X[alpha].core, [2,1,0]),np.transpose(X[alpha].u[0][row_order_U1[i1_order]:row_order_U1[i1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [0,2,1]),np.transpose(X[alpha].u[1][row_order_U2[j1_order]:row_order_U2[j1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [1,2,0]),np.transpose(X[alpha].u[2][ind_update_3, :]), (2, 0))[0,0,:]
A3_12[ii, :] = fun(A)
r[0] = r0[0]+r_add[0]
r[1] = r0[1]+r_add[1]
r[2] = r0[2]+r_add[2]
while True:
for alpha in xrange(d):
A[alpha] = np.dot(np.transpose(X[alpha].core, [2,1,0]), np.transpose(X[alpha].u[0][ind_update_1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [0,2,1]), np.transpose(X[alpha].u[1][row_order_U2,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [1,2,0]), np.transpose(X[alpha].u[2][row_order_U3,:]))
Ar_1 = np.concatenate((Ar, fun(A)), 0)
row_order_U1 = np.concatenate((row_order_U1, ind_update_1))
for alpha in xrange(d):
A[alpha] = np.dot(np.transpose(X[alpha].core, [0,2,1]), np.transpose(X[alpha].u[1][ind_update_2,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [0,2,1]), np.transpose(X[alpha].u[2][row_order_U3,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [2,1,0]), np.transpose(X[alpha].u[0][row_order_U1,:]))
A[alpha] = np.transpose(A[alpha], [2,1,0])
Ar_2 = np.concatenate((Ar_1, fun(A)), 1)
row_order_U2 = np.concatenate((row_order_U2, ind_update_2))
for alpha in xrange(d):
A[alpha] = np.dot(X[alpha].core, np.transpose(X[alpha].u[2][ind_update_3,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [2,0,1]),np.transpose(X[alpha].u[1][row_order_U2,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [0,2,1]),np.transpose(X[alpha].u[0][row_order_U1,:]))
A[alpha] = np.transpose(A[alpha], [2,1,0])
Ar = np.concatenate((Ar_2, fun(A)), 2)
row_order_U3 = np.concatenate((row_order_U3, ind_update_3))
A1 = np.reshape(Ar, [r[0],-1], order='f')
A1 = np.transpose(A1)
column_order_update_U1 = tuck.mv.maxvol( schur_comp(A1, A1_11, A1_12) )
r_add[0] = len(column_order_update_U1)
A2 = np.reshape(np.transpose(Ar, [1,0,2]), [r[1],-1], order='f')
A2 = np.transpose(A2)
column_order_update_U2 = tuck.mv.maxvol( schur_comp(A2, A2_11, A2_12) )
r_add[1] = len(column_order_update_U2)
A3 = np.reshape(np.transpose(Ar, [2,0,1]), [r[2],-1], order='f')
A3 = np.transpose(A3)
column_order_update_U3 = tuck.mv.maxvol( schur_comp(A3, A3_11, A3_12) )
r_add[2] = len(column_order_update_U3)
u1_approx = np.zeros((n[0], r_add[0]), dtype=np.complex128)
u1 = np.zeros((n[0], r_add[0]), dtype=np.complex128)
for i in xrange(r_add[0]):
for alpha in xrange(d):
k1_order, j1_order = mod(column_order_update_U1[i], r[1])
A[alpha] = np.dot(X[alpha].core, np.transpose(X[alpha].u[2][row_order_U3[k1_order]:row_order_U3[k1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [2,0,1]),np.transpose(X[alpha].u[1][row_order_U2[j1_order]:row_order_U2[j1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [0,2,1]),np.transpose(X[alpha].u[0]), (2, 0))
A[alpha] = np.transpose(A[alpha], [2,1,0])[:,0,0]
u1[:,i] = fun(A)
u1_approx_i = np.dot(Ar, np.transpose(UU3[row_order_U3[k1_order]:row_order_U3[k1_order]+1,:]))
u1_approx_i = np.dot(np.transpose(u1_approx_i,[2,0,1]),np.transpose(UU2[row_order_U2[j1_order]:row_order_U2[j1_order]+1,:]))
u1_approx_i = np.tensordot(np.transpose(u1_approx_i,[0,2,1]),np.transpose(UU1), (2, 0))
u1_approx_i = np.transpose(u1_approx_i,[2,1,0])
u1_approx[:,i] = u1_approx_i[:, 0, 0]
u2_approx = np.zeros((n[1], r_add[1]), dtype=np.complex128)
u2 = np.zeros((n[1], r_add[1]), dtype=np.complex128)
for j in xrange(r_add[1]):
for alpha in xrange(d):
k1_order, i1_order = mod(column_order_update_U2[j], r[0])
A[alpha] = np.dot(X[alpha].core, np.transpose(X[alpha].u[2][row_order_U3[k1_order]:row_order_U3[k1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [2,1,0]), np.transpose(X[alpha].u[0][row_order_U1[i1_order]:row_order_U1[i1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [0,2,1]), np.transpose(X[alpha].u[1]), (2, 0))
A[alpha] = np.transpose(A[alpha], [1,2,0])[0,:,0]
u2[:,j] = fun(A)
u2_approx_j = np.dot(Ar,np.transpose(UU3[row_order_U3[k1_order]:row_order_U3[k1_order]+1,:]))
u2_approx_j = np.dot(np.transpose(u2_approx_j,[2,1,0]),np.transpose(UU1[row_order_U1[i1_order]:row_order_U1[i1_order]+1,:]))
u2_approx_j = np.tensordot(np.transpose(u2_approx_j,[0,2,1]),np.transpose(UU2), (2, 0))
u2_approx[:,j] = u2_approx_j[0, 0, :]
u3_approx = np.zeros((n[2], r_add[2]), dtype=np.complex128)
u3 = np.zeros((n[2], r_add[2]), dtype=np.complex128)
for k in xrange(r_add[2]):
for alpha in xrange(d):
j1_order, i1_order = mod(column_order_update_U3[k], r[0])
A[alpha] = np.dot(np.transpose(X[alpha].core, [2,1,0]),np.transpose(X[alpha].u[0][row_order_U1[i1_order]:row_order_U1[i1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [0,2,1]),np.transpose(X[alpha].u[1][row_order_U2[j1_order]:row_order_U2[j1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [1,2,0]),np.transpose(X[alpha].u[2]), (2, 0))[0,0,:]
u3[:,k] = fun(A)
u3_approx_k = np.dot(np.transpose(Ar,[2,1,0]),np.transpose(UU1[row_order_U1[i1_order]:row_order_U1[i1_order]+1,:]))
u3_approx_k = np.dot(np.transpose(u3_approx_k,[0,2,1]),np.transpose(UU2[row_order_U2[j1_order]:row_order_U2[j1_order]+1,:]))
u3_approx_k = np.tensordot(np.transpose(u3_approx_k,[1,2,0]),np.transpose(UU3), (2, 0))
u3_approx[:,k] = u3_approx_k[0, 0, :]
eps_cross = 1./3*( np.linalg.norm(u1_approx - u1)/ np.linalg.norm(u1) +
np.linalg.norm(u2_approx - u2)/ np.linalg.norm(u2) +
np.linalg.norm(u3_approx - u3)/ np.linalg.norm(u3) )
if pr <> None:
print 'relative accuracy = %s' % (eps_cross), 'ranks = %s' % r
if eps_cross < delta_cross:
break
#print np.linalg.norm( full(G, U1, U2, U3) - C_toch )/np.linalg.norm(C_toch)
UU1, ind_update_1 = column_update(UU1, u1, row_order_U1)
UU2, ind_update_2 = column_update(UU2, u2, row_order_U2)
UU3, ind_update_3 = column_update(UU3, u3, row_order_U3)
U1 = np.concatenate((U1, u1), 1)
U2 = np.concatenate((U2, u2), 1)
U3 = np.concatenate((U3, u3), 1)
A1_11 = np.concatenate((A1_11, A1_12), 1)
A1_11 = np.concatenate((A1_11, A1[column_order_update_U1,:]) )
A2_11 = np.concatenate((A2_11, A2_12), 1)
A2_11 = np.concatenate((A2_11, A2[column_order_update_U2,:]) )
A3_11 = np.concatenate((A3_11, A3_12), 1)
A3_11 = np.concatenate((A3_11, A3[column_order_update_U3,:]) )
A1_12 = U1[ind_update_1, r_add[0]:].T
A2_12 = U2[ind_update_2, r_add[1]:].T
A3_12 = U3[ind_update_3, r_add[2]:].T
r[0] = r[0]+r_add[0]
r[1] = r[1]+r_add[1]
r[2] = r[2]+r_add[2]
U1, R1 = np.linalg.qr(UU1)
U2, R2 = np.linalg.qr(UU2)
U3, R3 = np.linalg.qr(UU3)
GG = np.tensordot(np.transpose(Ar,[2,1,0]),np.transpose(R1), (2, 0))
GG = np.tensordot(np.transpose(GG,[0,2,1]),np.transpose(R2), (2, 0))
GG = np.transpose(GG,[1,2,0])
G = np.tensordot(GG,np.transpose(R3), (2, 0))
G_Tucker = tuck.tensor(G, delta_cross)
if pr <> None:
print 'ranks after rounding = %s' % G_Tucker.r[0], G_Tucker.r[1], G_Tucker.r[2]
fun = tuck.tensor()
fun.core = G_Tucker.core
fun.u[0] = np.dot(U1, G_Tucker.u[0])
fun.u[1] = np.dot(U2, G_Tucker.u[1])
fun.u[2] = np.dot(U3, G_Tucker.u[2])
fun.r = G_Tucker.r
fun.n = n
return fun
def cross3d(func, M, eps_init, delta_add=1e-5):
N = int((M + 1) / 2)
r1 = 2
r2 = 2
r3 = 2
GG = np.zeros((r1, r2, r3), dtype=np.complex128)
U1 = np.zeros((M, r1), dtype=np.complex128)
U2 = np.zeros((M, r2), dtype=np.complex128)
U3 = np.zeros((M, r3), dtype=np.complex128)
U1[:N, :] = np.random.random((N, r1))
U2[:N, :] = np.random.random((N, r2))
U3[:N, :] = np.random.random((N, r3))
U1, R = np.linalg.qr(U1)
U2, R = np.linalg.qr(U2)
U3, R = np.linalg.qr(U3)
eps_cross = 1
while True:
row_order_U1 = tuck.mv.maxvol(U1)
row_order_U2 = tuck.mv.maxvol(U2)
row_order_U3 = tuck.mv.maxvol(U3)
Ar = np.zeros((r1, r2, r3), dtype=np.complex128)
for i in xrange(r1):
for j in xrange(r2):
for k in xrange(r3):
Ar[i, j, k] = func(
(row_order_U1[i], row_order_U2[j], row_order_U3[k]))
U1_r = U1[row_order_U1, :]
U2_r = U2[row_order_U2, :]
U3_r = U3[row_order_U3, :]
G_UV = np.linalg.solve(
U3_r,
np.reshape(np.transpose(Ar, [2, 0, 1]), (r3, r1 * r2), order='f'))
G_UV = np.reshape(G_UV, (r3, r1, r2), order='f')
G_UV = np.transpose(G_UV, [1, 2, 0])
G_U = np.linalg.solve(
U2_r,
np.reshape(np.transpose(G_UV, [1, 2, 0]), (r2, r1 * r3),
order='f'))
G_U = np.reshape(G_U, (r2, r3, r1), order='f')
G_U = np.transpose(G_U, [2, 0, 1])
G = np.linalg.solve(U1_r, np.reshape(G_U, (r1, r2 * r3), order='f'))
G = np.reshape(G, (r1, r2, r3), order='f')
norm = np.linalg.norm(G)
eps_cross = (np.linalg.norm(GG - G)) / norm
#print 'relative accuracy = %s' % (eps_cross), 'ranks = %s' % r1, r2, r3
G_Tucker = tuck.tensor(G, eps_init / 10)
G = G_Tucker.core
U1 = np.dot(U1, G_Tucker.u[0])
U2 = np.dot(U2, G_Tucker.u[1])
U3 = np.dot(U3, G_Tucker.u[2])
(r1, r2, r3) = G_Tucker.r
if eps_cross < eps_init:
break
row_order_U1 = tuck.mv.maxvol(U1)
row_order_U2 = tuck.mv.maxvol(U2)
row_order_U3 = tuck.mv.maxvol(U3)
Ar = np.zeros((r1, r2, r3), dtype=np.complex128)
for i in xrange(r1):
for j in xrange(r2):
for k in xrange(r3):
Ar[i, j, k] = func(
(row_order_U1[i], row_order_U2[j], row_order_U3[k]))
A1 = np.reshape(Ar, [r1, -1], order='f')
A1_r = np.transpose(A1)
A1_r, R = np.linalg.qr(A1_r)
column_order_U1 = tuck.mv.maxvol(A1_r)
A2 = np.reshape(np.transpose(Ar, [1, 0, 2]), [r2, -1], order='f')
A2_r = np.transpose(A2)
A2_r, R = np.linalg.qr(A2_r)
column_order_U2 = tuck.mv.maxvol(A2_r)
A3 = np.reshape(np.transpose(Ar, [2, 0, 1]), [r3, -1], order='f')
A3_r = np.transpose(A3)
A3_r, R = np.linalg.qr(A3_r)
column_order_U3 = tuck.mv.maxvol(A3_r)
u1 = np.zeros((M, r1), dtype=np.complex128)
for i in xrange(r1):
for ii in xrange(M):
k1_order, j1_order = mod(column_order_U1[i], r2)
u1[ii, i] = func(
(ii, row_order_U2[j1_order], row_order_U3[k1_order]))
u2 = np.zeros((M, r2), dtype=np.complex128)
for j in xrange(r2):
for jj in xrange(M):
k1_order, i1_order = mod(column_order_U2[j], r1)
u2[jj, j] = func(
(row_order_U1[i1_order], jj, row_order_U3[k1_order]))
u3 = np.zeros((M, r3), dtype=np.complex128)
for k in xrange(r3):
for kk in xrange(M):
j1_order, i1_order = mod(column_order_U3[k], r1)
u3[kk, k] = func(
(row_order_U1[i1_order], row_order_U2[j1_order], kk))
u1, v, r11 = round_matrix(u1, delta_add)
u2, v, r22 = round_matrix(u2, delta_add)
u3, v, r33 = round_matrix(u3, delta_add)
u1 = u1[:, :r11]
u2 = u2[:, :r22]
u3 = u3[:, :r33]
U1_0 = np.zeros((M, r1 + r11), dtype=np.complex128)
U2_0 = np.zeros((M, r2 + r22), dtype=np.complex128)
U3_0 = np.zeros((M, r3 + r33), dtype=np.complex128)
U1_0[:, :r1] = U1.copy()
U2_0[:, :r2] = U2.copy()
U3_0[:, :r3] = U3.copy()
U1_0[:, r1:r1 + r11] = u1
U2_0[:, r2:r2 + r22] = u2
U3_0[:, r3:r3 + r33] = u3
U1 = U1_0.copy()
U2 = U2_0.copy()
U3 = U3_0.copy()
r1 = r1 + r11
r2 = r2 + r22
r3 = r3 + r33
U1, R1 = np.linalg.qr(U1)
U2, R2 = np.linalg.qr(U2)
U3, R3 = np.linalg.qr(U3)
GG = np.zeros((r1, r2, r3), dtype=np.complex128)
GG[:(r1 - r11), :(r2 - r22), :(r3 - r33)] = G.copy()
GG = np.dot(np.transpose(GG, [2, 1, 0]), np.transpose(R1))
GG = np.dot(np.transpose(GG, [0, 2, 1]), np.transpose(R2))
GG = np.transpose(GG, [1, 2, 0])
GG = np.dot(GG, np.transpose(R3))
#print 'ranks after rounding = %s' % r1, r2, r3
G_Tucker.n = (M, M, M)
G_Tucker.u[0] = U1
G_Tucker.u[1] = U2
G_Tucker.u[2] = U3
G_Tucker.r = [r1, r2, r3]
return tuck.round(G_Tucker, eps_init)
def multifun(X, delta_cross, fun, r_add=4, y0=None, rmax=100, pr=None):
# For X = [X_1,...,X_d], where X_i - tensors in the Tucker format
# cross_func computes y = func(X) == func(x_1,...,x_d) in the Tucker format by using cross3d
#
# delta_cross - accuracy for cross3D
# r_add - number of computed columns on each iteration of cross3d. May be used to improve time performing.
d = len(X)
if type(r_add) == int:
r_add = [r_add, r_add, r_add]
elif len(r_add) == 3:
None
else:
raise Exception('r_add must be of type int or list of len = 3')
eps_cross = 1
if pr <> None:
print 'cross multifun... \n'
r = copy.copy(r_add)
n = X[0].n
N = int((min(n)+1)/2)
# Type check
list = [X[i].u[0][0,0] for i in xrange(len(X))]
if type(np.sum(list)) is np.complex128:
dtype = np.complex128
else:
dtype = np.float64
if pr <> None:
print 'data type is', dtype
# if there is initial guess
if y0 <> None:
############################################################
############################################################
############################################################
Q1, R = np.linalg.qr(y0.u[0]);
row_order_U1 = np.sort(tuck.mv.maxvol(Q1));
Q2, R = np.linalg.qr(y0.u[1]);
row_order_U2 = np.sort(tuck.mv.maxvol(Q2));
Q3, R = np.linalg.qr(y0.u[2]);
row_order_U3 = np.sort(tuck.mv.maxvol(Q3));
r0 = [len(row_order_U1), len(row_order_U2), len(row_order_U3)]
A = [None]*d
for alpha in xrange(d):
A[alpha] = np.tensordot(X[alpha].core, np.transpose(X[alpha].u[2][row_order_U3,:]), (2, 0))
A[alpha] = np.tensordot(np.transpose(A[alpha], [2,0,1]), np.transpose(X[alpha].u[1][row_order_U2,:]), (2, 0))
A[alpha] = np.tensordot(np.transpose(A[alpha], [0,2,1]), np.transpose(X[alpha].u[0][row_order_U1,:]), (2, 0))
A[alpha] = np.transpose(A[alpha], [2,1,0])
Ar = fun(A)
A1 = np.reshape(Ar, [r0[0],-1], order='f')
A1 = np.transpose(A1)
Q_A1, R = np.linalg.qr(A1)
column_order_U1 = tuck.mv.maxvol(Q_A1)
A1_11 = A1[column_order_U1, :]
A2 = np.reshape(np.transpose(Ar, [1,0,2]), [r0[1],-1], order='f')
A2 = np.transpose(A2)
Q_A2, R = np.linalg.qr(A2)
column_order_U2 = tuck.mv.maxvol(Q_A2)
A2_11 = A2[column_order_U2, :]
A3 = np.reshape(np.transpose(Ar, [2,0,1]), [r0[2],-1], order='f')
A3 = np.transpose(A3)
Q_A3, R = np.linalg.qr(A3)
column_order_U3 = tuck.mv.maxvol(Q_A3)
A3_11 = A3[column_order_U3, :]
u1 = np.zeros((n[0], r0[0]), dtype=dtype)
for i in xrange(r0[0]):
for alpha in xrange(d):
k1_order, j1_order = mod(column_order_U1[i], r0[1])
A[alpha] = np.dot(X[alpha].core,np.transpose(X[alpha].u[2][row_order_U3[k1_order]:row_order_U3[k1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [2,0,1]), np.transpose(X[alpha].u[1][row_order_U2[j1_order]:row_order_U2[j1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [0,2,1]), np.transpose(X[alpha].u[0]), (2,0))
A[alpha] = np.transpose(A[alpha], [2,1,0])[:, 0, 0]
u1[:,i] = fun(A)
u2 = np.zeros((n[1], r0[1]), dtype=dtype)
for j in xrange(r0[1]):
for alpha in xrange(d):
k1_order, i1_order = mod(column_order_U2[j], r0[0])
A[alpha] = np.dot(X[alpha].core, np.transpose(X[alpha].u[2][row_order_U3[k1_order]:row_order_U3[k1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [2,1,0]),np.transpose(X[alpha].u[0][row_order_U1[i1_order]:row_order_U1[i1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [0,2,1]),np.transpose(X[alpha].u[1]), (2, 0))
A[alpha] = np.transpose(A[alpha], [1,2,0])[0, :, 0]
u2[:,j] = fun(A)
u3 = np.zeros((n[2], r0[2]), dtype=dtype)
for k in xrange(r0[2]):
for alpha in xrange(d):
j1_order, i1_order = mod(column_order_U3[k], r0[0])
A[alpha] = np.dot(np.transpose(X[alpha].core, [2,1,0]),np.transpose(X[alpha].u[0][row_order_U1[i1_order]:row_order_U1[i1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [0,2,1]),np.transpose(X[alpha].u[1][row_order_U2[j1_order]:row_order_U2[j1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [1,2,0]),np.transpose(X[alpha].u[2]), (2, 0))[0,0,:]
u3[:,k] = fun(A)
else:
############################################################
############################################################
############################################################
GG = np.zeros(r, dtype=dtype)
u1 = np.zeros((n[0], r_add[0]), dtype=dtype)
u2 = np.zeros((n[1], r_add[1]), dtype=dtype)
u3 = np.zeros((n[2], r_add[2]), dtype=dtype)
u1[:N,:] = np.random.random((N,r_add[0]))
u2[:N,:] = np.random.random((N,r_add[1]))
u3[:N,:] = np.random.random((N,r_add[2]))
u1, R = np.linalg.qr(u1)
u2, R = np.linalg.qr(u2)
u3, R = np.linalg.qr(u3)
row_order_U1 = tuck.mv.maxvol(u1)
row_order_U2 = tuck.mv.maxvol(u2)
row_order_U3 = tuck.mv.maxvol(u3)
r0 = [len(row_order_U1), len(row_order_U1), len(row_order_U1)]
A = [None]*d
for alpha in xrange(d):
A[alpha] = np.tensordot(X[alpha].core, np.transpose(X[alpha].u[2][row_order_U3,:]), (2, 0))
A[alpha] = np.tensordot(np.transpose(A[alpha], [2,0,1]), np.transpose(X[alpha].u[1][row_order_U2,:]), (2, 0))
A[alpha] = np.tensordot(np.transpose(A[alpha], [0,2,1]), np.transpose(X[alpha].u[0][row_order_U1,:]), (2, 0))
A[alpha] = np.transpose(A[alpha], [2,1,0])
Ar = fun(A)
A1 = np.reshape(Ar, [r0[0],-1], order='f')
A1 = np.transpose(A1)
Q_A1, R = np.linalg.qr(A1)
column_order_U1 = tuck.mv.maxvol(Q_A1)
A1_11 = A1[column_order_U1, :]
A2 = np.reshape(np.transpose(Ar, [1,0,2]), [r0[1],-1], order='f')
A2 = np.transpose(A2)
Q_A2, R = np.linalg.qr(A2)
column_order_U2 = tuck.mv.maxvol(Q_A2)
A2_11 = A2[column_order_U2, :]
A3 = np.reshape(np.transpose(Ar, [2,0,1]), [r0[2],-1], order='f')
A3 = np.transpose(A3)
Q_A3, R = np.linalg.qr(A3)
column_order_U3 = tuck.mv.maxvol(Q_A3)
A3_11 = A3[column_order_U3, :]
#################################################################################
U1 = u1
U2 = u2
U3 = u3
U1_hat = np.linalg.solve(U1[row_order_U1, :].T, U1.T).T
U2_hat = np.linalg.solve(U2[row_order_U2, :].T, U2.T).T
U3_hat = np.linalg.solve(U3[row_order_U3, :].T, U3.T).T
u1 = np.random.random((n[0],r_add[0]))
u2 = np.random.random((n[1],r_add[1]))
u3 = np.random.random((n[2],r_add[2]))
UU1, ind_update_1 = column_update(U1_hat, u1, row_order_U1)
UU2, ind_update_2 = column_update(U2_hat, u2, row_order_U2)
UU3, ind_update_3 = column_update(U3_hat, u3, row_order_U3)
U1 = np.concatenate((U1, u1), 1)
U2 = np.concatenate((U2, u2), 1)
U3 = np.concatenate((U3, u3), 1)
A1_12 = np.zeros((r0[0], r_add[0]),dtype=dtype)
for ii in xrange(r0[0]):
for alpha in xrange(d):
k1_order, j1_order = mod(column_order_U1[ii], r0[1])
A[alpha] = np.dot(X[alpha].core, np.transpose(X[alpha].u[2][row_order_U3[k1_order]:row_order_U3[k1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [2,0,1]),np.transpose(X[alpha].u[1][row_order_U2[j1_order]:row_order_U2[j1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [0,2,1]),np.transpose(X[alpha].u[0][ind_update_1, :]), (2, 0))
A[alpha] = np.transpose(A[alpha], [2,1,0])[:,0,0]
A1_12[ii,:] = fun(A)
A2_12 = np.zeros((r0[1], r_add[1]),dtype=dtype)
for ii in xrange(r0[1]):
for alpha in xrange(d):
k1_order, i1_order = mod(column_order_U2[ii], r0[0])
A[alpha] = np.dot(X[alpha].core, np.transpose(X[alpha].u[2][row_order_U3[k1_order]:row_order_U3[k1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [2,1,0]), np.transpose(X[alpha].u[0][row_order_U1[i1_order]:row_order_U1[i1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [0,2,1]), np.transpose(X[alpha].u[1][ind_update_2, :]), (2, 0))
A[alpha] = np.transpose(A[alpha], [1,2,0])[0,:,0]
A2_12[ii, :] = fun(A)
A3_12 = np.zeros((r0[2], r_add[2]),dtype=dtype)
for ii in xrange(r0[2]):
for alpha in xrange(d):
j1_order, i1_order = mod(column_order_U3[ii], r0[0])
A[alpha] = np.dot(np.transpose(X[alpha].core, [2,1,0]),np.transpose(X[alpha].u[0][row_order_U1[i1_order]:row_order_U1[i1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [0,2,1]),np.transpose(X[alpha].u[1][row_order_U2[j1_order]:row_order_U2[j1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [1,2,0]),np.transpose(X[alpha].u[2][ind_update_3, :]), (2, 0))[0,0,:]
A3_12[ii, :] = fun(A)
r[0] = r0[0]+r_add[0]
r[1] = r0[1]+r_add[1]
r[2] = r0[2]+r_add[2]
while True:
for alpha in xrange(d):
A[alpha] = np.dot(np.transpose(X[alpha].core, [2,1,0]), np.transpose(X[alpha].u[0][ind_update_1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [0,2,1]), np.transpose(X[alpha].u[1][row_order_U2,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [1,2,0]), np.transpose(X[alpha].u[2][row_order_U3,:]))
Ar_1 = np.concatenate((Ar, fun(A)), 0)
row_order_U1 = np.concatenate((row_order_U1, ind_update_1))
for alpha in xrange(d):
A[alpha] = np.dot(np.transpose(X[alpha].core, [0,2,1]), np.transpose(X[alpha].u[1][ind_update_2,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [0,2,1]), np.transpose(X[alpha].u[2][row_order_U3,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [2,1,0]), np.transpose(X[alpha].u[0][row_order_U1,:]))
A[alpha] = np.transpose(A[alpha], [2,1,0])
Ar_2 = np.concatenate((Ar_1, fun(A)), 1)
row_order_U2 = np.concatenate((row_order_U2, ind_update_2))
for alpha in xrange(d):
A[alpha] = np.dot(X[alpha].core, np.transpose(X[alpha].u[2][ind_update_3,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [2,0,1]),np.transpose(X[alpha].u[1][row_order_U2,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [0,2,1]),np.transpose(X[alpha].u[0][row_order_U1,:]))
A[alpha] = np.transpose(A[alpha], [2,1,0])
Ar = np.concatenate((Ar_2, fun(A)), 2)
row_order_U3 = np.concatenate((row_order_U3, ind_update_3))
A1 = np.reshape(Ar, [r[0],-1], order='f')
A1 = np.transpose(A1)
column_order_update_U1 = tuck.mv.maxvol( schur_comp(A1, A1_11, A1_12, dtype) )
r_add[0] = len(column_order_update_U1)
A2 = np.reshape(np.transpose(Ar, [1,0,2]), [r[1],-1], order='f')
A2 = np.transpose(A2)
column_order_update_U2 = tuck.mv.maxvol( schur_comp(A2, A2_11, A2_12, dtype) )
r_add[1] = len(column_order_update_U2)
A3 = np.reshape(np.transpose(Ar, [2,0,1]), [r[2],-1], order='f')
A3 = np.transpose(A3)
column_order_update_U3 = tuck.mv.maxvol( schur_comp(A3, A3_11, A3_12, dtype) )
r_add[2] = len(column_order_update_U3)
u1_approx = np.zeros((n[0], r_add[0]), dtype=dtype)
u1 = np.zeros((n[0], r_add[0]), dtype=dtype)
for i in xrange(r_add[0]):
for alpha in xrange(d):
k1_order, j1_order = mod(column_order_update_U1[i], r[1])
A[alpha] = np.dot(X[alpha].core, np.transpose(X[alpha].u[2][row_order_U3[k1_order]:row_order_U3[k1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [2,0,1]),np.transpose(X[alpha].u[1][row_order_U2[j1_order]:row_order_U2[j1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [0,2,1]),np.transpose(X[alpha].u[0]), (2, 0))
A[alpha] = np.transpose(A[alpha], [2,1,0])[:,0,0]
u1[:,i] = fun(A)
u1_approx_i = np.dot(Ar, np.transpose(UU3[row_order_U3[k1_order]:row_order_U3[k1_order]+1,:]))
u1_approx_i = np.dot(np.transpose(u1_approx_i,[2,0,1]),np.transpose(UU2[row_order_U2[j1_order]:row_order_U2[j1_order]+1,:]))
u1_approx_i = np.tensordot(np.transpose(u1_approx_i,[0,2,1]),np.transpose(UU1), (2, 0))
u1_approx_i = np.transpose(u1_approx_i,[2,1,0])
u1_approx[:,i] = u1_approx_i[:, 0, 0]
u2_approx = np.zeros((n[1], r_add[1]), dtype=dtype)
u2 = np.zeros((n[1], r_add[1]), dtype=dtype)
for j in xrange(r_add[1]):
for alpha in xrange(d):
k1_order, i1_order = mod(column_order_update_U2[j], r[0])
A[alpha] = np.dot(X[alpha].core, np.transpose(X[alpha].u[2][row_order_U3[k1_order]:row_order_U3[k1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [2,1,0]), np.transpose(X[alpha].u[0][row_order_U1[i1_order]:row_order_U1[i1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [0,2,1]), np.transpose(X[alpha].u[1]), (2, 0))
A[alpha] = np.transpose(A[alpha], [1,2,0])[0,:,0]
u2[:,j] = fun(A)
u2_approx_j = np.dot(Ar,np.transpose(UU3[row_order_U3[k1_order]:row_order_U3[k1_order]+1,:]))
u2_approx_j = np.dot(np.transpose(u2_approx_j,[2,1,0]),np.transpose(UU1[row_order_U1[i1_order]:row_order_U1[i1_order]+1,:]))
u2_approx_j = np.tensordot(np.transpose(u2_approx_j,[0,2,1]),np.transpose(UU2), (2, 0))
u2_approx[:,j] = u2_approx_j[0, 0, :]
u3_approx = np.zeros((n[2], r_add[2]), dtype=dtype)
u3 = np.zeros((n[2], r_add[2]), dtype=dtype)
for k in xrange(r_add[2]):
for alpha in xrange(d):
j1_order, i1_order = mod(column_order_update_U3[k], r[0])
A[alpha] = np.dot(np.transpose(X[alpha].core, [2,1,0]),np.transpose(X[alpha].u[0][row_order_U1[i1_order]:row_order_U1[i1_order]+1,:]))
A[alpha] = np.dot(np.transpose(A[alpha], [0,2,1]),np.transpose(X[alpha].u[1][row_order_U2[j1_order]:row_order_U2[j1_order]+1,:]))
A[alpha] = np.tensordot(np.transpose(A[alpha], [1,2,0]),np.transpose(X[alpha].u[2]), (2, 0))[0,0,:]
u3[:,k] = fun(A)
u3_approx_k = np.dot(np.transpose(Ar,[2,1,0]),np.transpose(UU1[row_order_U1[i1_order]:row_order_U1[i1_order]+1,:]))
u3_approx_k = np.dot(np.transpose(u3_approx_k,[0,2,1]),np.transpose(UU2[row_order_U2[j1_order]:row_order_U2[j1_order]+1,:]))
u3_approx_k = np.tensordot(np.transpose(u3_approx_k,[1,2,0]),np.transpose(UU3), (2, 0))
u3_approx[:,k] = u3_approx_k[0, 0, :]
eps_cross = 1./3*( np.linalg.norm(u1_approx - u1)/ np.linalg.norm(u1) +
np.linalg.norm(u2_approx - u2)/ np.linalg.norm(u2) +
np.linalg.norm(u3_approx - u3)/ np.linalg.norm(u3) )
if pr <> None:
print 'relative accuracy = %s' % (eps_cross), 'ranks = %s' % r
if eps_cross < delta_cross:
break
elif r[0]>rmax:
print 'Rank has exceeded rmax value'
break
#print np.linalg.norm( full(G, U1, U2, U3) - C_toch )/np.linalg.norm(C_toch)
UU1, ind_update_1 = column_update(UU1, u1, row_order_U1)
UU2, ind_update_2 = column_update(UU2, u2, row_order_U2)
UU3, ind_update_3 = column_update(UU3, u3, row_order_U3)
U1 = np.concatenate((U1, u1), 1)
U2 = np.concatenate((U2, u2), 1)
U3 = np.concatenate((U3, u3), 1)
A1_11 = np.concatenate((A1_11, A1_12), 1)
A1_11 = np.concatenate((A1_11, A1[column_order_update_U1,:]) )
A2_11 = np.concatenate((A2_11, A2_12), 1)
A2_11 = np.concatenate((A2_11, A2[column_order_update_U2,:]) )
A3_11 = np.concatenate((A3_11, A3_12), 1)
A3_11 = np.concatenate((A3_11, A3[column_order_update_U3,:]) )
A1_12 = U1[ind_update_1, r_add[0]:].T
A2_12 = U2[ind_update_2, r_add[1]:].T
A3_12 = U3[ind_update_3, r_add[2]:].T
r[0] = r[0]+r_add[0]
r[1] = r[1]+r_add[1]
r[2] = r[2]+r_add[2]
U1, R1 = np.linalg.qr(UU1)
U2, R2 = np.linalg.qr(UU2)
U3, R3 = np.linalg.qr(UU3)
GG = np.tensordot(np.transpose(Ar,[2,1,0]),np.transpose(R1), (2, 0))
GG = np.tensordot(np.transpose(GG,[0,2,1]),np.transpose(R2), (2, 0))
GG = np.transpose(GG,[1,2,0])
G = np.tensordot(GG,np.transpose(R3), (2, 0))
G_Tucker = tuck.tensor(G, delta_cross)
if pr <> None:
print 'ranks after rounding = %s' % G_Tucker.r[0], G_Tucker.r[1], G_Tucker.r[2]
fun = tuck.tensor()
fun.core = G_Tucker.core
fun.u[0] = np.dot(U1, G_Tucker.u[0])
fun.u[1] = np.dot(U2, G_Tucker.u[1])
fun.u[2] = np.dot(U3, G_Tucker.u[2])
fun.r = G_Tucker.r
fun.n = n
return fun
def gto2tuck(w, cf, x, eps):
n = len(x)
r = len(cf)
k = 0
for alpha in xrange(r):
k += len(w[alpha].prims)
U1 = np.zeros((n, k * r))
U2 = np.zeros((n, k * r))
U3 = np.zeros((n, k * r))
c = np.zeros(k * r)
nG = 0
for alpha in xrange(r):
for beta in xrange(len(w[alpha].prims)):
prim = w[alpha].prims[beta]
i, j, k = prim.powers
x0, y0, z0 = prim.origin
#print [x0,y0,z0]
U1[:, beta + nG] = pow(x - x0, i) * np.exp(-prim.exp * (x - x0)**2)
U2[:, beta + nG] = pow(x - y0, j) * np.exp(-prim.exp * (x - y0)**2)
U3[:, beta + nG] = pow(x - z0, k) * np.exp(-prim.exp * (x - z0)**2)
c[beta + nG] = w[alpha].norm * prim.norm * prim.coef * cf[alpha]
nG += len(w[alpha].prims)
u1, v1 = tuck.cross.cross2d_full(U1, eps)
u2, v2 = tuck.cross.cross2d_full(U2, eps)
u3, v3 = tuck.cross.cross2d_full(U3, eps)
v1 = np.real(H(v1))
v2 = np.real(H(v2))
v3 = np.real(H(v3))
r1 = v1.shape[0]
r2 = v2.shape[0]
r3 = v3.shape[0]
maxrank = max([r1, r2, r3])
core = np.zeros((maxrank, maxrank, maxrank))
for a1 in xrange(r1):
for a2 in xrange(r2):
for a3 in xrange(r3):
for a in xrange(len(c)):
core[a1, a2,
a3] += c[a] * v1[a1, a] * v2[a2, a] * v3[a3, a]
u1_new = np.zeros((n, maxrank))
u2_new = np.zeros((n, maxrank))
u3_new = np.zeros((n, maxrank))
u1_new[:, :r1] = u1
u2_new[:, :r2] = u2
u3_new[:, :r3] = u3
b = tuck.tensor()
b.core = core.copy()
b.u[0] = np.real(u1_new)
b.u[1] = np.real(u2_new)
b.u[2] = np.real(u3_new)
b.r = core.shape
b.n = (n, n, n)
return b
def cross3d(func, M, eps_init, delta_add = 1e-5):
N = int((M+1)/2)
r1 = 2
r2 = 2
r3 = 2
GG = np.zeros((r1,r2,r3),dtype=np.complex128)
U1 = np.zeros((M,r1),dtype=np.complex128)
U2 = np.zeros((M,r2),dtype=np.complex128)
U3 = np.zeros((M,r3),dtype=np.complex128)
U1[:N,:] = np.random.random((N,r1))
U2[:N,:] = np.random.random((N,r2))
U3[:N,:] = np.random.random((N,r3))
U1, R = np.linalg.qr(U1)
U2, R = np.linalg.qr(U2)
U3, R = np.linalg.qr(U3)
eps_cross = 1
while True:
row_order_U1 = tuck.mv.maxvol(U1)
row_order_U2 = tuck.mv.maxvol(U2)
row_order_U3 = tuck.mv.maxvol(U3)
Ar = np.zeros((r1,r2,r3),dtype=np.complex128)
for i in xrange(r1):
for j in xrange(r2):
for k in xrange(r3):
Ar[i,j,k] = func((row_order_U1[i],row_order_U2[j],row_order_U3[k]))
U1_r = U1[row_order_U1,:]
U2_r = U2[row_order_U2,:]
U3_r = U3[row_order_U3,:]
G_UV = np.linalg.solve(U3_r,np.reshape(np.transpose(Ar,[2,0,1]),(r3,r1*r2),order='f'))
G_UV = np.reshape(G_UV,(r3,r1,r2),order='f')
G_UV = np.transpose(G_UV,[1,2,0])
G_U = np.linalg.solve(U2_r,np.reshape(np.transpose(G_UV,[1,2,0]),(r2,r1*r3),order='f'))
G_U = np.reshape(G_U,(r2,r3,r1),order='f')
G_U = np.transpose(G_U,[2,0,1])
G = np.linalg.solve(U1_r,np.reshape(G_U,(r1,r2*r3),order='f'))
G = np.reshape(G,(r1,r2,r3),order='f')
norm = np.linalg.norm(G)
eps_cross = (np.linalg.norm(GG-G))/norm
#print 'relative accuracy = %s' % (eps_cross), 'ranks = %s' % r1, r2, r3
G_Tucker = tuck.tensor(G, eps_init/10)
G = G_Tucker.core
U1 = np.dot(U1, G_Tucker.u[0])
U2 = np.dot(U2, G_Tucker.u[1])
U3 = np.dot(U3, G_Tucker.u[2])
(r1, r2, r3) = G_Tucker.r
if eps_cross < eps_init:
break
row_order_U1 = tuck.mv.maxvol(U1)
row_order_U2 = tuck.mv.maxvol(U2)
row_order_U3 = tuck.mv.maxvol(U3)
Ar = np.zeros((r1,r2,r3),dtype=np.complex128)
for i in xrange(r1):
for j in xrange(r2):
for k in xrange(r3):
Ar[i, j, k] = func((row_order_U1[i], row_order_U2[j], row_order_U3[k]))
A1 = np.reshape(Ar, [r1,-1], order='f')
A1_r = np.transpose(A1)
A1_r,R = np.linalg.qr(A1_r)
column_order_U1 = tuck.mv.maxvol(A1_r)
A2 = np.reshape(np.transpose(Ar, [1,0,2]), [r2,-1], order='f')
A2_r = np.transpose(A2)
A2_r,R = np.linalg.qr(A2_r)
column_order_U2 = tuck.mv.maxvol(A2_r)
A3 = np.reshape(np.transpose(Ar, [2,0,1]), [r3,-1], order='f')
A3_r = np.transpose(A3)
A3_r,R = np.linalg.qr(A3_r)
column_order_U3 = tuck.mv.maxvol(A3_r)
u1 = np.zeros((M, r1), dtype=np.complex128)
for i in xrange(r1):
for ii in xrange(M):
k1_order, j1_order = mod(column_order_U1[i], r2)
u1[ii,i] = func((ii, row_order_U2[j1_order], row_order_U3[k1_order]))
u2 = np.zeros((M, r2), dtype=np.complex128)
for j in xrange(r2):
for jj in xrange(M):
k1_order, i1_order = mod(column_order_U2[j], r1)
u2[jj,j] = func((row_order_U1[i1_order], jj, row_order_U3[k1_order]))
u3 = np.zeros((M, r3), dtype=np.complex128)
for k in xrange(r3):
for kk in xrange(M):
j1_order, i1_order = mod(column_order_U3[k], r1)
u3[kk,k] = func((row_order_U1[i1_order], row_order_U2[j1_order], kk))
u1, v, r11 = round_matrix(u1, delta_add)
u2, v, r22 = round_matrix(u2, delta_add)
u3, v, r33 = round_matrix(u3, delta_add)
u1 = u1[:,:r11]
u2 = u2[:,:r22]
u3 = u3[:,:r33]
U1_0 = np.zeros((M,r1+r11),dtype=np.complex128)
U2_0 = np.zeros((M,r2+r22),dtype=np.complex128)
U3_0 = np.zeros((M,r3+r33),dtype=np.complex128)
U1_0[:,:r1] = U1.copy()
U2_0[:,:r2] = U2.copy()
U3_0[:,:r3] = U3.copy()
U1_0[:,r1:r1+r11] = u1
U2_0[:,r2:r2+r22] = u2
U3_0[:,r3:r3+r33] = u3
U1 = U1_0.copy()
U2 = U2_0.copy()
U3 = U3_0.copy()
r1 = r1+r11
r2 = r2+r22
r3 = r3+r33
U1, R1 = np.linalg.qr(U1)
U2, R2 = np.linalg.qr(U2)
U3, R3 = np.linalg.qr(U3)
GG = np.zeros((r1,r2,r3),dtype=np.complex128)
GG[:(r1-r11),:(r2-r22),:(r3-r33)] = G.copy()
GG = np.dot(np.transpose(GG,[2,1,0]),np.transpose(R1))
GG = np.dot(np.transpose(GG,[0,2,1]),np.transpose(R2))
GG = np.transpose(GG,[1,2,0])
GG = np.dot(GG,np.transpose(R3))
#print 'ranks after rounding = %s' % r1, r2, r3
G_Tucker.n = (M, M, M)
G_Tucker.u[0] = U1
G_Tucker.u[1] = U2
G_Tucker.u[2] = U3
G_Tucker.r = [r1, r2, r3]
return tuck.round(G_Tucker, eps_init)
