def test_dmrg(self):
sym1 = ['++-', [ni, nj, nk], None, None]
sym2 = ['++-', [nk, nl, nm], None, None]
sym3 = ['++--', [nn, no, nj, nl], None, None]
sym4 = ['++-', [ni, nn, np], None, None]
ijk = random.random([
nbond,
] * 3, sym1)
klm = random.random([
nbond,
] * 3, sym2)
nojl = random.random([
nbond,
] * 4, sym3)
inp = random.random([
nbond,
] * 3, sym4)
pom = einsum('ijk,klm,nojl,inp->pom', ijk, klm, nojl, inp)
ijlm = einsum('ijk,klm->ijlm', ijk, klm)
inom = einsum('ijlm,nojl->inom', ijlm, nojl)
pom1 = einsum('inom,inp->pom', inom, inp)
self.assertTrue((pom - pom1).norm() < thresh)
def test_453(self):
ni = range(0, 6)
nj = range(0, 3)
nk = range(1, 6)
nl = range(0, 3)
nm = range(0, 3)
nn = range(0, 6)
sym1 = ['++--', [ni, nj, nk, nl], None, None]
sym2 = ['-++--', [nj, nk, nl, nm, nn], None, None]
ijkl = random.random([
nbond,
] * 4, sym1)
jklmn = random.random([
nbond,
] * 5, sym2)
imn = einsum('ijkl,jklmn->imn', ijkl, jklmn)
ijkl_dense, jklmn_dense = ijkl.make_dense(), jklmn.make_dense()
imn_dense = einsum('IJKLijkl,JKLMNjklmn->IMNimn', ijkl_dense,
jklmn_dense)
imn_sparse = einsum('IMNimn,IMN->IMimn', imn_dense,
imn.get_irrep_map())
diff = (imn - imn_sparse).norm() / numpy.sqrt(imn_sparse.size)
self.assertTrue(diff < thresh)
def test_440(self):
ijab = random.random([nocc,nocc,nvir,nvir], sym_phys)
ijba = random.random([nocc,nocc,nvir,nvir], sym_phys)
ijab_dense, ijba_dense = ijab.make_dense(), ijba.make_dense()
X = einsum('IJABijab,IJBAijba->', ijab_dense, ijba_dense)
X1 = einsum('ijab,ijba->', ijab, ijba)
diff = abs(X-X1)
self.assertTrue(diff<thresh)
def test_224(self):
A = random.random([nocc,nvir],sym_t1)
B = random.random([nocc,nvir],sym_t1)
A_dense, B_dense = A.make_dense(), B.make_dense()
X = einsum('IAia,JBjb->IJABijab', A_dense, B_dense)
X = einsum('IJABijab,JB->IJAijab', X, A.get_irrep_map())
X1 = einsum('ia,jb->ijab', A, B)
diff = (X1-X).norm() / np.sqrt(X.size)
self.assertTrue(diff<thresh)
def test_231(self):
ld = random.random([nocc,nvir], sym_t1)
ild = random.random([nocc,nocc,nvir], sym_eom)
ld_dense, ild_dense = ld.make_dense(), ild.make_dense()
X1 = einsum('ld,ild->i', ld, ild)
X = einsum('LDld,ILDild->Ii', ld_dense, ild_dense)
X = einsum('Ii,I->i', X, X1.get_irrep_map())
diff = (X1-X).norm() / np.sqrt(X.size)
self.assertTrue(diff<thresh)
def test_244(self):
A = random.random([nocc,nvir], sym_t1)
B = random.random([nocc,nvir,nocc,nocc], sym_chem)
C = random.random([nocc,nvir,nvir,nvir], sym_chem)
A_dense, B_dense, C_dense = A.make_dense(), B.make_dense(), C.make_dense()
X1 = einsum('kclj,ic->klij', B, A)
X = einsum('KCLJkclj,ICic->KLIJklij', B_dense, A_dense)
X = einsum('KLIJklij,KLIJ->KLIklij', X, X1.get_irrep_map())
diff = (X1-X).norm() / np.sqrt(X.size)
self.assertTrue(diff<thresh)
Y1 = einsum('lcki,jc->klij', B, A)
Y = einsum('LCKIlcki,JCjc->KLIJklij', B_dense, A_dense)
Y = einsum('KLIJklij,KLIJ->KLIklij', Y, Y1.get_irrep_map())
diff = (Y1-Y).norm() / np.sqrt(Y.size)
self.assertTrue(diff<thresh)
Z1 = einsum('kcad,id->akic', C, A)
Z = einsum('KCADkcad,IDid->AKICakic', C_dense, A_dense)
Z = einsum('AKICakic,AKIC->AKIakic', Z, Z1.get_irrep_map())
diff = (Z1-Z).norm() / np.sqrt(Z.size)
self.assertTrue(diff<thresh)
def test_413(self):
c = random.random([nvir], sym_s)
ijcb = random.random([nocc,nocc,nvir,nvir], sym_phys)
c_dense, ijcb_dense = c.make_dense(), ijcb.make_dense()
X1 = einsum('c,ijcb->ijb', c, ijcb)
X = einsum('Cc,IJCBijcb->IJBijb', c_dense, ijcb_dense)
X = einsum('IJBijb,IJB->IJijb',X,X1.get_irrep_map())
diff = (X1-X).norm() / np.sqrt(X.size)
self.assertTrue(diff<thresh)
def test_242(self):
A = random.random([nocc,nvir],sym_t1)
B = random.random([nocc,nocc,nvir,nvir],sym_phys)
A_dense, B_dense = A.make_dense(), B.make_dense()
X = einsum('KCkc,KICAkica->IAia', A_dense, B_dense)
X = einsum('IAia,IA->Iia', X, A.get_irrep_map())
X1 = einsum('kc,kica->ia', A, B)
diff = (X1-X).norm() / np.sqrt(X.size)
self.assertTrue(diff<thresh)
def test_211(self):
ki = random.random([nocc,nocc], sym_t1)
k = random.random([nocc], sym_s)
ki_dense, k_dense = ki.make_dense(), k.make_dense()
X1 = einsum('ki,k->i',ki, k)
X = einsum('KIki,Kk->Ii', ki_dense, k_dense)
X = einsum('Ii,I->i', X, X1.get_irrep_map())
diff = (X1-X).norm() / np.sqrt(X.size)
self.assertTrue(diff<thresh)
def test_433(self):
sym1 = ['+++-', [ni, nn, no, nm], None, None]
sym2 = ['++-', [ni, nn, np], None, None]
inom = random.random([
nbond,
] * 4, sym1)
inp = random.random([
nbond,
] * 3, sym2)
pom = einsum('inom,inp->pom', inom, inp)
inom_dense, inp_dense = inom.make_dense(), inp.make_dense()
pom_dense = einsum('INOMinom,INPinp->POMpom', inom_dense, inp_dense)
pom_sparse = einsum('POMpom,POM->POpom', pom_dense,
pom.get_irrep_map())
diff = (pom - pom_sparse).norm() / numpy.sqrt(pom_sparse.size)
self.assertTrue(diff < thresh)
def test_cc(self):
sym1 = ["+-", [[-1, 1]] * 2, None, None]
sym2 = ["++--", [[-1, 1]] * 4, None, None]
ie = random.random([nbond] * 2, sym1)
ijab = random.random([nbond] * 4, sym2)
abcd = random.random([nbond] * 4, sym2)
ejcd = einsum('ie,ijab,abcd->ejcd', ie, ijab, abcd)
ejab = einsum('ie,ijab->ejab', ie, ijab)
ejcd1 = einsum('ejab,abcd->ejcd', ejab, abcd)
ijcd = einsum('ijab,abcd->ijcd', ijab, abcd)
ejcd2 = einsum('ie,ijcd->ejcd', ie, ijcd)
self.assertTrue((ejcd - ejcd1).norm() < thresh)
self.assertTrue((ejcd - ejcd2).norm() < thresh)
def test_334(self):
# symtensor contraction
sym1 = ['++-', [ni, nj, nk], None, None]
sym2 = ['++-', [nk, nl, nm], None, None]
ijk = random.random([
nbond,
] * 3, sym1)
klm = random.random([
nbond,
] * 3, sym2)
ijlm = einsum('ijk,klm->ijlm', ijk, klm)
# sparse tensor contraction
ijk_dense, klm_dense = ijk.make_dense(), klm.make_dense()
ijlm_dense = einsum('IJKijk,KLMklm->IJLMijlm', ijk_dense, klm_dense)
ijlm_sparse = einsum('IJLMijlm,IJLM->IJLijlm', ijlm_dense,
ijlm.get_irrep_map())
diff = (ijlm - ijlm_sparse).norm() / numpy.sqrt(ijlm_sparse.size)
self.assertTrue(diff < thresh)
def test_444(self):
numpy.random.seed(3)
sym1 = ['+++-', [ni, nj, nl, nm], None, None]
sym2 = ['++--', [nn, no, nj, nl], None, None]
ijlm = random.random([
nbond,
] * 4, sym1)
nojl = random.random([
nbond,
] * 4, sym2)
inom = einsum('ijlm,nojl->inom', ijlm, nojl)
equal = symlib.check_sym_equal(sym1, sym2)
ijlm_dense, nojl_dense = ijlm.make_dense(), nojl.make_dense()
inom_dense = einsum('IJLMijlm,NOJLnojl->INOMinom', ijlm_dense,
nojl_dense)
inom_sparse = einsum('INOMinom,INOM->INOinom', inom_dense,
inom.get_irrep_map())
diff = (inom - inom_sparse).norm() / numpy.sqrt(inom_sparse.size)
self.assertTrue(diff < thresh)
def test_hprd(self):
A = random.random([no, no, nv, nv, nmode],
sym=["++--0", [ran] * 4, None, None])
B = random.random([nv, nv, nv, nmode, nv],
sym=["++-0-", [ran] * 4, None, None])
C = einsum('ijcdx,abcxd->ijabx', A, B)
out = np.zeros(C.array.shape)
for ki, kj, kc, ka in itertools.product(ran, repeat=4):
kd = ki + kj - kc
kb = kc + kd - ka
if kd not in ran or kb not in ran: continue
out[ki, kj, ka] += np.einsum('ijcdx,abcxd->ijabx',
A.array[ki, kj, kc], B.array[ka, kb,
kc])
self.assertTrue(np.amax(C.array - out) < thresh)
def test_444(self):
B = random.random([nocc,nvir,nocc,nvir], sym_chem)
C = random.random([nocc,nocc,nvir,nvir], sym_phys)
D = random.random([nvir,nvir,nvir,nvir], sym_phys)
B_dense, C_dense, D_dense = B.make_dense(), C.make_dense(), D.make_dense()
X1 = einsum('kcld,ijcd->klij', B, C)
X = einsum('KCLDkcld,IJCDijcd->KLIJklij', B_dense, C_dense)
X = einsum('KLIJklij,KLIJ->KLIklij', X, X1.get_irrep_map())
diff = (X1-X).norm() / np.sqrt(X.size)
self.assertTrue(diff<thresh)
Y1 = einsum('ldkc,ilda->akic', B, C)
Y = einsum('LDKCldkc,ILDAilda->AKICakic', B_dense, C_dense)
Y = einsum('AKICakic,AKIC->AKIakic', Y, Y1.get_irrep_map())
diff = (Y1-Y).norm() / np.sqrt(Y.size)
self.assertTrue(diff<thresh)
Z1 = einsum('abcd,ijcd->ijab', D, C)
Z = einsum('ABCDabcd,IJCDijcd->IJABijab', D_dense, C_dense)
Z = einsum('IJABijab,IJAB->IJAijab', Z, Z1.get_irrep_map())
diff = (Z1-Z).norm() / np.sqrt(Z.size)
self.assertTrue(diff<thresh)
def test_222(self):
A = random.random([nocc,nocc],sym_t1)
B = random.random([nocc,nvir],sym_t1)
C = random.random([nvir,nvir],sym_t1)
A_dense, B_dense, C_dense = A.make_dense(), B.make_dense(), C.make_dense()
X = einsum('ACac,ICic->IAia', C_dense, B_dense)
X = einsum('IAia,IA->Iia', X, A.get_irrep_map())
X1 = einsum('ac,ic->ia', C, B)
diff = (X1-X).norm() / np.sqrt(X.size)
self.assertTrue(diff<thresh)
Y = einsum('KIki,KAka->IAia', A_dense, B_dense)
Y = einsum('IAia,IA->Iia', Y, A.get_irrep_map())
Y1 = einsum('ki,ka->ia', A, B)
diff = (Y1-Y).norm() / np.sqrt(Y.size)
self.assertTrue(diff<thresh)
def test_442(self):
A = random.random([nocc,nvir,nocc,nvir], sym_chem)
B = random.random([nocc,nocc,nvir,nvir], sym_phys)
C = random.random([nocc,nvir,nvir,nvir], sym_chem)
A_dense, B_dense, C_dense = A.make_dense(), B.make_dense(), C.make_dense()
X1 = einsum('kcld,ilcd->ki', A, B)
X = einsum('KCLDkcld,ILCDilcd->KIki', A_dense, B_dense)
X = einsum('KIki,KI->Kki', X, X1.get_irrep_map())
diff = (X1-X).norm() / np.sqrt(X.size)
self.assertTrue(diff<thresh)
Y1 = einsum('kdac,ikcd->ia', C, B)
Y = einsum('KDACkdac,IKCDikcd->IAia', C_dense, B_dense)
Y = einsum('IAia,IA->Iia', Y, Y1.get_irrep_map())
diff = (Y1-Y).norm() / np.sqrt(Y.size)
self.assertTrue(diff<thresh)
def test_233(self):
bd = random.random([nvir,nvir], sym_t1)
ijd = random.random([nocc,nocc,nvir], sym_eom)
ki = random.random([nocc,nocc], sym_t1)
kjb = random.random([nocc,nocc,nvir], sym_eom)
bd_dense, ijd_dense, ki_dense, kjb_dense = bd.make_dense(), ijd.make_dense(), ki.make_dense(), kjb.make_dense()
X1 = einsum('bd,ijd->ijb', bd, ijd)
X = einsum('BDbd,IJDijd->IJBijb', bd_dense, ijd_dense)
X = einsum('IJBijb,IJB->IJijb', X, X1.get_irrep_map())
diff = (X1-X).norm() / np.sqrt(X.size)
self.assertTrue(diff<thresh)
Y1 = einsum('ki,kjb->ijb', ki, kjb)
Y = einsum('KIki,KJBkjb->IJBijb', ki_dense, kjb_dense)
Y = einsum('IJBijb,IJB->IJijb', Y, Y1.get_irrep_map())
diff = (Y1-Y).norm() / np.sqrt(Y.size)
self.assertTrue(diff<thresh)
def test_343(self):
klij = random.random([nocc,nocc,nocc,nocc], sym_phys)
klb = random.random([nocc,nocc,nvir], sym_eom)
lbdj = random.random([nocc,nvir,nvir,nocc], sym_phys)
ild = random.random([nocc,nocc,nvir], sym_eom)
klij_dense, klb_dense, lbdj_dense, ild_dense = klij.make_dense(), klb.make_dense(), lbdj.make_dense(), ild.make_dense()
X1 = einsum('klij,klb->ijb', klij, klb)
X = einsum('KLIJklij,KLBklb->IJBijb', klij_dense, klb_dense)
X = einsum('IJBijb,IJB->IJijb', X, X1.get_irrep_map())
diff = (X1-X).norm() / np.sqrt(X.size)
self.assertTrue(diff<thresh)
Y1 = einsum('lbdj,ild->ijb', lbdj, ild)
Y = einsum('LBDJlbdj,ILDild->IJBijb', lbdj_dense, ild_dense)
Y = einsum('IJBijb,IJB->IJijb', Y, Y1.get_irrep_map())
diff = (Y1-Y).norm() / np.sqrt(Y.size)
self.assertTrue(diff<thresh)
def test_431(self):
lkdc = random.random([nocc,nocc,nvir,nvir], sym_phys)
kld = random.random([nocc,nocc,nvir], sym_eom)
kldc = random.random([nocc,nocc,nvir,nvir], sym_phys)
lkdc_dense, kld_dense, kldc_dense = lkdc.make_dense(), kld.make_dense(), kldc.make_dense()
X1 = einsum('lkdc,kld->c', lkdc, kld)
X = einsum('LKDClkdc,KLDkld->Cc', lkdc_dense, kld_dense)
X = einsum('Cc,C->c', X, X1.get_irrep_map())
diff = (X1-X).norm() / np.sqrt(X.size)
self.assertTrue(diff<thresh)
Y1 = einsum('kldc,kld->c', kldc, kld)
Y = einsum('KLDCkldc,KLDkld->Cc', kldc_dense, kld_dense)
Y = einsum('Cc,C->c', Y, Y1.get_irrep_map())
diff = (Y1-Y).norm() / np.sqrt(Y.size)
self.assertTrue(diff<thresh)
nd = len(arrays)
dims = [nd] + [len(x) for x in arrays]
out = np.ndarray(dims)
shape = [-1] + [1] * nd
for i, arr in enumerate(arrays):
out[i] = arr.reshape(shape[:nd - i])
scaled_kpts = out.reshape(nd, -1).T
gvec = get_reciprocal_vectors(lattice)
kpts = np.dot(scaled_kpts, gvec)
return kpts
def get_reciprocal_vectors(lattice):
b = np.linalg.inv(lattice.T)
return 2 * np.pi * b
lattice = np.eye(3) * 5
kpts = make_kpts(lattice, [2, 2, 1])
gvec = get_reciprocal_vectors(lattice)
nkpts, nmo = len(kpts), 10
sym = ['++--', [
kpts,
] * 4, None, gvec]
Aarray = np.random.random([nkpts, nkpts, nkpts, nmo, nmo, nmo, nmo])
Barray = np.random.random([nkpts, nkpts, nkpts, nmo, nmo, nmo, nmo])
A = array(Aarray, sym, verbose=1)
B = array(Barray, sym, verbose=1)
out = einsum('ijab,abcd->ijcd', A, B)
#!/usr/bin/env python
#
# Author: Yang Gao <*****@*****.**>
#
'''
Simple tensor contraction with 1D symmetry
'''
import numpy as np
from symtensor import array, einsum
ni = np.arange(0,3)
nj = np.arange(0,4)
nk = np.arange(1,5)
nl = np.arange(0,1)
nm = np.arange(0,5)
nbond = 20
sym_ijk = ['++-', [ni,nj,nk], None, None] # I + J - K = 0
sym_klm = ['++-', [nk,nl,nm], None, None] # K + L - M = 0
ijk_array = np.random.random([len(ni),len(nj),nbond,nbond,nbond])
klm_array = np.random.random([len(nk),len(nl),nbond,nbond,nbond])
ijk = array(ijk_array, sym_ijk, verbose=1)
klm = array(klm_array, sym_klm, verbose=1)
ijlm = einsum('ijk,klm->ijlm',ijk,klm)
