def test_get_diag(dtype, num_charges, Ds, flow):
np.random.seed(10)
np_flow = -np.int((np.int(flow) - 0.5) * 2)
indices = [
Index(
BaseCharge(np.random.randint(-2, 3, (Ds[n], num_charges)),
charge_types=[U1Charge] * num_charges), flow)
for n in range(2)
]
arr = BlockSparseTensor.random(indices, dtype=dtype)
fused = fuse_charges(arr.flat_charges, arr.flat_flows)
inds = np.nonzero(fused == np.zeros((1, num_charges), dtype=np.int16))[0]
# pylint: disable=no-member
left, _ = np.divmod(inds, Ds[1])
unique_charges = unique(np_flow *
(indices[0]._charges[0].charges[left, :]))
diagonal = diag(arr)
sparse_blocks, _, block_shapes = _find_diagonal_sparse_blocks(
arr.flat_charges, arr.flat_flows, 1)
data = np.concatenate([
np.diag(np.reshape(arr.data[sparse_blocks[n]], block_shapes[:, n]))
for n in range(len(sparse_blocks))
])
np.testing.assert_allclose(data, diagonal.data)
np.testing.assert_allclose(unique_charges,
diagonal.flat_charges[0].unique_charges)
def get_chargearray(num_charges, dtype=np.float64):
D = np.random.randint(8, 12)
charge = BaseCharge(np.random.randint(-5, 6, (num_charges, D)),
charge_types=[U1Charge] * num_charges)
flow = False
index = Index(charge, flow)
return ChargeArray.random(indices=[index], dtype=dtype)
def test_BaseCharge_len():
D = 300
B = 5
np.random.seed(10)
q = np.random.randint(-B // 2, B // 2 + 1, (D, 2)).astype(np.int16)
Q = BaseCharge(charges=q)
assert len(Q) == 300
def test_ChargeArray_transpose_reshape_transpose_data(num_charges):
Ds = np.array([8, 9, 10, 11])
flows = [True, False, True, False]
indices = [
Index(
BaseCharge(np.random.randint(-5, 6, (num_charges, Ds[n])),
charge_types=[U1Charge] * num_charges), flows[n])
for n in range(4)
]
arr = ChargeArray.random(indices)
nparr = np.reshape(arr.data, Ds)
arr2 = arr.transpose([2, 0, 1, 3])
nparr2 = nparr.transpose([2, 0, 1, 3])
arr3 = arr2.reshape([80, 99])
nparr3 = nparr2.reshape([80, 99])
arr4 = arr3.transpose([1, 0])
nparr4 = nparr3.transpose([1, 0])
arr5 = arr4.reshape([9, 11, 10, 8])
nparr5 = nparr4.reshape([9, 11, 10, 8])
np.testing.assert_allclose(arr3.transpose_data().data,
np.ascontiguousarray(nparr3).flat)
np.testing.assert_allclose(arr4.transpose_data().data,
np.ascontiguousarray(nparr4).flat)
np.testing.assert_allclose(arr5.transpose_data().data,
np.ascontiguousarray(nparr5).flat)
def test_pinv(dtype, num_charges):
np.random.seed(10)
R = 2
D = 10
charge = BaseCharge(np.random.randint(-5,
6, (D, num_charges),
dtype=np.int16),
charge_types=[U1Charge] * num_charges)
flows = [True, False]
A = BlockSparseTensor.random([Index(charge, flows[n]) for n in range(R)],
(-0.5, 0.5),
dtype=dtype)
invA = pinv(A)
left_eye = invA @ A
blocks, _, shapes = _find_diagonal_sparse_blocks(left_eye.flat_charges,
left_eye.flat_flows, 1)
for n, block in enumerate(blocks):
t = np.reshape(left_eye.data[block], shapes[:, n])
assert np.linalg.norm(t - np.eye(t.shape[0], t.shape[1])) < 1E-12
right_eye = A @ invA
blocks, _, shapes = _find_diagonal_sparse_blocks(right_eye.flat_charges,
right_eye.flat_flows, 1)
for n, block in enumerate(blocks):
t = np.reshape(right_eye.data[block], shapes[:, n])
assert np.linalg.norm(t - np.eye(t.shape[0], t.shape[1])) < 1E-12
def test_diagonal(Ds, dtype, num_charges, flow):
np.random.seed(10)
backend = symmetric_backend.SymmetricBackend()
np_flow = -np.int((np.int(flow) - 0.5) * 2)
indices = [
Index(
BaseCharge(np.random.randint(-2, 3, (Ds[n], num_charges)),
charge_types=[U1Charge] * num_charges), flow)
for n in range(2)
]
arr = BlockSparseTensor.random(indices, dtype=dtype)
fused = fuse_charges(arr.flat_charges, arr.flat_flows)
inds = np.nonzero(fused == np.zeros((1, num_charges), dtype=np.int16))[0]
# pylint: disable=no-member
left, _ = np.divmod(inds, Ds[1])
unique = np.unique(np_flow * (indices[0]._charges[0].charges[left, :]),
axis=0)
diagonal = backend.diagonal(arr)
sparse_blocks, _, block_shapes = _find_diagonal_sparse_blocks(
arr.flat_charges, arr.flat_flows, 1)
data = np.concatenate([
np.diag(np.reshape(arr.data[sparse_blocks[n]], block_shapes[:, n]))
for n in range(len(sparse_blocks))
])
np.testing.assert_allclose(data, diagonal.data)
np.testing.assert_allclose(unique, diagonal.flat_charges[0].unique_charges)
with pytest.raises(NotImplementedError):
diagonal = backend.diagonal(arr, axis1=0)
with pytest.raises(NotImplementedError):
diagonal = backend.diagonal(arr, axis2=1)
with pytest.raises(NotImplementedError):
diagonal = backend.diagonal(arr, offset=1)
def get_contractable_tensors(R1, R2, cont, dtype, num_charges, DsA, Dscomm,
DsB):
assert R1 >= cont
assert R2 >= cont
chargesA = [
BaseCharge(np.random.randint(-5, 5, (num_charges, DsA[n])),
charge_types=[U1Charge] * num_charges)
for n in range(R1 - cont)
]
commoncharges = [
BaseCharge(np.random.randint(-5, 5, (num_charges, Dscomm[n])),
charge_types=[U1Charge] * num_charges) for n in range(cont)
]
chargesB = [
BaseCharge(np.random.randint(-5, 5, (num_charges, DsB[n])),
charge_types=[U1Charge] * num_charges)
for n in range(R2 - cont)
]
#contracted indices
indsA = np.random.choice(np.arange(R1), cont, replace=False)
indsB = np.random.choice(np.arange(R2), cont, replace=False)
flowsA = np.full(R1, False, dtype=np.bool)
flowsB = np.full(R2, False, dtype=np.bool)
flowsB[indsB] = True
indicesA = [None for _ in range(R1)]
indicesB = [None for _ in range(R2)]
for n, ia in enumerate(indsA):
indicesA[ia] = Index(commoncharges[n], flowsA[ia])
indicesB[indsB[n]] = Index(commoncharges[n], flowsB[indsB[n]])
compA = list(set(np.arange(R1)) - set(indsA))
compB = list(set(np.arange(R2)) - set(indsB))
for n, ca in enumerate(compA):
indicesA[ca] = Index(chargesA[n], flowsA[ca])
for n, cb in enumerate(compB):
indicesB[cb] = Index(chargesB[n], flowsB[cb])
indices_final = []
for n in sorted(compA):
indices_final.append(indicesA[n])
for n in sorted(compB):
indices_final.append(indicesB[n])
A = BlockSparseTensor.random(indices=indicesA, dtype=dtype)
B = BlockSparseTensor.random(indices=indicesB, dtype=dtype)
return A, B, indsA, indsB
def test_BaseCharge_charges():
D = 100
B = 6
np.random.seed(10)
charges = np.random.randint(-B // 2, B // 2 + 1, (D, 2)).astype(np.int16)
q1 = BaseCharge(charges)
np.testing.assert_allclose(q1.charges, charges)
def test_eye_dtype(dtype, num_charges):
np.random.seed(10)
backend = symmetric_backend.SymmetricBackend()
index = Index(
BaseCharge(np.random.randint(-5, 6, (num_charges, 100)),
charge_types=[U1Charge] * num_charges), False)
actual = backend.eye(index, dtype=dtype)
assert actual.dtype == dtype
def get_square_matrix(num_charges, dtype=np.float64):
D = np.random.randint(40, 60)
charges = BaseCharge(np.random.randint(-5, 6, (num_charges, D)),
charge_types=[U1Charge] * num_charges)
flows = [False, True]
indices = [Index(charges, flows[n]) for n in range(2)]
return BlockSparseTensor.random(indices=indices, dtype=dtype)
def get_hermitian_matrix(num_charges, dtype=np.float64):
D = np.random.randint(40, 60)
charges = BaseCharge(np.random.randint(-5, 6, (D, num_charges)),
charge_types=[U1Charge] * num_charges)
flows = [False, True]
indices = [Index(charges, flows[n]) for n in range(2)]
A = BlockSparseTensor.random(indices=indices, dtype=dtype)
return A + A.conj().T
def get_tensor(R, num_charges, dtype=np.float64):
Ds = np.random.randint(8, 12, R)
charges = [
BaseCharge(np.random.randint(-5, 6, (num_charges, Ds[n])),
charge_types=[U1Charge] * num_charges) for n in range(R)
]
flows = list(np.full(R, fill_value=False, dtype=np.bool))
indices = [Index(charges[n], flows[n]) for n in range(R)]
return BlockSparseTensor.random(indices=indices, dtype=dtype)
def test_eq__raises():
np.random.seed(10)
num_charges = 2
charge = BaseCharge(np.random.randint(-2, 3, (30, num_charges)),
charge_types=[U1Charge] * num_charges)
with pytest.raises(ValueError):
_ = charge == np.random.randint(-1,
1, (2, num_charges + 1),
dtype=np.int16)
def test_BaseCharge_unique():
D = 3000
B = 5
np.random.seed(10)
q = np.random.randint(-B // 2, B // 2 + 1, (2, D)).astype(np.int16)
Q = BaseCharge(charges=q, charge_types=[U1Charge, U1Charge])
expected = np.unique(q,
return_index=True,
return_inverse=True,
return_counts=True,
axis=1)
actual = Q.unique(return_index=True,
return_inverse=True,
return_counts=True)
assert np.all(actual[0].charges == expected[0])
assert np.all(actual[1] == expected[1])
assert np.all(actual[2] == expected[2])
assert np.all(actual[3] == expected[3])
def get_zeros(shape, num_charges, dtype=np.float64):
R = len(shape)
charges = [
BaseCharge(np.random.randint(-5, 6, (num_charges, shape[n])),
charge_types=[U1Charge] * num_charges) for n in range(R)
]
flows = list(np.full(R, fill_value=False, dtype=np.bool))
indices = [Index(charges[n], flows[n]) for n in range(R)]
return BlockSparseTensor.zeros(indices=indices, dtype=dtype)
def get_charge(chargetype, num_charges, D):
if chargetype == "U1":
out = BaseCharge(np.random.randint(-5, 6, (D, num_charges)),
charge_types=[U1Charge] * num_charges)
if chargetype == "Z2":
out = BaseCharge(np.random.randint(0, 2, (D, num_charges)),
charge_types=[Z2Charge] * num_charges)
if chargetype == "mixed":
n1 = num_charges // 2 if num_charges > 1 else 1
out = BaseCharge(np.random.randint(-5, 6, (D, n1)),
charge_types=[U1Charge] * n1)
if num_charges > 1:
n2 = num_charges - n1
out = out @ BaseCharge(np.random.randint(0, 2, (D, n2)),
charge_types=[Z2Charge] * n2)
return out
def test_ChargeArray_todense(dtype, num_charges):
Ds = [8, 9, 10, 11]
indices = [
Index(
BaseCharge(np.random.randint(-5, 6, (num_charges, Ds[n])),
charge_types=[U1Charge] * num_charges), False)
for n in range(4)
]
arr = ChargeArray.random(indices, dtype=dtype)
np.testing.assert_allclose(arr.todense(), np.reshape(arr.data, Ds))
def test_BaseCharge_generic():
D = 300
B = 5
np.random.seed(10)
q = np.random.randint(-B // 2, B // 2 + 1, (D, 2)).astype(np.int16)
unique_charges = np.unique(q, axis=0)
Q = BaseCharge(charges=q)
assert Q.dim == 300
assert Q.num_symmetries == 2
assert Q.num_unique == unique_charges.shape[0]
def get_charge(chargetype, num_charges, D):
if chargetype == "U1":
return BaseCharge(np.random.randint(-5, 6, (num_charges, D)),
charge_types=[U1Charge] * num_charges)
if chargetype == "Z2":
return BaseCharge(np.random.randint(0, 2, (num_charges, D)),
charge_types=[Z2Charge] * num_charges)
if chargetype == "mixed":
n1 = num_charges // 2 if num_charges > 1 else 1
c = BaseCharge(np.random.randint(-5, 6, (n1, D)),
charge_types=[U1Charge] * n1)
if num_charges > 1:
n2 = num_charges - n1
c = c @ BaseCharge(np.random.randint(0, 2, (n2, D)),
charge_types=[Z2Charge] * n2)
return c
return None
def test_zeros_dtype(R, dtype, num_charges):
np.random.seed(10)
backend = symmetric_backend.SymmetricBackend()
indices = [
Index(
BaseCharge(np.random.randint(-5, 6, (num_charges, 10)),
charge_types=[U1Charge] * num_charges), False)
for _ in range(R)
]
actual = backend.zeros(indices, dtype=dtype)
assert actual.dtype == dtype
def test_reduce_charges_2():
left_charges = np.asarray([[-2, 0, 1, 0, 0], [-3, 0, 2, 1,
0]]).astype(np.int16).T
right_charges = np.asarray([[-1, 0, 2, 1], [-2, 2, 7, 0]]).astype(np.int16).T
target_charge = np.zeros((1, 2), dtype=np.int16)
fused_charges = fuse_ndarray_charges(left_charges, right_charges,
[U1Charge, U1Charge])
dense_positions = reduce_charges([
BaseCharge(left_charges, charge_types=[U1Charge, U1Charge]),
BaseCharge(right_charges, charge_types=[U1Charge, U1Charge])
], [False, False],
target_charge,
return_locations=True)
np.testing.assert_allclose(dense_positions[0].charges, 0)
#pylint: disable=no-member
np.testing.assert_allclose(
dense_positions[1],
np.nonzero(np.logical_and.reduce(fused_charges == target_charge,
axis=1))[0])
def test_trace_tensor(dtype, num_charges, D1, D2):
np.random.seed(10)
charge1 = BaseCharge(np.random.randint(-5,
6, (num_charges, D1),
dtype=np.int16),
charge_types=[U1Charge] * num_charges)
charge2 = BaseCharge(np.random.randint(-5,
6, (num_charges, D2),
dtype=np.int16),
charge_types=[U1Charge] * num_charges)
indices = [
Index(charge1, False),
Index(charge2, False),
Index(charge1, True)
]
tensor = BlockSparseTensor.random(indices, dtype=dtype)
res = trace(tensor, (0, 2))
assert res.sparse_shape[0] == indices[1]
res_dense = np.trace(tensor.todense(), axis1=0, axis2=2)
np.testing.assert_allclose(res.todense(), res_dense)
def test_random_uniform_non_zero_imag(R, dtype, num_charges):
np.random.seed(10)
backend = symmetric_backend.SymmetricBackend()
indices = [
Index(
BaseCharge(np.random.randint(-5, 6, (num_charges, 10)),
charge_types=[U1Charge] * num_charges), False)
for _ in range(R)
]
actual = backend.random_uniform(indices, dtype=dtype, seed=10)
assert np.linalg.norm(np.imag(actual.data)) != 0.0
def test_eye(dtype, num_charges, D):
charge = BaseCharge(
np.random.randint(-5, 6, (num_charges, D), dtype=np.int16),
charge_types=[U1Charge] * num_charges)
flow = False
index = Index(charge, flow)
A = eye(index, dtype=dtype)
blocks, _, shapes = _find_diagonal_sparse_blocks(A.flat_charges, A.flat_flows,
1)
for n, block in enumerate(blocks):
t = np.reshape(A.data[block], shapes[:, n])
np.testing.assert_almost_equal(t, np.eye(t.shape[0], t.shape[1]))
def test_trace_matrix(dtype, num_charges, D):
np.random.seed(10)
R = 2
charge = BaseCharge(
np.random.randint(-5, 6, (num_charges, D), dtype=np.int16),
charge_types=[U1Charge] * num_charges)
flows = [True, False]
matrix = BlockSparseTensor.random([Index(charge, flows[n]) for n in range(R)],
dtype=dtype)
res = trace(matrix)
res_dense = np.trace(matrix.todense())
np.testing.assert_allclose(res.data, res_dense)
def test_pinv_raises():
num_charges = 1
np.random.seed(10)
R = 3
D = 10
charge = BaseCharge(
np.random.randint(-5, 6, (num_charges, D), dtype=np.int16),
charge_types=[U1Charge] * num_charges)
A = BlockSparseTensor.random([Index(charge, False) for n in range(R)],
(-0.5, 0.5))
with pytest.raises(ValueError):
pinv(A)
def test_BaseCharge_single_unique():
D = 30
np.random.seed(10)
q = np.ones((D, 2), dtype=np.int16)
Q = BaseCharge(charges=q, charge_types=[U1Charge, U1Charge])
expected = np.unique(q,
return_index=True,
return_inverse=True,
return_counts=True,
axis=0)
actual = Q.unique(return_index=True,
return_inverse=True,
return_counts=True)
assert np.all(actual[0].charges == expected[0])
assert np.all(actual[1] == expected[1])
assert np.all(actual[2] == expected[2])
assert np.all(actual[3] == expected[3])
expected = np.unique(q, axis=0)
actual = Q.unique()
assert np.all(actual.charges == expected)
def test_random_uniform_dtype(dtype, num_charges):
np.random.seed(10)
R = 4
backend = symmetric_backend.SymmetricBackend()
indices = [
Index(
BaseCharge(np.random.randint(-5, 6, (num_charges, 10)),
charge_types=[U1Charge] * num_charges), False)
for _ in range(R)
]
actual = backend.random_uniform(indices, dtype=dtype, seed=10)
assert actual.dtype == dtype
def test_eye(dtype, num_charges):
np.random.seed(10)
backend = symmetric_backend.SymmetricBackend()
index = Index(
BaseCharge(np.random.randint(-5, 6, (num_charges, 100)),
charge_types=[U1Charge] * num_charges), False)
actual = backend.eye(index, dtype=dtype)
expected = eye(index, dtype=dtype)
np.testing.assert_allclose(expected.data, actual.data)
assert np.all([
charge_equal(expected._charges[n], actual._charges[n])
for n in range(len(actual._charges))
])
def test_get_empty_diag(dtype, num_charges, Ds):
np.random.seed(10)
indices = [
Index(
BaseCharge(np.random.randint(-2, 3, (num_charges, Ds[n])),
charge_types=[U1Charge] * num_charges), False)
for n in range(2)
]
arr = BlockSparseTensor.random(indices, dtype=dtype)
diagonal = diag(arr)
np.testing.assert_allclose([], diagonal.data)
for c in diagonal.flat_charges:
assert len(c) == 0
