def test_qr(self):
Q, R = snp.qr(self.tens, [0, 1, 2], [3, 4, 5])
QR = snp.tensordot(Q, R, ([3], [0]))
QR.__squeeze__()
diff1 = set(self.tens.__keys__()).difference(QR.__keys__())
diff2 = set(QR.__keys__()).difference(self.tens.__keys__())
self.assertTrue(len(diff1) == 0)
self.assertTrue(len(diff2) == 0)
for k in self.tens._tensor.keys():
self.assertTrue(
np.linalg.norm(self.tens[k] - QR[k]) /
utils.prod(QR[k].shape) < self.eps)
for k in QR._tensor.keys():
self.assertTrue(
np.linalg.norm(self.tens[k] - QR[k]) /
utils.prod(QR[k].shape) < self.eps)
unit = snp.tensordot(Q, snp.conj(Q), ([0, 1, 2], [0, 1, 2]))
for k in unit._tensor.keys():
self.assertTrue(
np.linalg.norm(unit[k] - np.eye(unit[k].shape[0])) /
utils.prod(unit[k].shape) < self.eps)
def test_eye(self):
ind = self.rank - 1
eye1 = self.tens.__eye__(ind, 0)
eye2 = self.tens.__eye__(ind, 1)
r1 = snp.tensordot(self.tens, eye1, ([ind], [0]))
r2 = snp.tensordot(self.tens, eye2, ([ind], [1]))
diff1 = set(r1.__keys__()).difference(self.tens.__keys__())
diff2 = set(self.tens.__keys__()).difference(r1.__keys__())
self.assertTrue(len(diff1) == 0)
self.assertTrue(len(diff2) == 0)
diff1 = set(r2.__keys__()).difference(self.tens.__keys__())
diff2 = set(self.tens.__keys__()).difference(r2.__keys__())
self.assertTrue(len(diff1) == 0)
self.assertTrue(len(diff2) == 0)
for k in r1._tensor.keys():
self.assertTrue(
np.linalg.norm(r1[k] - self.tens[k]) /
utils.prod(self.tens[k].shape) < self.eps)
for k in r2._tensor.keys():
self.assertTrue(
np.linalg.norm(r2[k] - self.tens[k]) /
utils.prod(self.tens[k].shape) < self.eps)
def test_random(self):
ind = self.rank - 1
rand1 = self.tens.__random__(ind, 0)
rand2 = self.tens.__random__(ind, 1)
r1 = snp.tensordot(self.tens, rand1, ([ind], [0]))
r2 = snp.tensordot(self.tens, rand2, ([ind], [1]))
diff1 = set(r1.__keys__()).difference(self.tens.__keys__())
diff2 = set(self.tens.__keys__()).difference(r1.__keys__())
self.assertTrue(len(diff1) == 0)
self.assertTrue(len(diff2) == 0)
diff1 = set(r2.__keys__()).difference(self.tens.__keys__())
diff2 = set(self.tens.__keys__()).difference(r2.__keys__())
self.assertTrue(len(diff1) == 0)
self.assertTrue(len(diff2) == 0)
def test_norm(self):
Z1 = self.tens.__norm__()
Z2 = np.sqrt(
list(
snp.tensordot(self.tens, snp.conj(self.tens),
(range(self.tens._rank), range(
self.tens._rank)))._tensor.values())[0])
self.assertTrue(np.abs(Z1 - Z2) < self.eps)
def __normalize__(self):
Z = list(
snp.tensordot(
self, snp.conj(self),
(range(self._rank), range(self._rank)))._tensor.values())[0]
for k in self._tensor:
t = self._tensor[k]
self._tensor[k] = t / Z
def test_qr_merged(self):
merged = snp.merge(self.tens, [0, 1], [4, 5])
Q, R = snp.qr(merged, [0, 1], [2, 3])
#print
#print 'merged:',
#print 'qflow:',merged._qflow
#print 'mergelevel:',merged._mergelevel
#print 'charge:',merged.__charge__().values()
#
#print 'Q:'
#print 'qflow:',Q._qflow
#print 'mergelevel:',Q._mergelevel
#print 'charge:',sorted(Q.__charge__().values())
#print
#
#print 'R:'
#print 'qflow:',R._qflow
#print 'mergelevel:',R._mergelevel
#print 'charge:',sorted(R.__charge__().values())
#print
QR = snp.tensordot(Q, R, ([2], [0]))
QR.__squeeze__()
diff1 = set(merged.__keys__()).difference(QR.__keys__())
diff2 = set(QR.__keys__()).difference(merged.__keys__())
self.assertTrue(len(diff1) == 0)
self.assertTrue(len(diff2) == 0)
for k in merged._tensor.keys():
self.assertTrue(
np.linalg.norm(merged[k] - QR[k]) /
utils.prod(QR[k].shape) < self.eps)
for k in QR._tensor.keys():
self.assertTrue(
np.linalg.norm(merged[k] - QR[k]) /
utils.prod(QR[k].shape) < self.eps)
unit = snp.tensordot(Q, snp.conj(Q), ([0, 1], [0, 1]))
for k in unit._tensor.keys():
self.assertTrue(
np.linalg.norm(unit[k] - np.eye(unit[k].shape[0])) /
utils.prod(unit[k].shape) < self.eps)
def test_tensordot(self):
inds = random.sample(range(self.rank),
random.sample(range(1, self.rank + 1), 1)[0])
r = snp.tensordot(self.tens,
self.tens, (inds, inds),
ignore_qflow=True)
full = self.tens.__tondarray__()
rfull = np.tensordot(full, full, (inds, inds))
self.assertTrue(np.linalg.norm(rfull - r.__tondarray__()) < 1E-10)
shapes = r.__shapes__()
for k in shapes:
self.assertTrue(tuple(shapes[k]) == r[k].shape)
def test_svd_merged(self):
merged = snp.merge(self.tens, [0, 1], [4, 5])
U, S, V = snp.svd(merged, [0, 1], [2, 3])
Z = S.__norm__()
merged /= Z
S /= Z
S.__squeeze__()
US = snp.tensordot(U, S, ([2], [0]))
USV = snp.tensordot(US, V, ([2], [0]))
USV.__squeeze__()
diff1 = set(merged._tensor.keys()).difference(USV._tensor.keys())
diff2 = set(USV._tensor.keys()).difference(merged._tensor.keys())
self.assertTrue(len(diff1) == 0)
self.assertTrue(len(diff2) == 0)
for k in merged._tensor.keys():
self.assertTrue(
np.linalg.norm(merged[k] - USV[k]) /
utils.prod(USV[k].shape) < self.eps)
for k in USV._tensor.keys():
self.assertTrue(
np.linalg.norm(merged[k] - USV[k]) /
utils.prod(USV[k].shape) < self.eps)
unitU = snp.tensordot(U, snp.conj(U), ([0, 1], [0, 1]))
for k in unitU._tensor.keys():
self.assertTrue(
np.linalg.norm(unitU[k] - np.eye(unitU[k].shape[0])) /
utils.prod(unitU[k].shape) < self.eps)
unitV = snp.tensordot(V, snp.conj(V), ([1, 2], [1, 2]))
for k in unitV._tensor.keys():
self.assertTrue(
np.linalg.norm(unitV[k] - np.eye(unitV[k].shape[0])) /
utils.prod(unitV[k].shape) < self.eps)
def test_tensordot_merged(self):
num = random.sample(range(self.rank - 1), 1)[0]
inds = random.sample(range(self.rank - 1),
random.sample(range(1, self.rank), 1)[0])
tens = snp.mergeSingle(self.tens, [num, num + 1])
r = snp.tensordot(tens, tens, (inds, inds), ignore_qflow=True)
full = tens.__tondarray__()
rfull = np.tensordot(full, full, (inds, inds))
self.assertTrue(np.linalg.norm(rfull - r.__tondarray__()) < 1E-10)
shapes = r.__shapes__()
for k in shapes:
self.assertTrue(
utils.prod(utils.flatten(tuple(shapes[k]))) == utils.prod(
r[k].shape))
def test_tensordot_merged_2(self):
N = 5
rank = 8
keys = []
outind = random.sample(range(rank), 1)[0]
for n in range(N):
key = random.sample(range(20), rank - 1)
key.insert(outind, sum(key))
keys.append(tuple(key))
Ds = [dict() for n in range(rank)]
for n in range(rank):
for k in keys:
Ds[n][k[n]] = random.sample(range(2, 8), 1)[0]
values = []
for k in keys:
size = tuple([])
for n in range(rank):
size += tuple([Ds[n][k[n]]])
values.append(np.random.rand(*size))
l = [1] * rank
l[outind] = -1
qflow = tuple(l)
tens = spt.SparseTensor(keys=keys,
values=values,
Ds=Ds,
qflow=qflow,
mergelevel=None,
dtype=self.tens._dtype)
eps = 1E-12
tens1 = snp.merge(tens, [0, 1], [3, 4])
tens2 = snp.merge(tens1, [0, 1], [3, 4, 5])
inds = [1, 2]
r = snp.tensordot(tens2, tens2, (inds, inds), ignore_qflow=True)
shapes = r.__shapes__()
for k in shapes:
self.assertTrue(
utils.prod(utils.flatten(tuple(shapes[k]))) == utils.prod(
r[k].shape))
def TensDotProf(a, b, inds, reps):
for n in range(reps):
r = snp.tensordot(a, b, (inds, inds), ignore_qflow=True)
def __norm__(self):
Z = list(
snp.tensordot(
self, snp.conj(self),
(range(self._rank), range(self._rank)))._tensor.values())[0]
return np.sqrt(Z)
