def test_FreeBondFTN(self):
shapeA = (300, 4, 5)
shapeB = (300, 6)
shapeC = (4, 6, 5)
a = Tensor(shape=shapeA,
labels=['a300', 'b4', 'c5'],
data=np.ones(shapeA))
b = Tensor(shape=shapeB, labels=['a300', 'd6'], data=np.ones(shapeB))
c = Tensor(shape=shapeC,
labels=['e4', 'd6', 'c5'],
data=np.ones(shapeC))
tensorDict = TensorDict()
tensorDict.setTensor('a', a)
tensorDict.setTensor('b', b)
tensorDict.setTensor('c', c)
FTN = FiniteTensorNetwork(['a', 'b'], realCost=True)
FTN.addTensor('c')
FTN.addLink('a', 'a300', 'b', 'a300')
FTN.addLink('a', 'c5', 'c', 'c5')
FTN.addLink('b', 'd6', 'c', 'd6')
result = FTN.contract(tensorDict, removeTensorTag=False)
self.assertTrue(funcs.compareLists(result.labels, ['a-b4', 'c-e4']))
self.assertEqual(int(result.a[0][1]), 9000)
result = FTN.contract(tensorDict, removeTensorTag=True)
self.assertTrue(funcs.compareLists(result.labels, ['b4', 'e4']))
self.assertEqual(int(result.a[0][1]), 9000)
FTN.unlock()
FTN.addPostNameChange('c', 'e4', 'e4FromC')
FTN.addPreNameChange('a', 'b4', 'b4FromA')
FTN.addPreNameChange('a', 'a300', 'a3')
FTN.removePreNameChange('a', 'a300', 'a3')
FTN.addPostNameChange('a', 'd6', 'foo')
FTN.removePostNameChange('a', 'd6', 'foo')
result = FTN.contract(tensorDict, removeTensorTag=True)
# print(result.labels)
self.assertTrue(
funcs.compareLists(result.labels, ['b4FromA', 'e4FromC']))
self.assertEqual(int(result.a[0][1]), 9000)
FTN.unlock()
FTN.removePostNameChange('c', 'e4', 'e4FromC')
FTN.addPreNameChange('c', 'e4', 'e4FromC')
FTN.addPostOutProduct([('a', 'b4FromA'), ('c', 'e4FromC')], 'out')
result = FTN.contract(tensorDict, removeTensorTag=True)
self.assertListEqual(result.labels, ['out'])
self.assertEqual(result.shape[0], 16)
def contract(self, tensorDict, removeTensorTag=True):
self.lock()
if (isinstance(tensorDict, dict)):
tensorDict = TensorDict(tensorDict)
# print(tensorDict.tensors)
assert funcs.compareLists(
self.tensorNames, list(tensorDict.tensors.keys())
), "Error: input tensorDict {} does not compatible with FTN {}.".format(
list(tensorDict.tensors.keys()), self.tensorNames)
localTensors = dict()
for name in tensorDict.tensors:
localTensors[name] = tensorDict.tensors[name].copy()
for tensor, legName, newName in self.changeNameBefore:
localTensors[tensor].renameLabel(legName, newName)
for name in localTensors:
localTensors[name].addTensorTag(name)
for leg1, leg2 in self.links:
tensorA, legA = leg1
tensorB, legB = leg2
makeLink(legA, legB, localTensors[tensorA], localTensors[tensorB])
self.changed = False
self.loadBondDims(localTensors)
tensorList = [localTensors[name] for name in self.tensorNames]
if (self.optimalSeq is None) or (self.realCost and self.changed):
# print('getting optimal seq')
self.optimalSeq = generateOptimalSequence(
tensorList, bf=False, typicalDim=self.typicalDim)
# print('optimal seq = {}'.format(self.optimalSeq))
res = contractWithSequence(tensorList,
seq=self.optimalSeq,
inplace=True)
# print(res)
# print(tensorDict.tensors)
for labelList, newLabel in self.outProductAfter:
labelList = [
self._dealOutProductLabel(label) for label in labelList
]
# print(labelList, newLabel)
# print(res.labels)
res.outProduct(labelList, 'res-' + newLabel)
# print(res.labels)
for tensor, legName, newName in self.changeNameAfter:
res.renameLabel(tensor + '-' + legName, tensor + '-' + newName)
if (removeTensorTag):
res.removeTensorTag()
return res
def test_triangleContractFTN(self):
FTN = triangleContractFTN()
a = makeTriangleTensor(np.ones((3, 3, 3)))
tensorDict = TensorDict({'u': a, 'l': a, 'r': a})
res = FTN.contract(tensorDict)
self.assertTrue(funcs.compareLists(res.labels, ['1', '2', '3']))
res.reArrange(['1', '2', '3'])
self.assertTupleEqual(res.shape, (3, 3, 3))
self.assertTrue(FTN.locked)
def test_squareContractFTN(self):
FTN = squareContractFTN()
a = makeSquareTensor(np.ones((3, 4, 3, 4)))
tensorDict = TensorDict({'ul': a, 'ur': a, 'dl': a, 'dr': a})
res = FTN.contract(tensorDict)
# print(res.labels
self.assertTrue(funcs.compareLists(res.labels, ['u', 'l', 'd', 'r']))
res.reArrange(['u', 'l', 'd', 'r'])
self.assertTupleEqual(res.shape, (9, 16, 9, 16))
def __init__(self, a, chi=16):
self.a = a.copy()
self.chi = chi
assert funcs.compareLists(a.labels, [
'l', 'r', 'u', 'd'
]), funcs.errorMessage(
'CTMRG can only accept tensor with legs ["l", "r", "u", "d"], {} obtained.'
.format(a))
self.setRecords()
self.setFTNs()
self.setInitialTensors()
def toMatrix(self, rows=None, cols=None):
"""
Make a matrix of the data of this tensor, given the labels or legs of rows and cols.
Parameters
----------
rows : None or list of str or list of Leg
The legs for the rows of the matrix. If None, deducted from cols.
cols : None or list of str or list of Leg
The legs for the cols of the matrix. If None, deducted from rows.
Returns
-------
2D ndarray of float
The data of this tensor, in the form of (rows, cols).
"""
# print(rows, cols)
# print(self.labels)
# input two set of legs
assert (not self.tensorLikeFlag), funcs.errorMessage(
'TensorLike cannot be transferred to matrix since no data contained.',
'Tensor.toMatrix')
assert not (
(rows is None) and (cols is None)
), "Error in Tensor.toMatrix: toMatrix must have at least row or col exist."
if (rows is not None) and (isinstance(rows[0], str)):
rows = [self.getLeg(label) for label in rows]
if (cols is not None) and (isinstance(cols[0], str)):
cols = [self.getLeg(label) for label in cols]
if (cols is None):
cols = funcs.listDifference(self.legs, rows)
if (rows is None):
rows = funcs.listDifference(self.legs, cols)
assert (
funcs.compareLists(rows + cols, self.legs)
), "Error Tensor.toMatrix: rows + cols must contain(and only contain) all legs of tensor."
colIndices = self.getLegIndices(cols)
rowIndices = self.getLegIndices(rows)
colShape = tuple([self.shape[x] for x in colIndices])
rowShape = tuple([self.shape[x] for x in rowIndices])
colTotalSize = funcs.tupleProduct(colShape)
rowTotalSize = funcs.tupleProduct(rowShape)
moveFrom = rowIndices + colIndices
moveTo = list(range(len(moveFrom)))
data = xplib.xp.moveaxis(xplib.xp.copy(self.a), moveFrom, moveTo)
data = xplib.xp.reshape(data, (rowTotalSize, colTotalSize))
return data
def reArrange(self, labels):
"""
Rearrange the legs to a given order according to labels.
Parameters
----------
labels : list of str
The order of labels after rearranging.
"""
assert (
funcs.compareLists(self.labels, labels)
), "Error: tensor labels must be the same with original labels: get {} but {} needed".format(
len(labels), len(self.labels))
self.moveLabelsToFront(labels)
def test_squareContractOutFTN(self):
FTN = squareContractOutFTN()
tensorNames = ['ul', 'ur', 'dl', 'dr']
tensorDict = TensorDict()
# print('keys = {}'.format(tensorDict.tensors.keys()))
for tensorName in tensorNames:
tensorDict.setTensor(
tensorName,
makeSquareOutTensor(np.ones((3, 4, 6)), loc=tensorName))
# print('keys = {}'.format(tensorDict.tensors.keys()))
res = FTN.contract(tensorDict)
self.assertTrue(funcs.compareLists(res.labels, ['u', 'd', 'l', 'r']))
self.assertTupleEqual(res.shape, (6, 6, 6, 6))
self.assertEqual(int(res.a[(0, 0, 0, 0)]), 144)
def toMatrix(self, rows, cols):
"""
Deprecated
Make a matrix of the data of this diagonal tensor, given the labels or legs of rows and cols.
Deprecated since this function is time comsuming(O(n^d)), and for most of the cases there are much better ways to use the data rather than making a matrix. For details, see CTL.tensor.contract for more information.
Parameters
----------
rows : None or list of str or list of Leg
The legs for the rows of the matrix. If None, deducted from cols.
cols : None or list of str or list of Leg
The legs for the cols of the matrix. If None, deducted from rows.
Returns
-------
2D ndarray of float
The data of this tensor, in the form of (rows, cols).
"""
assert (not self.tensorLikeFlag), funcs.errorMessage('DiagonalTensorLike cannot be transferred to matrix since no data contained.', 'DiagonalTensor.toMatrix')
# print(rows, cols)
# print(self.labels)
# input two set of legs
funcs.deprecatedFuncWarning(funcName = "DiagonalTensor.toMatrix", deprecateMessage = "Diagonal tensors should be used in a better way for linear algebra calculation rather than be made into a matrix.")
assert not ((rows is None) and (cols is None)), "Error in Tensor.toMatrix: toMatrix must have at least row or col exist."
if (rows is not None) and (isinstance(rows[0], str)):
rows = [self.getLeg(label) for label in rows]
if (cols is not None) and (isinstance(cols[0], str)):
cols = [self.getLeg(label) for label in cols]
if (cols is None):
cols = funcs.listDifference(self.legs, rows)
if (rows is None):
rows = funcs.listDifference(self.legs, cols)
assert (funcs.compareLists(rows + cols, self.legs)), "Error Tensor.toMatrix: rows + cols must contain(and only contain) all legs of tensor."
colIndices = self.getLegIndices(cols)
rowIndices = self.getLegIndices(rows)
colShape = tuple([self.shape[x] for x in colIndices])
rowShape = tuple([self.shape[x] for x in rowIndices])
colTotalSize = funcs.tupleProduct(colShape)
rowTotalSize = funcs.tupleProduct(rowShape)
data = funcs.diagonalNDTensor(self.a, self.dim)
data = xplib.xp.reshape(data, (rowTotalSize, colTotalSize))
return data
def test_outerProduct(self):
a = Tensor(shape=(2, ), labels=['a'])
b = Tensor(shape=(2, ), labels=['b'])
op = contractTwoTensors(a, b, outProductWarning=False)
self.assertTrue(funcs.compareLists(op.labels, ['a', 'b']))
a = Tensor(shape=(2, 2, 2), labels=['a', 'b', 'c'])
b = Tensor(shape=(2, ), labels=['x'])
c = Tensor(shape=(2, ), labels=['y'])
makeLink('a', 'x', a, b)
makeLink('b', 'y', a, c)
prod = contractTensorList([a, b, c], outProductWarning=False)
self.assertTrue(funcs.compareLists(prod.labels, ['c']))
dataA = np.random.random_sample((2, 2))
dataB = np.random.random_sample((3, 3))
a = Tensor(shape=(2, 2), labels=['a1', 'a2'], data=dataA)
b = Tensor(shape=(3, 3), labels=['b1', 'b2'], data=dataB)
prod = contractTensorList([a, b], outProductWarning=False)
prod.reArrange(['a1', 'a2', 'b1', 'b2'])
res = np.zeros((2, 2, 3, 3))
for i in range(2):
for j in range(2):
for k in range(3):
for l in range(3):
res[(i, j, k, l)] = dataA[(i, j)] * dataB[(k, l)]
# print(res, prod.a)
self.assertTrue(funcs.floatArrayEqual(res, prod.a))
a = Tensor(shape=(2, 2), labels=['a1', 'a2'], data=dataA)
b = DiagonalTensor(shape=(3, 3),
labels=['b1', 'b2'],
data=np.diag(dataB))
prod = contractTensorList([a, b], outProductWarning=False)
prodData = prod.toTensor(['a1', 'a2', 'b1', 'b2'])
# prod.reArrange(['a1', 'a2', 'b1', 'b2'])
res = np.zeros((2, 2, 3, 3))
for i in range(2):
for j in range(2):
for k in range(3):
# for l in range(3):
res[(i, j, k, k)] = dataA[(i, j)] * dataB[(k, k)]
# print(res, prod.a)
self.assertTrue(funcs.floatArrayEqual(res, prodData))
dataA = np.random.random_sample((2, 2))
dataB = np.random.random_sample(3)
a = Tensor(shape=(2, 2), labels=['a1', 'a2'], data=dataA)
b = DiagonalTensor(shape=(3, 3, 3),
labels=['b1', 'b2', 'b3'],
data=dataB)
prod = contractTensorList([a, b], outProductWarning=False)
prodData = prod.toTensor(['a1', 'a2', 'b1', 'b2', 'b3'])
# prod.reArrange(['a1', 'a2', 'b1', 'b2'])
res = np.zeros((2, 2, 3, 3, 3))
for i in range(2):
for j in range(2):
for k in range(3):
# for l in range(3):
res[(i, j, k, k, k)] = dataA[(i, j)] * dataB[k]
# print(res, prod.a)
self.assertTrue(funcs.floatArrayEqual(res, prodData))
def test_Ising(self):
betaJ = 1.0
a = IsingSiteTensor(betaJ = betaJ, dim = 4, labels = ['u', 'd', 'l', 'r'])
edgeMat = IsingEdgeMatrix(betaJ = betaJ)
self.assertTrue(funcs.floatEqual(a.a[(0, 0, 0, 0)], edgeMat[0, 0] ** 4 + edgeMat[0, 1] ** 4))
self.assertTrue(funcs.compareLists(['u', 'd', 'l', 'r'], a.labels))
def test_diagonalSumOut(self):
a = DiagonalTensor(shape = (3, 3, 3), labels = ['abc', 'def', 'abc'])
a.sumOutLegByLabel(['abc', 'abc'])
self.assertTrue(funcs.compareLists(a.labels, ['def']))
def test_diagonalRename(self):
a = DiagonalTensor(shape = (3, 3, 3), labels = ['abc', 'def', 'abc'])
a.renameLabels(['abc', 'abc'], ['abc1', 'abc2'])
self.assertTrue(funcs.compareLists(a.labels, ['abc1', 'abc2', 'def']))
def test_contraction(self):
self.showTestCaseBegin("diagonal tensor contraction")
# print('Begin test diagonalTensor contraction.')
a = DiagonalTensor(shape = (2, 2), labels = ['a', 'b'])
b = Tensor(shape = (2, ), labels = ['x'])
c = Tensor(shape = (2, ), labels = ['y'])
makeLink('a', 'x', a, b)
makeLink('b', 'y', a, c)
seq = generateOptimalSequence([a, b, c], typicalDim = 10)
# print('optimal sequence = {}'.format(seq))
prod, cost = contractAndCostWithSequence([a, b, c], seq = seq)
# print('cost = {}'.format(cost))
# prod = contractTensorList([a, b, c], outProductWarning = False)
self.assertTrue(funcs.compareLists(prod.labels, []))
self.assertListEqual(seq, [(0, 2), (1, 0)])
self.assertEqual(cost, 4.0)
# if we use Tensor instead of DiagonalTensor for a
# then the cost should be 12.0, and the order should be (1, 2), (0, 1)
# the optimal cost of diagonal tensors can be achieved if we use diagonal nature for contraction
a = DiagonalTensor(shape = (2, 2, 2), labels = ['a', 'b', 'c'])
b = DiagonalTensor(shape = (2, 2), labels = ['x', 'y'])
makeLink('a', 'x', a, b)
prod, cost = contractAndCostWithSequence([a, b])
self.assertEqual(cost, 2)
self.assertTrue(funcs.compareLists(prod.labels, ['b', 'c', 'y']))
aData = np.array([[[1, 0], [0, 0]], [[0, 0], [0, 3]]])
bData = np.random.random_sample(2)
cData = np.random.random_sample(2)
a = DiagonalTensor(data = aData, labels = ['a', 'b', 'c'])
b = Tensor(data = bData, labels = ['x'])
c = Tensor(data = cData, labels = ['y'])
makeLink('a', 'x', a, b)
makeLink('b', 'y', a, c)
res1, _ = contractAndCostWithSequence([a, b, c])
# print('seq = {}'.format(generateOptimalSequence([a, b, c])))
a = Tensor(data = aData, labels = ['a', 'b', 'c'])
b = Tensor(data = bData, labels = ['x'])
c = Tensor(data = cData, labels = ['y'])
makeLink('a', 'x', a, b)
makeLink('b', 'y', a, c)
res2, _ = contractAndCostWithSequence([a, b, c])
# self.assertListEqual(list(res1.a), list(res2.a))
self.assertTrue(funcs.floatArrayEqual(res1.a, res2.a))
# print(cost1, cost2)
# print(res1.a, res2.a)
# test diagonal tensor contraction
a = DiagonalTensor(shape = (2, 2), labels = ['a1', 'a2'])
b = DiagonalTensor(shape = (2, 2, 2), labels = ['b1', 'b2', 'b3'])
makeLink('a1', 'b1', a, b)
res = a @ b
self.assertTupleEqual(res.shape, (2, 2, 2))
self.assertEqual(res.dim, 3)
self.assertTrue(res.diagonalFlag)
self.assertTrue((res.a == np.ones(2)).all())
# test for diagonal * diagonal contraction cost(just O(length))
a = DiagonalTensor(shape = (2, 2), labels = ['a1', 'a2'])
b = DiagonalTensor(shape = 2, labels = ['b1', 'b2']) # deduce dim
makeLink('a1', 'b2', a, b)
cost, _ = contractCost(a, b)
self.assertEqual(cost, 2.0)
res, cost = contractAndCostWithSequence([a, b])
self.assertEqual(res.dim, 2)
self.assertEqual(res._length, 2)
self.assertTupleEqual(res.shape, (2, 2))
self.assertEqual(cost, 2.0)
self.assertTrue(res.diagonalFlag)
a = DiagonalTensor(shape = (2, 2), labels = ['a1', 'a2'])
b = Tensor(shape = (2, 3, 3), labels = ['b1', 'b2', 'b3']) # deduce dim
makeLink('a1', 'b1', a, b)
cost, _ = contractCost(a, b)
self.assertEqual(cost, 18.0)
res, cost = contractAndCostWithSequence([a, b])
# print(res)
self.assertEqual(res.dim, 3)
self.assertTrue(funcs.compareLists(list(res.shape), [2, 3, 3]))
self.assertEqual(cost, 18.0)
self.showTestCaseEnd("diagonal tensor contraction")
def test_extremeContraction(self):
self.showTestCaseBegin("diagonal tensor extreme contraction")
aData = np.random.random_sample(2)
aTensorData = np.array([[[aData[0], 0], [0, 0]], [[0, 0], [0, aData[1]]]])
bData = np.random.random_sample((2, 2))
a = DiagonalTensor(shape = (2, 2, 2), labels = ['a1', 'a2', 'a3'], data = aData)
b = Tensor(shape = (2, 2), labels = ['b1', 'b2'], data = bData)
makeLink('a1', 'b1', a, b)
makeLink('a3', 'b2', a, b)
res1 = a @ b
a = Tensor(shape = (2, 2, 2), labels = ['a1', 'a2', 'a3'], data = aTensorData)
b = Tensor(shape = (2, 2), labels = ['b1', 'b2'], data = bData)
makeLink('a1', 'b1', a, b)
makeLink('a3', 'b2', a, b)
res2 = b @ a
self.assertTrue(funcs.compareLists(list(res1.labels), ['a2']))
self.assertTrue(funcs.compareLists(list(res2.labels), ['a2']))
# self.assertListEqual(list(res1.a), list(res2.a))
self.assertTrue(funcs.floatArrayEqual(res1.a, res2.a))
aData = np.random.random_sample(2)
aTensorData = np.array([[aData[0], 0], [0, aData[1]]])
bData = np.random.random_sample((2, 2))
a = DiagonalTensor(shape = (2, 2), labels = ['a1', 'a2'], data = aData)
b = Tensor(shape = (2, 2), labels = ['b1', 'b2'], data = bData)
makeLink('a1', 'b1', a, b)
makeLink('a2', 'b2', a, b)
res1 = a @ b
a = Tensor(shape = (2, 2), labels = ['a1', 'a2'], data = aTensorData)
b = Tensor(shape = (2, 2), labels = ['b1', 'b2'], data = bData)
makeLink('a1', 'b1', a, b)
makeLink('a2', 'b2', a, b)
res2 = b @ a
self.assertTrue(funcs.compareLists(res1.labels, []))
self.assertTrue(funcs.compareLists(res2.labels, []))
# self.assertListEqual(list(res1.single(), list(res2.a))
self.assertTrue(funcs.floatEqual(res1.single(), res2.single()))
aData = np.random.random_sample(2)
aTensorData = np.array([[[aData[0], 0], [0, 0]], [[0, 0], [0, aData[1]]]])
bData = np.random.random_sample((2, 2, 2))
a = DiagonalTensor(shape = (2, 2, 2), labels = ['a1', 'a2', 'a3'], data = aData)
b = Tensor(shape = (2, 2, 2), labels = ['b1', 'b2', 'b3'], data = bData)
makeLink('a1', 'b1', a, b)
makeLink('a3', 'b2', a, b)
res1 = a @ b
a = Tensor(shape = (2, 2, 2), labels = ['a1', 'a2', 'a3'], data = aTensorData)
b = Tensor(shape = (2, 2, 2), labels = ['b1', 'b2', 'b3'], data = bData)
makeLink('a1', 'b1', a, b)
makeLink('a3', 'b2', a, b)
res2 = b @ a
self.assertTrue(funcs.compareLists(list(res1.labels), ['a2', 'b3']))
self.assertTrue(funcs.compareLists(list(res2.labels), ['a2', 'b3']))
# print(res1.labels, res2.labels)
# print(res1.a, res2.a)
res2.reArrange(res1.labels)
self.assertTrue(funcs.floatArrayEqual(res1.a, res2.a))
# self.assertListEqual(list(np.ravel(res1.a)), list(np.ravel(res2.a)))
aData = np.random.random_sample(2)
aTensorData = np.array([[[aData[0], 0], [0, 0]], [[0, 0], [0, aData[1]]]])
bData = np.random.random_sample((2, 2, 2))
a = DiagonalTensor(shape = (2, 2, 2), labels = ['a1', 'a2', 'a3'], data = aData)
b = Tensor(shape = (2, 2, 2), labels = ['b1', 'b2', 'b3'], data = bData)
makeLink('a1', 'b1', a, b)
# makeLink('a3', 'b2', a, b)
res1 = a @ b
a = Tensor(shape = (2, 2, 2), labels = ['a1', 'a2', 'a3'], data = aTensorData)
b = Tensor(shape = (2, 2, 2), labels = ['b1', 'b2', 'b3'], data = bData)
makeLink('a1', 'b1', a, b)
# makeLink('a3', 'b2', a, b)
res2 = b @ a
# print('ndEye(2, 2) = {}'.format(funcs.ndEye(2, 2)))
# print('ndEye(1, 2) = {}'.format(funcs.ndEye(1, 2)))
# print('ndEye(3, 2) = {}'.format(funcs.ndEye(3, 2)))
self.assertTrue(funcs.compareLists(list(res1.labels), ['a2', 'a3', 'b2', 'b3']))
self.assertTrue(funcs.compareLists(list(res2.labels), ['a2', 'a3', 'b2', 'b3']))
# print(res1.labels, res2.labels)
res2.reArrange(res1.labels)
# print('res1 = {}, res2 = {}'.format(res1.a, res2.a))
self.assertTrue(funcs.floatArrayEqual(res1.a, res2.a))
# self.assertListEqual(list(np.ravel(res1.a)), list(np.ravel(res2.a)))
aData = np.random.random_sample(2)
aTensorData = np.array([[[aData[0], 0], [0, 0]], [[0, 0], [0, aData[1]]]])
bData = np.random.random_sample((2, 4, 7))
a = DiagonalTensor(shape = (2, 2, 2), labels = ['a1', 'a2', 'a3'], data = aData)
b = Tensor(shape = (2, 4, 7), labels = ['b1', 'b2', 'b3'], data = bData)
makeLink('a1', 'b1', a, b)
# makeLink('a3', 'b2', a, b)
res1 = a @ b
a = Tensor(shape = (2, 2, 2), labels = ['a1', 'a2', 'a3'], data = aTensorData)
b = Tensor(shape = (2, 4, 7), labels = ['b1', 'b2', 'b3'], data = bData)
makeLink('a1', 'b1', a, b)
# makeLink('a3', 'b2', a, b)
res2 = b @ a
# print('ndEye(2, 2) = {}'.format(funcs.ndEye(2, 2)))
# print('ndEye(1, 2) = {}'.format(funcs.ndEye(1, 2)))
# print('ndEye(3, 2) = {}'.format(funcs.ndEye(3, 2)))
self.assertTrue(funcs.compareLists(list(res1.labels), ['a2', 'a3', 'b2', 'b3']))
self.assertTrue(funcs.compareLists(list(res2.labels), ['a2', 'a3', 'b2', 'b3']))
# print(res1.labels, res2.labels)
res2.reArrange(res1.labels)
# print('res1 = {}, res2 = {}'.format(res1.a, res2.a))
self.assertTrue(funcs.floatArrayEqual(res1.a, res2.a))
self.showTestCaseEnd("diagonal tensor extreme contraction")
def test_deduce(self):
self.showTestCaseBegin("diagonal tensor shape deduction")
legA = Leg(tensor = None, dim = 5, name = 'a')
legB = Leg(tensor = None, dim = 5, name = 'b')
legBError = Leg(tensor = None, dim = 6, name = 'b')
a = DiagonalTensor(legs = [legA, legB])
self.assertTupleEqual(a.shape, (5, 5))
self.assertEqual(a.dim, 2)
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b']))
self.assertTrue(funcs.floatArrayEqual(a.a, np.ones(5)))
a = DiagonalTensor(legs = [legA, legB], labels = ['a', 'b'])
self.assertTupleEqual(a.shape, (5, 5))
self.assertEqual(a.dim, 2)
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b']))
self.assertTrue(funcs.floatArrayEqual(a.a, np.ones(5)))
a = DiagonalTensor(legs = [legA, legB], shape = 5)
self.assertTupleEqual(a.shape, (5, 5))
self.assertEqual(a.dim, 2)
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b']))
self.assertTrue(funcs.floatArrayEqual(a.a, np.ones(5)))
a = DiagonalTensor(legs = [legA, legB], shape = 5, data = np.zeros(5))
self.assertTupleEqual(a.shape, (5, 5))
self.assertEqual(a.dim, 2)
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b']))
self.assertTrue(funcs.floatArrayEqual(a.a, np.zeros(5)))
def legDimNotEqualFunc():
_ = DiagonalTensor(legs = [legA, legBError])
def labelsSizeNotEqualFunc():
_ = DiagonalTensor(legs = [legA, legB], labels = ['a'])
def labelsOrderNotEqualFunc():
_ = DiagonalTensor(legs = [legA, legB], labels = ['b', 'a'])
def shapeSizeNotEqualFunc():
_ = DiagonalTensor(legs = [legA, legB], shape = (5, 6, 7))
def shapeOrderNotEqualFunc():
_ = DiagonalTensor(legs = [legA, legB], shape = (6, 5))
def dataDimNotEqualFunc():
_ = DiagonalTensor(legs = [legA, legB], data = np.zeros((5, 6, 7)))
def dataShapeNotEqualFunc():
_ = DiagonalTensor(legs = [legA, legB], data = np.zeros((5, 6)))
def labelsShapeNotCompatibleFunc():
_ = DiagonalTensor(legs = [legA, legB], labels = ['a'], data = np.zeros((5, 5)))
def dimensionless1DDataErrorFunc():
_ = DiagonalTensor(legs = [], labels = [], data = np.zeros(3))
def dimensionless1DDataErrorFunc2():
_ = DiagonalTensor(labels = [], data = np.zeros(3))
self.assertRaises(ValueError, legDimNotEqualFunc)
self.assertRaises(ValueError, labelsSizeNotEqualFunc)
self.assertRaises(ValueError, labelsOrderNotEqualFunc)
self.assertRaises(ValueError, shapeSizeNotEqualFunc)
self.assertRaises(ValueError, shapeOrderNotEqualFunc)
self.assertRaises(ValueError, dataDimNotEqualFunc)
self.assertRaises(ValueError, dataShapeNotEqualFunc)
self.assertRaises(ValueError, labelsShapeNotCompatibleFunc)
self.assertRaises(ValueError, dimensionless1DDataErrorFunc)
self.assertRaises(ValueError, dimensionless1DDataErrorFunc2)
a = DiagonalTensor(shape = (2, 2), labels = ['a1', 'a2'])
self.assertTupleEqual(a.shape, (2, 2))
self.assertEqual(a.dim, 2)
a = DiagonalTensor(shape = (2, 2))
self.assertTupleEqual(a.shape, (2, 2))
self.assertEqual(a.dim, 2)
self.assertTrue((a.a == np.ones(2)).all()) # default as identity tensor
def shapeNotEqualFunc():
_ = DiagonalTensor(shape = (2, 3))
self.assertRaises(ValueError, shapeNotEqualFunc)
def labelsShortFunc():
_ = DiagonalTensor(shape = (2, 2), labels = ['a1'])
def labelsLongFunc():
_ = DiagonalTensor(shape = (2, 2), labels = ['a', 'b', 'c'])
self.assertRaises(ValueError, labelsShortFunc)
self.assertRaises(ValueError, labelsLongFunc)
a = DiagonalTensor(shape = (2, 2), data = np.zeros((2, 2)))
self.assertTupleEqual(a.shape, (2, 2))
self.assertEqual(a.dim, 2)
a = DiagonalTensor(shape = (2, 2, 2), data = np.zeros(2))
self.assertTupleEqual(a.shape, (2, 2, 2))
self.assertEqual(a.dim, 3)
def dataDimErrorFunc():
_ = DiagonalTensor(shape = (2, 2), data = np.zeros((2, 2, 2)))
def dataShapeErrorFunc():
_ = DiagonalTensor(shape = (2, 2), data = np.zeros((2, 3))) # no error in 9be9325, newly added
self.assertRaises(ValueError, dataDimErrorFunc)
self.assertRaises(ValueError, dataShapeErrorFunc)
# now start (shape = None) tests
a = DiagonalTensor(labels = ['a', 'b'], data = np.zeros(3))
self.assertEqual(a._length, 3)
self.assertEqual(a.shape, (3, 3))
self.assertEqual(a.dim, 2)
a = DiagonalTensor(labels = ['a', 'b'], data = np.zeros((4, 4)))
self.assertEqual(a._length, 4)
self.assertEqual(a.shape, (4, 4))
self.assertEqual(a.dim, 2)
a = DiagonalTensor(labels = ['a', 'b'], data = np.array([[1, 2], [3, 4]]))
self.assertEqual(a._length, 2)
self.assertEqual(a.shape, (2, 2))
self.assertTrue((a.a == np.array([1, 4])).all())
def dataDimErrorFunc2():
_ = DiagonalTensor(labels = ['a', 'b', 'c'], data = np.zeros((2, 2)))
def dataShapeErrorFunc2():
_ = DiagonalTensor(labels = ['a', 'b', 'c'], data = np.zeros((2, 2, 3)))
def dataNoneErrorFunc():
_ = DiagonalTensor(labels = ['a', 'b', 'c'], data = None)
self.assertRaises(ValueError, dataDimErrorFunc2)
self.assertRaises(ValueError, dataShapeErrorFunc2)
self.assertRaises(ValueError, dataNoneErrorFunc)
# now start(shape = None, labels = None)
a = DiagonalTensor(data = np.zeros(2)) # 1D diagonal tensor as a simple vector
self.assertEqual(a.dim, 1)
self.assertEqual(a._length, 2)
self.assertListEqual(a.labels, ['a'])
a = DiagonalTensor(data = np.array([[1, 2], [4, 3]]))
self.assertEqual(a.dim, 2)
self.assertEqual(a._length, 2)
self.assertTrue((a.a == np.array([1, 3])).all())
def dataShapeErrorFunc3():
_ = DiagonalTensor(data = np.zeros((2, 2, 3)))
def nothingErrorFunc():
_ = DiagonalTensor()
self.assertRaises(ValueError, dataShapeErrorFunc3)
self.assertRaises(ValueError, nothingErrorFunc)
self.showTestCaseEnd("diagonal tensor shape deduction")
def test_TensorLike(self):
# the deduction rules are just the same as Tensor
# the only difference is that data is None, and tensorLikeFlag is True
legA = Leg(tensor = None, dim = 5, name = 'a')
legB = Leg(tensor = None, dim = 6, name = 'b')
a = Tensor(legs = [legA, legB], tensorLikeFlag = True)
self.assertTupleEqual(a.shape, (5, 6))
self.assertEqual(a.dim, 2)
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b']))
self.assertTrue(a.tensorLikeFlag)
self.assertIsNone(a.a)
a = Tensor(legs = [legA, legB], labels = ['a', 'b'], tensorLikeFlag = True)
self.assertTupleEqual(a.shape, (5, 6))
self.assertEqual(a.dim, 2)
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b']))
self.assertTrue(a.tensorLikeFlag)
self.assertIsNone(a.a)
def labelsSizeNotEqualFunc():
_ = Tensor(legs = [legA, legB], labels = ['a'], tensorLikeFlag = True)
def labelsOrderNotEqualFunc():
_ = Tensor(legs = [legA, legB], labels = ['b', 'a'], tensorLikeFlag = True)
def shapeSizeNotEqualFunc():
_ = Tensor(legs = [legA, legB], shape = (5, 6, 7), tensorLikeFlag = True)
def shapeOrderNotEqualFunc():
_ = Tensor(legs = [legA, legB], shape = (6, 5), tensorLikeFlag = True)
def dataDimNotEqualFunc():
_ = Tensor(legs = [legA, legB], data = np.zeros((5, 6, 7)), tensorLikeFlag = True)
def dataShapeNotEqualFunc():
_ = Tensor(legs = [legA, legB], data = np.zeros((5, 5)), tensorLikeFlag = True)
self.assertRaises(ValueError, labelsSizeNotEqualFunc)
self.assertRaises(ValueError, labelsOrderNotEqualFunc)
self.assertRaises(ValueError, shapeSizeNotEqualFunc)
self.assertRaises(ValueError, shapeOrderNotEqualFunc)
self.assertRaises(ValueError, dataDimNotEqualFunc)
self.assertRaises(ValueError, dataShapeNotEqualFunc)
# for data, works if (data size) = (dim product), no matter what the shape of data
a = Tensor(legs = [legA, legB], data = np.zeros((6, 5)), tensorLikeFlag = True)
self.assertTupleEqual(a.shape, (5, 6))
self.assertEqual(a.dim, 2)
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b']))
self.assertTrue(a.tensorLikeFlag)
self.assertIsNone(a.a)
a = Tensor(legs = [legA, legB], data = np.zeros((3, 2, 5)), tensorLikeFlag = True)
self.assertTupleEqual(a.shape, (5, 6))
self.assertEqual(a.dim, 2)
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b']))
self.assertTrue(a.tensorLikeFlag)
self.assertIsNone(a.a)
a = Tensor(legs = [legA, legB], data = np.zeros(30), tensorLikeFlag = True)
self.assertTupleEqual(a.shape, (5, 6))
self.assertEqual(a.dim, 2)
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b']))
self.assertTrue(a.tensorLikeFlag)
self.assertIsNone(a.a)
# 2. legs not exist, shape exist
# if data exist, check the total number of components of data equal to shape, otherwise random
# if labels exist: check the number of labels equal to dimension, otherwise auto-generate
a = Tensor(shape = (5, 3, 4), tensorLikeFlag = True)
self.assertTupleEqual(a.shape, (5, 3, 4))
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b', 'c']))
self.assertEqual(a.dim, 3)
self.assertTrue(a.tensorLikeFlag)
self.assertIsNone(a.a)
a = Tensor(shape = (5, 3, 4), data = np.zeros(60), tensorLikeFlag = True)
self.assertTupleEqual(a.shape, (5, 3, 4))
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b', 'c']))
self.assertEqual(a.dim, 3)
# self.assertEqual(a.a[(0, 0, 0)], 0)
self.assertTrue(a.tensorLikeFlag)
self.assertIsNone(a.a)
a = Tensor(shape = (5, 3, 4), labels = ['c', 'b', 'a'], tensorLikeFlag = True)
self.assertTupleEqual(a.shape, (5, 3, 4))
self.assertTrue(funcs.compareLists(a.labels, ['c', 'b', 'a']))
self.assertEqual(a.dim, 3)
self.assertTrue(a.tensorLikeFlag)
self.assertIsNone(a.a)
a = Tensor(shape = (5, 3, 4), labels = ('c', 'b', 'a'), tensorLikeFlag = True) # tuple also is acceptable
self.assertTupleEqual(a.shape, (5, 3, 4))
self.assertTrue(funcs.compareLists(a.labels, ['c', 'b', 'a']))
self.assertEqual(a.dim, 3)
self.assertTrue(a.tensorLikeFlag)
self.assertIsNone(a.a)
a = Tensor(shape = (5, 3, 4), labels = ['c', 'b', 'a'], data = np.zeros(60), tensorLikeFlag = True)
self.assertTupleEqual(a.shape, (5, 3, 4))
self.assertTrue(funcs.compareLists(a.labels, ['c', 'b', 'a']))
self.assertEqual(a.dim, 3)
self.assertTrue(a.tensorLikeFlag)
self.assertIsNone(a.a)
def dataTotalSizeNotEqualErrorFunc():
_ = Tensor(shape = (5, 3, 4), data = np.zeros((5, 3, 3)), tensorLikeFlag = True)
def labelsSizeNotEqualFunc2():
_ = Tensor(shape = (5, 3, 4), labels = ['a', 'b'])
self.assertRaises(ValueError, dataTotalSizeNotEqualErrorFunc)
self.assertRaises(ValueError, labelsSizeNotEqualFunc2)
# 3. legs not exist, shape not exist
# if data exist: generate shape according to data, and auto-generate legs
a = Tensor(data = np.zeros((3, 4, 5)), tensorLikeFlag = True)
self.assertTupleEqual(a.shape, (3, 4, 5))
self.assertEqual(a.dim, 3)
self.assertEqual(a.legs[0].dim, 3)
self.assertEqual(a.legs[0].name, 'a')
self.assertTrue(a.tensorLikeFlag)
self.assertIsNone(a.a)
self.assertTrue(a.__str__().find('TensorLike') != -1)
self.assertTrue(a.__repr__().find('TensorLike') != -1)
def nothingErrorFunc():
_ = Tensor(tensorLikeFlag = True)
self.assertRaises(ValueError, nothingErrorFunc)
def test_TensorDeduction(self):
# test the deduction of Tensor
# deduce strategy:
# we want shape, and labels
# we have legs, shape, labels, data
# priority for shape: legs > shape > data
# priority for labels: legs > labels
# 1. legs exist:
# if labels exist: check the length and content of labels with legs
# if shape exist: check whether shape == tuple([leg.dim for leg in legs])
# if data exist: check whehter data.shape == tuple([leg.dim for leg in legs]) (if not, but the total size equal, we transfer data to the given shape)
# 3. legs not exist, shape not exist
# if data exist: generate shape according to data, and auto-generate legs
legA = Leg(tensor = None, dim = 5, name = 'a')
legB = Leg(tensor = None, dim = 6, name = 'b')
a = Tensor(legs = [legA, legB])
self.assertTupleEqual(a.shape, (5, 6))
self.assertEqual(a.dim, 2)
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b']))
a = Tensor(legs = [legA, legB], labels = ['a', 'b'])
self.assertTupleEqual(a.shape, (5, 6))
self.assertEqual(a.dim, 2)
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b']))
def labelsSizeNotEqualFunc():
_ = Tensor(legs = [legA, legB], labels = ['a'])
def labelsOrderNotEqualFunc():
_ = Tensor(legs = [legA, legB], labels = ['b', 'a'])
def shapeSizeNotEqualFunc():
_ = Tensor(legs = [legA, legB], shape = (5, 6, 7))
def shapeOrderNotEqualFunc():
_ = Tensor(legs = [legA, legB], shape = (6, 5))
def dataDimNotEqualFunc():
_ = Tensor(legs = [legA, legB], data = np.zeros((5, 6, 7)))
def dataShapeNotEqualFunc():
_ = Tensor(legs = [legA, legB], data = np.zeros((5, 5)))
self.assertRaises(ValueError, labelsSizeNotEqualFunc)
self.assertRaises(ValueError, labelsOrderNotEqualFunc)
self.assertRaises(ValueError, shapeSizeNotEqualFunc)
self.assertRaises(ValueError, shapeOrderNotEqualFunc)
self.assertRaises(ValueError, dataDimNotEqualFunc)
self.assertRaises(ValueError, dataShapeNotEqualFunc)
# for data, works if (data size) = (dim product), no matter what the shape of data
a = Tensor(legs = [legA, legB], data = np.zeros((6, 5)))
self.assertTupleEqual(a.shape, (5, 6))
self.assertEqual(a.dim, 2)
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b']))
a = Tensor(legs = [legA, legB], data = np.zeros((3, 2, 5)))
self.assertTupleEqual(a.shape, (5, 6))
self.assertEqual(a.dim, 2)
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b']))
a = Tensor(legs = [legA, legB], data = np.zeros(30))
self.assertTupleEqual(a.shape, (5, 6))
self.assertEqual(a.dim, 2)
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b']))
# 2. legs not exist, shape exist
# if data exist, check the total number of components of data equal to shape, otherwise random
# if labels exist: check the number of labels equal to dimension, otherwise auto-generate
a = Tensor(shape = (5, 3, 4))
self.assertTupleEqual(a.shape, (5, 3, 4))
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b', 'c']))
self.assertEqual(a.dim, 3)
a = Tensor(shape = (5, 3, 4), data = np.zeros(60))
self.assertTupleEqual(a.shape, (5, 3, 4))
self.assertTrue(funcs.compareLists(a.labels, ['a', 'b', 'c']))
self.assertEqual(a.dim, 3)
self.assertEqual(a.a[(0, 0, 0)], 0)
a = Tensor(shape = (5, 3, 4), labels = ['c', 'b', 'a'])
self.assertTupleEqual(a.shape, (5, 3, 4))
self.assertTrue(funcs.compareLists(a.labels, ['c', 'b', 'a']))
self.assertEqual(a.dim, 3)
a = Tensor(shape = (5, 3, 4), labels = ('c', 'b', 'a')) # tuple also is acceptable
self.assertTupleEqual(a.shape, (5, 3, 4))
self.assertTrue(funcs.compareLists(a.labels, ['c', 'b', 'a']))
self.assertEqual(a.dim, 3)
a = Tensor(shape = (5, 3, 4), labels = ['c', 'b', 'a'], data = np.zeros(60))
self.assertTupleEqual(a.shape, (5, 3, 4))
self.assertTrue(funcs.compareLists(a.labels, ['c', 'b', 'a']))
self.assertEqual(a.dim, 3)
def dataTotalSizeNotEqualErrorFunc():
_ = Tensor(shape = (5, 3, 4), data = np.zeros((5, 3, 3)))
def labelsSizeNotEqualFunc2():
_ = Tensor(shape = (5, 3, 4), labels = ['a', 'b'])
self.assertRaises(ValueError, dataTotalSizeNotEqualErrorFunc)
self.assertRaises(ValueError, labelsSizeNotEqualFunc2)
# 3. legs not exist, shape not exist
# if data exist: generate shape according to data, and auto-generate legs
a = Tensor(data = np.zeros((3, 4, 5)))
self.assertTupleEqual(a.shape, (3, 4, 5))
self.assertEqual(a.dim, 3)
self.assertEqual(a.legs[0].dim, 3)
self.assertEqual(a.legs[0].name, 'a')
def nothingErrorFunc():
_ = Tensor()
self.assertRaises(ValueError, nothingErrorFunc)
def test_merge(self):
'''
test the merge(ta, tb) for merge the bonds between ta and tb
'''
# normal tensor merge case: 2 shared bonds
ta = Tensor(shape=(3, 4, 5), labels=['a3', 'a4', 'a5'])
tb = Tensor(shape=(4, 3, 6), labels=['b4', 'b3', 'b6'])
makeLink('a3', 'b3', ta, tb)
makeLink('a4', 'b4', ta, tb)
ta, tb = merge(ta, tb)
self.assertTrue(funcs.compareLists(ta.labels, ['a3|a4', 'a5']))
self.assertTrue(funcs.compareLists(tb.labels, ['b3|b4', 'b6']))
ta.reArrange(['a3|a4', 'a5'])
self.assertTupleEqual(ta.shape, (12, 5))
tb.reArrange(['b3|b4', 'b6'])
self.assertTupleEqual(tb.shape, (12, 6))
self.assertEqual(len(shareBonds(ta, tb)), 1)
# normal tensor merge case, order changed
ta = Tensor(shape=(3, 4, 5), labels=['a3', 'a4', 'a5'])
tb = Tensor(shape=(4, 3, 6), labels=['b4', 'b3', 'b6'])
makeLink('a3', 'b3', ta, tb)
makeLink('a4', 'b4', ta, tb)
tb, ta = merge(tb, ta)
self.assertTrue(funcs.compareLists(ta.labels, ['a4|a3', 'a5']))
self.assertTrue(funcs.compareLists(tb.labels, ['b4|b3', 'b6']))
# test single shared bond: with warning, and do nothing but rename
ta = Tensor(shape=(3, 4, 5), labels=['a3', 'a4', 'a5'])
tb = Tensor(shape=(4, 3, 6), labels=['b4', 'b3', 'b6'])
makeLink('a3', 'b3', ta, tb)
# tb, ta = merge(tb, ta, bondName = 'o')
with self.assertWarns(RuntimeWarning) as cm:
tb, ta = merge(tb, ta, bondName='o')
self.assertIn('link.py', cm.filename)
message = cm.warning.__str__()
self.assertIn('mergeLink cannot merge links', message)
self.assertIn('sharing one bond', message)
self.assertTrue(funcs.compareLists(['o', 'a4', 'a5'], ta.labels))
self.assertTrue(funcs.compareLists(['o', 'b4', 'b6'], tb.labels))
# test for normal merge, tensorLike
ta = Tensor(shape=(3, 4, 5),
labels=['a3', 'a4', 'a5'],
tensorLikeFlag=True)
tb = Tensor(shape=(4, 3, 6),
labels=['b4', 'b3', 'b6'],
tensorLikeFlag=True)
makeLink('a3', 'b3', ta, tb)
makeLink('a4', 'b4', ta, tb)
ta, tb = merge(ta, tb)
self.assertTrue(funcs.compareLists(ta.labels, ['a3|a4', 'a5']))
self.assertTrue(funcs.compareLists(tb.labels, ['b3|b4', 'b6']))
ta.reArrange(['a3|a4', 'a5'])
self.assertTupleEqual(ta.shape, (12, 5))
tb.reArrange(['b3|b4', 'b6'])
self.assertTupleEqual(tb.shape, (12, 6))
self.assertEqual(len(shareBonds(ta, tb)), 1)
self.assertTrue(ta.tensorLikeFlag and tb.tensorLikeFlag)
# test for single bond merge, tensorLike
ta = Tensor(shape=(3, 4, 5),
labels=['a3', 'a4', 'a5'],
tensorLikeFlag=True)
tb = Tensor(shape=(4, 3, 6),
labels=['b4', 'b3', 'b6'],
tensorLikeFlag=True)
makeLink('a3', 'b3', ta, tb)
# tb, ta = merge(tb, ta, bondName = 'o')
with self.assertWarns(RuntimeWarning) as cm:
tb, ta = merge(tb, ta, bondName='o')
self.assertIn('link.py', cm.filename)
message = cm.warning.__str__()
self.assertIn('mergeLink cannot merge links', message)
self.assertIn('sharing one bond', message)
self.assertTrue(ta.tensorLikeFlag and tb.tensorLikeFlag)
ta = Tensor(shape=(3, 4, 5), labels=['a3', 'a4', 'a5'])
tb = Tensor(shape=(4, 3, 6), labels=['b4', 'b3', 'b6'])
with self.assertWarns(RuntimeWarning) as cm:
ta, tb = merge(ta, tb, bondName='o')
self.assertIn('link.py', cm.filename)
ta = Tensor(shape=(3, 4, 5), labels=['a3', 'a4', 'a5'])
tb = Tensor(shape=(4, 3, 6), labels=['b4', 'b3', 'b6'])
with self.assertWarns(RuntimeWarning) as cm:
ta, tb = merge(ta, tb, bondName='o', chi=2)
# print(cm.__dict__)
self.assertIn('link.py', cm.filename)
ta = Tensor(shape=(3, 4, 5), labels=['a3', 'a4', 'a5'])
tb = Tensor(shape=(4, 3, 6), labels=['b4', 'b3', 'b6'])
makeLink('a3', 'b3', ta, tb)
makeLink('a4', 'b4', ta, tb)
ta, tb = merge(ta, tb, chi=2)
self.assertTrue(funcs.compareLists(ta.labels, ['a3|a4', 'a5']))
self.assertTrue(funcs.compareLists(tb.labels, ['b3|b4', 'b6']))
ta.reArrange(['a3|a4', 'a5'])
self.assertTupleEqual(ta.shape, (2, 5))
tb.reArrange(['b3|b4', 'b6'])
self.assertTupleEqual(tb.shape, (2, 6))
self.assertEqual(len(shareBonds(ta, tb)), 1)
ta = Tensor(shape=(3, 4, 5),
labels=['a3', 'a4', 'a5'],
tensorLikeFlag=True)
tb = Tensor(shape=(4, 3, 6),
labels=['b4', 'b3', 'b6'],
tensorLikeFlag=True)
makeLink('a3', 'b3', ta, tb)
makeLink('a4', 'b4', ta, tb)
ta, tb = merge(ta, tb, chi=2)
# print(ta, tb)
self.assertTrue(funcs.compareLists(ta.labels, ['a3|a4', 'a5']))
self.assertTrue(funcs.compareLists(tb.labels, ['b3|b4', 'b6']))
ta.reArrange(['a3|a4', 'a5'])
self.assertTupleEqual(ta.shape, (2, 5))
tb.reArrange(['b3|b4', 'b6'])
self.assertTupleEqual(tb.shape, (2, 6))
self.assertEqual(len(shareBonds(ta, tb)), 1)
self.assertTrue(ta.tensorLikeFlag and tb.tensorLikeFlag)
ta = Tensor(shape=(3, 4, 5), labels=['a3', 'a4', 'a5'])
tb = Tensor(shape=(4, 3, 6), labels=['b4', 'b3', 'b6'])
makeLink('a3', 'b3', ta, tb)
makeLink('a4', 'b4', ta, tb)
# large chi test
ta, tb = merge(ta, tb, chi=15)
# the real internal bond size is chosen by min(chi, ta.remainShape, tb.remainShape, mergeShape)
self.assertTrue(funcs.compareLists(ta.labels, ['a3|a4', 'a5']))
self.assertTrue(funcs.compareLists(tb.labels, ['b3|b4', 'b6']))
ta.reArrange(['a3|a4', 'a5'])
self.assertTupleEqual(ta.shape, (5, 5))
tb.reArrange(['b3|b4', 'b6'])
self.assertTupleEqual(tb.shape, (5, 6))
self.assertEqual(len(shareBonds(ta, tb)), 1)
