def test_conjugate(self):
x = get_random_symmetric_matrices(10, 4)
x_imag = sm.imag(x)
conj_x = sm.conjugate(x)
self.assertAllEqual(-x_imag, sm.imag(conj_x))
self.assertAllEqual(x_imag, sm.imag(x))
def test_multiply_by_i(self):
x = get_random_symmetric_matrices(10, 4)
result = sm.multiply_by_i(x)
expected_real = sm.real(result)
expected_imag = sm.imag(result)
self.assertAllEqual(expected_real, -sm.imag(x))
self.assertAllEqual(expected_imag, sm.real(x))
def test_takagi_factorization_very_large_values(self):
a = get_random_symmetric_matrices(3, 3) * 1000
eigenvalues, s = TakagiFactorization(3).factorize(a)
diagonal = torch.diag_embed(eigenvalues)
diagonal = sm.stick(diagonal, torch.zeros_like(diagonal))
self.assertAllClose(
a, sm.bmm3(sm.conjugate(s), diagonal, sm.conj_trans(s)))
def test_to_symmetric(self):
x = get_random_symmetric_matrices(10, 4)
x_real = sm.real(x)
x_imag = sm.imag(x)
x_real_transpose = x_real.transpose(-1, -2)
x_imag_transpose = x_imag.transpose(-1, -2)
self.assertAllEqual(x_real, x_real_transpose)
self.assertAllEqual(x_imag, x_imag_transpose)
def test_proj_x_real_pos_imag_pos(self):
x = get_random_symmetric_matrices(10, self.dims)
proj_x = self.manifold.projx(x)
# assert symmetry
self.assertAllClose(proj_x, sm.transpose(proj_x))
# assert all points belong to the manifold
for point in proj_x:
self.assertTrue(self.manifold.check_point_on_manifold(point))
def test_takagi_factorization_real_neg_imag_neg(self):
a = get_random_symmetric_matrices(3, 3)
a = sm.stick(sm.real(a) * -1, sm.imag(a) * -1)
eigenvalues, s = TakagiFactorization(3).factorize(a)
diagonal = torch.diag_embed(eigenvalues)
diagonal = sm.stick(diagonal, torch.zeros_like(diagonal))
self.assertAllClose(
a, sm.bmm3(sm.conjugate(s), diagonal, sm.conj_trans(s)))
def test_takagi_factorization_real_identity(self):
a = sm.identity_like(get_random_symmetric_matrices(3, 3))
eigenvalues, s = TakagiFactorization(3).factorize(a)
diagonal = torch.diag_embed(eigenvalues)
diagonal = sm.stick(diagonal, torch.zeros_like(diagonal))
self.assertAllClose(
a, sm.bmm3(sm.conjugate(s), diagonal, sm.conj_trans(s)))
self.assertAllClose(a, s)
self.assertAllClose(torch.ones_like(eigenvalues), eigenvalues)
def test_proj_x_real_neg_imag_neg(self):
x = get_random_symmetric_matrices(10, 3)
x = sm.stick(sm.real(x) * -1, sm.imag(x) * -1)
proj_x = self.manifold.projx(x)
# assert symmetry
self.assertAllClose(proj_x, sm.transpose(proj_x))
# assert all points belong to the manifold
for point in proj_x:
self.assertTrue(self.manifold.check_point_on_manifold(point))
def test_conj_transpose(self):
x = get_random_symmetric_matrices(10, 4)
x_real = sm.real(x)
x_imag = sm.imag(x)
x_real_transpose = x_real.transpose(-1, -2)
x_imag_transpose = x_imag.transpose(-1, -2)
x_expected_conj_transpose = sm.stick(x_real_transpose,
x_imag_transpose * -1)
x_result_conj_transpose = sm.conj_trans(x)
self.assertAllEqual(x_expected_conj_transpose, x_result_conj_transpose)
def test_inverse_cayley_transform_from_projx(self):
x = get_random_symmetric_matrices(10, 3)
x = self.bounded_manifold.projx(x)
tran_x = inverse_cayley_transform(x)
result = cayley_transform(tran_x)
self.assertAllClose(x, result)
# the intermediate result belongs to the Upper Half Space manifold
for point in tran_x:
self.assertTrue(self.upper_half_manifold.check_point_on_manifold(point))
# the final result belongs to the Bounded domain manifold
for point in result:
self.assertTrue(self.bounded_manifold.check_point_on_manifold(point))
def test_transpose(self):
x = get_random_symmetric_matrices(10, 4)
x_real = sm.real(x)
x_imag = sm.imag(x)
x_real_transpose = x_real.transpose(-1, -2)
x_imag_transpose = x_imag.transpose(-1, -2)
x_expected_transpose = sm.stick(x_real_transpose, x_imag_transpose)
x_result_transpose = sm.transpose(x)
self.assertAllEqual(x_expected_transpose, x_result_transpose)
self.assertAllEqual(
x, x_result_transpose) # because they are symmetric matrices
def test_takagi_factorization_real_diagonal(self):
a = get_random_symmetric_matrices(3, 3) * 10
a = torch.where(sm.identity_like(a) == 1, a, torch.zeros_like(a))
eigenvalues, s = TakagiFactorization(3).factorize(a)
diagonal = torch.diag_embed(eigenvalues)
diagonal = sm.stick(diagonal, torch.zeros_like(diagonal))
self.assertAllClose(
a, sm.bmm3(sm.conjugate(s), diagonal, sm.conj_trans(s)))
# real part of eigenvectors is made of vectors with one 1 and all zeros
real_part = torch.sum(torch.abs(sm.real(s)), dim=-1)
self.assertAllClose(torch.ones_like(real_part), real_part)
# imaginary part of eigenvectors is all zeros
self.assertAllClose(torch.zeros(1), torch.sum(sm.imag(s)))
def test_subtract(self):
x = get_random_symmetric_matrices(10, 4)
result = torch.zeros_like(x)
self.assertAllEqual(result, sm.subtract(x, x))
def test_add(self):
x = get_random_symmetric_matrices(10, 4)
expected = x * 2
self.assertAllEqual(expected, sm.add(x, x))