def __init__(self, n): super(_SpecialOrthogonalMatrices, self).__init__(dim=int((n * (n - 1)) / 2), default_point_type='matrix', n=n) self.lie_algebra = SkewSymmetricMatrices(n=n) self.bi_invariant_metric = BiInvariantMetric(group=self)
def test_structure_constant(self): group = self.matrix_so3 lie_algebra = SkewSymmetricMatrices(3) metric = InvariantMetric(group=group, algebra=lie_algebra) basis = lie_algebra.orthonormal_basis(metric.metric_mat_at_identity) x, y, z = basis result = metric.structure_constant(-z, y, -x) expected = 2.**.5 / 2. self.assertAllClose(result, expected) result = -metric.structure_constant(y, -z, -x) self.assertAllClose(result, expected) result = metric.structure_constant(y, -x, -z) self.assertAllClose(result, expected) result = -metric.structure_constant(-x, y, -z) self.assertAllClose(result, expected) result = metric.structure_constant(-x, -z, y) self.assertAllClose(result, expected) result = -metric.structure_constant(-z, -x, y) self.assertAllClose(result, expected) result = metric.structure_constant(x, x, z) expected = 0. self.assertAllClose(result, expected)
def test_inner_product_left(self): lie_algebra = SkewSymmetricMatrices(3) tangent_vec_a = lie_algebra.matrix_representation(gs.array([1., 0, 2.])) tangent_vec_a = self.matrix_so3.compose(self.point_1_matrix, tangent_vec_a) tangent_vec_b = lie_algebra.matrix_representation( gs.array([1., 0, 0.5])) tangent_vec_b = self.matrix_so3.compose(self.point_1_matrix, tangent_vec_b) result = self.matrix_left_metric.inner_product(tangent_vec_a, tangent_vec_b, self.point_1_matrix) expected = 4. self.assertAllClose(result, expected) tangent_vec_a = lie_algebra.matrix_representation( gs.array([[1., 0, 2.], [0, 3., 5.]])) tangent_vec_a = self.matrix_so3.compose(self.point_1_matrix, tangent_vec_a) result = self.matrix_left_metric.inner_product(tangent_vec_a, tangent_vec_b, self.point_1_matrix) expected = gs.array([4., 5.]) self.assertAllClose(result, expected)
def test_sectional_curvature(self): group = self.matrix_so3 lie_algebra = SkewSymmetricMatrices(3) metric = InvariantMetric(group=group, algebra=lie_algebra) x, y, z = lie_algebra.orthonormal_basis(metric.metric_mat_at_identity) result = metric.sectional_curvature(x, y) expected = 1. / 8 self.assertAllClose(result, expected) point = group.random_uniform() translation_map = group.tangent_translation_map(point) tan_a = translation_map(-z) tan_b = translation_map(y) result = metric.sectional_curvature(tan_a, tan_b, point) self.assertAllClose(result, expected) tan_a = gs.stack([x, y]) tan_b = gs.stack([z] * 2) result = metric.sectional_curvature(tan_a, tan_b) self.assertAllClose(result, gs.array([expected] * 2)) result = metric.sectional_curvature(y, y) expected = 0. self.assertAllClose(result, expected)
def test_baker_campbell_hausdorff(self, n, matrix_a, matrix_b, order, expected): skew = SkewSymmetricMatrices(n) result = skew.baker_campbell_hausdorff(gs.array(matrix_a), gs.array(matrix_b), order=order) self.assertAllClose(result, gs.array(expected))
class TestLieAlgebraMethods(geomstats.tests.TestCase): def setUp(self): self.n = 4 self.dim = int(self.n * (self.n - 1) / 2) self.algebra = SkewSymmetricMatrices(n=self.n) def test_dimension(self): result = self.algebra.dim expected = self.dim self.assertAllClose(result, expected) @geomstats.tests.np_only def test_matrix_representation_and_belongs(self): n_samples = 2 point = gs.random.rand(n_samples * self.dim) point = gs.reshape(point, (n_samples, self.dim)) mat = self.algebra.matrix_representation(point) result = self.algebra.belongs(mat).all() expected = True self.assertAllClose(result, expected) @geomstats.tests.np_only def test_basis_and_matrix_representation(self): n_samples = 2 expected = gs.random.rand(n_samples * self.dim) expected = gs.reshape(expected, (n_samples, self.dim)) mat = self.algebra.matrix_representation(expected) result = self.algebra.basis_representation(mat) self.assertAllClose(result, expected)
def test_curvature(self): group = self.matrix_so3 lie_algebra = SkewSymmetricMatrices(3) metric = InvariantMetric(group=group, algebra=lie_algebra) x, y, z = lie_algebra.orthonormal_basis(metric.metric_mat_at_identity) result = metric.curvature_at_identity(x, y, x) expected = 1. / 8 * y self.assertAllClose(result, expected) tan_a = gs.stack([x, x]) tan_b = gs.stack([y] * 2) result = metric.curvature(tan_a, tan_b, tan_a) self.assertAllClose(result, gs.array([expected] * 2)) point = group.random_uniform() translation_map = group.tangent_translation_map(point) tan_a = translation_map(x) tan_b = translation_map(y) result = metric.curvature(tan_a, tan_b, tan_a, point) expected = translation_map(expected) self.assertAllClose(result, expected) result = metric.curvature(y, y, z) expected = gs.zeros_like(z) self.assertAllClose(result, expected)
def test_dual_adjoint(self): group = self.matrix_so3 lie_algebra = SkewSymmetricMatrices(3) metric = InvariantMetric(group=group, algebra=lie_algebra) basis = lie_algebra.orthonormal_basis(metric.metric_mat_at_identity) for x in basis: for y in basis: for z in basis: result = metric.inner_product_at_identity( metric.dual_adjoint(x, y), z) expected = metric.structure_constant(x, z, y) self.assertAllClose(result, expected)
def __init__(self, n): dim = int(n * (n + 1) / 2) super(SpecialEuclideanMatrixLieAlgebra, self).__init__(dim, n) self.skew = SkewSymmetricMatrices(n) basis = homogeneous_representation( self.skew.basis, gs.zeros((self.skew.dim, n)), (self.skew.dim, n + 1, n + 1), 0.) basis = list(basis) for row in gs.arange(n): basis.append(gs.array_from_sparse( [(row, n)], [1.], (n + 1, n + 1))) self.basis = gs.stack(basis)
class TestLieAlgebra(geomstats.tests.TestCase): def setUp(self): self.n = 4 self.dim = int(self.n * (self.n - 1) / 2) self.algebra = SkewSymmetricMatrices(n=self.n) def test_dimension(self): result = self.algebra.dim expected = self.dim self.assertAllClose(result, expected) def test_matrix_representation_and_belongs(self): n_samples = 2 point = gs.random.rand(n_samples * self.dim) point = gs.reshape(point, (n_samples, self.dim)) mat = self.algebra.matrix_representation(point) result = gs.all(self.algebra.belongs(mat)) expected = True self.assertAllClose(result, expected) @geomstats.tests.np_and_pytorch_only def test_basis_and_matrix_representation(self): n_samples = 2 expected = gs.random.rand(n_samples * self.dim) expected = gs.reshape(expected, (n_samples, self.dim)) mat = self.algebra.matrix_representation(expected) result = self.algebra.basis_representation(mat) self.assertAllClose(result, expected) def test_orthonormal_basis(self): group = SpecialOrthogonal(3) lie_algebra = SkewSymmetricMatrices(3) metric = InvariantMetric(group=group, algebra=lie_algebra) basis = lie_algebra.orthonormal_basis(metric.metric_mat_at_identity) result = metric.inner_product_at_identity(basis[0], basis[1]) self.assertAllClose(result, 0.) result = metric.inner_product_at_identity(basis[1], basis[1]) self.assertAllClose(result, 1.) metric_mat = from_vector_to_diagonal_matrix(gs.array([1., 2., 3.])) metric = InvariantMetric(group=group, algebra=lie_algebra, metric_mat_at_identity=metric_mat) basis = lie_algebra.orthonormal_basis(metric.metric_mat_at_identity) result = metric.inner_product_at_identity(basis[0], basis[1]) self.assertAllClose(result, 0.) result = metric.inner_product_at_identity(basis[1], basis[1]) self.assertAllClose(result, 1.)
def test_inner_product_at_identity(self): lie_algebra = SkewSymmetricMatrices(3) tangent_vec_a = lie_algebra.matrix_representation([1., 0, 2.])[0] tangent_vec_b = lie_algebra.matrix_representation([1., 0, 0.5])[0] result = self.matrix_left_metric.inner_product_at_identity( tangent_vec_a, tangent_vec_b) expected = 4. self.assertAllClose(result, expected) tangent_vec_a = lie_algebra.matrix_representation( [[1., 0, 2.], [0, 3., 5.]]) result = self.matrix_left_metric.inner_product_at_identity( tangent_vec_a, tangent_vec_b) expected = gs.array([4., 5.]) self.assertAllClose(result, expected)
def test_connection(self): group = self.matrix_so3 lie_algebra = SkewSymmetricMatrices(3) metric = InvariantMetric(group=group, algebra=lie_algebra) x, y, z = lie_algebra.orthonormal_basis(metric.metric_mat_at_identity) result = metric.connection(-z, y) expected = -1. / 2**.5 / 2. * x self.assertAllClose(result, expected) point = group.random_uniform() translation_map = group.tangent_translation_map(point) tan_a = translation_map(-z) tan_b = translation_map(y) result = metric.connection(tan_a, tan_b, point) expected = translation_map(expected) self.assertAllClose(result, expected)
def test_curvature_derivative_at_identity(self): group = self.matrix_so3 lie_algebra = SkewSymmetricMatrices(3) metric = InvariantMetric(group=group, algebra=lie_algebra) basis = lie_algebra.orthonormal_basis(metric.metric_mat_at_identity) result = True for x in basis: for i, y in enumerate(basis): for z in basis[i:]: for t in basis: nabla_r = metric.curvature_derivative_at_identity( x, y, z, t) if not gs.all(gs.isclose(nabla_r, 0., atol=1e-5)): print(nabla_r) result = False self.assertTrue(result)
def test_curvature_derivative(self): group = self.matrix_so3 lie_algebra = SkewSymmetricMatrices(3) metric = InvariantMetric(group=group, algebra=lie_algebra) x, y, z = lie_algebra.orthonormal_basis(metric.metric_mat_at_identity) result = metric.curvature_derivative(x, y, z, x) expected = gs.zeros_like(x) self.assertAllClose(result, expected) point = group.random_uniform() translation_map = group.tangent_translation_map(point) tan_a = translation_map(x) tan_b = translation_map(y) tan_c = translation_map(z) result = metric.curvature_derivative(tan_a, tan_b, tan_c, tan_a, point) expected = gs.zeros_like(x) self.assertAllClose(result, expected)
class _SpecialOrthogonalMatrices(GeneralLinear, LieGroup): """Class for special orthogonal groups in matrix representation. Parameters ---------- n : int Integer representing the shape of the matrices: n x n. """ def __init__(self, n): super(_SpecialOrthogonalMatrices, self).__init__(dim=int((n * (n - 1)) / 2), default_point_type='matrix', n=n) self.lie_algebra = SkewSymmetricMatrices(n=n) self.bi_invariant_metric = BiInvariantMetric(group=self) def belongs(self, point): """Check whether point is an orthogonal matrix.""" return self.equal(self.mul(point, self.transpose(point)), self.identity) @classmethod def inverse(cls, point): """Return the transpose matrix of point.""" return cls.transpose(point) def _is_in_lie_algebra(self, tangent_vec, atol=ATOL): return self.lie_algebra.belongs(tangent_vec, atol=atol) @classmethod def _to_lie_algebra(cls, tangent_vec): """Project vector onto skew-symmetric matrices.""" return cls.to_skew_symmetric(tangent_vec) def random_uniform(self, n_samples=1, tol=1e-6): """Sample in SO(n) from the uniform distribution. Parameters ---------- n_samples : int, optional (1) Number of samples. tol : unused Returns ------- samples : array-like, shape=[..., n, n] Points sampled on the SO(n). """ if n_samples == 1: random_mat = gs.random.rand(self.n, self.n) else: random_mat = gs.random.rand(n_samples, self.n, self.n) skew = self.to_tangent(random_mat) return self.exp(skew)
def test_orthonormal_basis(self): group = SpecialOrthogonal(3) lie_algebra = SkewSymmetricMatrices(3) metric = InvariantMetric(group=group, algebra=lie_algebra) basis = lie_algebra.orthonormal_basis(metric.metric_mat_at_identity) result = metric.inner_product_at_identity(basis[0], basis[1]) self.assertAllClose(result, 0.) result = metric.inner_product_at_identity(basis[1], basis[1]) self.assertAllClose(result, 1.) metric_mat = from_vector_to_diagonal_matrix(gs.array([1., 2., 3.])) metric = InvariantMetric(group=group, algebra=lie_algebra, metric_mat_at_identity=metric_mat) basis = lie_algebra.orthonormal_basis(metric.metric_mat_at_identity) result = metric.inner_product_at_identity(basis[0], basis[1]) self.assertAllClose(result, 0.) result = metric.inner_product_at_identity(basis[1], basis[1]) self.assertAllClose(result, 1.)
def baker_campbell_hausdorff_data(self): n_list = range(3, 10) smoke_data = [] for n in n_list: space = SkewSymmetricMatrices(n) fb = space.basis[0] sb = space.basis[1] fb_sb_bracket = space.bracket(fb, sb) expected1 = fb + sb expected2 = expected1 + 0.5 * fb_sb_bracket expected3 = (expected2 + 1.0 / 12.0 * space.bracket(fb, fb_sb_bracket) - 1.0 / 12.0 * space.bracket(sb, fb_sb_bracket)) expected4 = expected3 - 1.0 / 24.0 * space.bracket( sb, space.bracket(fb, fb_sb_bracket)) expected = [expected1, expected2, expected3, expected4] for order in range(1, 5): smoke_data.append( dict( n=n, matrix_a=fb, matrix_b=sb, order=order, expected=expected[order - 1], )) return self.generate_tests(smoke_data)
def transform(self, X, base_point=None): """Lift data to a tangent space. Compute the logs of all data point and reshapes them to 1d vectors if necessary. By default the logs are taken at the mean but any other base point can be passed. Any machine learning algorithm can then be used with the output array. Parameters ---------- X : array-like, shape=[..., {dim, [n, n]}] Data to transform. y : Ignored (Compliance with scikit-learn interface) base_point : array-like, shape={dim, [n,n]}, optional (mean) Point on the manifold, the returned samples will be tangent vectors at the base point. Returns ------- X_new : array-like, shape=[..., dim] Lifted data. """ if base_point is None: base_point = self.estimator.estimate_ if self.estimator.estimate_ is None: raise RuntimeError( "fit needs to be called first or a " "base_point passed." ) tangent_vecs = self._used_geometry.log(X, base_point=base_point) if self.point_type == "vector": return tangent_vecs if gs.all(Matrices.is_symmetric(tangent_vecs)): X = SymmetricMatrices.to_vector(tangent_vecs) elif gs.all(Matrices.is_skew_symmetric(tangent_vecs)): X = SkewSymmetricMatrices(tangent_vecs.shape[-1]).basis_representation( tangent_vecs ) else: X = gs.reshape(tangent_vecs, (len(X), -1)) return X
def inverse_transform(self, X, base_point=None): """Reconstruction of X. The reconstruction will match X_original whose transform would be X. Parameters ---------- X : array-like, shape=[..., dim] New data, where dim is the dimension of the manifold data belong to. base_point : array-like, shape={dim, [n,n]}, optional (mean) Point on the manifold, where the input samples are tangent vectors. Returns ------- X_original : array-like, shape=[..., {dim, [n, n]} Data lying on the manifold. """ if base_point is None: base_point = self.estimator.estimate_ if self.estimator.estimate_ is None: raise RuntimeError('fit needs to be called first or a ' 'base_point passed.') if self.point_type == 'matrix': n_base_point = base_point.shape[-1] n_vecs = X.shape[-1] dim_sym = int(n_base_point * (n_base_point + 1) / 2) dim_skew = int(n_base_point * (n_base_point - 1) / 2) if gs.all(Matrices.is_symmetric(base_point)) and dim_sym == n_vecs: tangent_vecs = SymmetricMatrices( base_point.shape[-1]).from_vector(X) elif dim_skew == n_vecs: tangent_vecs = SkewSymmetricMatrices( dim_skew).matrix_representation(X) else: dim = base_point.shape[-1] tangent_vecs = gs.reshape(X, (len(X), dim, dim)) else: tangent_vecs = X return self._used_geometry.exp(tangent_vecs, base_point)
def projection(self, mat): """Project a matrix to the Lie Algebra. Compute the skew-symmetric projection of the rotation part of matrix. Parameters ---------- mat : array-like, shape=[..., n + 1, n + 1] Matrix. Returns ------- projected : array-like, shape=[..., n + 1, n + 1] Matrix belonging to Lie Algebra. """ rotation = mat[..., :self.n, :self.n] skew = SkewSymmetricMatrices.projection(rotation) return homogeneous_representation(skew, mat[..., :self.n, self.n], mat.shape, 0.0)
def load_connectomes(as_vectors=False): """Load data from brain connectomes. Load the correlation data from the kaggle MSLP 2014 Schizophrenia Challenge. The original data came as flattened vectors, but if `raw=True` is passed, the correlation values are reshaped as symmetric matrices with ones on the diagonal. Parameters ---------- as_vectors : bool Whether to return raw data as vectors or as symmetric matrices. Optional, default: False Returns ------- mat : array-like, shape=[86, {[28, 28], 378} Connectomes. patient_id : array-like, shape=[86,] Patient unique identifiers target : array-like, shape=[86,] Labels, whether patients belong to the diseased class (1) or control (0). """ with open(CONNECTOMES_PATH) as csvfile: data_list = list(csv.reader(csvfile)) patient_id = gs.array([int(row[0]) for row in data_list[1:]]) data = gs.array([[float(value) for value in row[1:]] for row in data_list[1:]]) with open(CONNECTOMES_LABELS_PATH) as csvfile: labels = list(csv.reader(csvfile)) target = gs.array([int(row[1]) for row in labels[1:]]) if as_vectors: return data, patient_id, target mat = SkewSymmetricMatrices(28).matrix_representation(data) mat = gs.eye(28) - gs.transpose(gs.tril(mat), (0, 2, 1)) mat = 1.0 / 2.0 * (mat + gs.transpose(mat, (0, 2, 1))) return mat, patient_id, target
def setUp(self): self.n = 4 self.dim = int(self.n * (self.n - 1) / 2) self.algebra = SkewSymmetricMatrices(n=self.n)
class SpecialEuclideanMatrixLieAlgebra(MatrixLieAlgebra): r"""Lie Algebra of the special Euclidean group. This is the tangent space at the identity. It is identified with the :math:`n + 1 \times n + 1` block matrices of the form: .. math: ((A, t), (0, 0)) where A is an :math:`n \times n` skew-symmetric matrix, :math: `t` is an n-dimensional vector. Parameters ---------- n : int Integer dimension of the underlying Euclidean space. Matrices will be of size: (n+1) x (n+1). """ def __init__(self, n): dim = int(n * (n + 1) / 2) super(SpecialEuclideanMatrixLieAlgebra, self).__init__(dim, n + 1) self.skew = SkewSymmetricMatrices(n) self.n = n def _create_basis(self): """Create the canonical basis.""" n = self.n basis = homogeneous_representation( self.skew.basis, gs.zeros((self.skew.dim, n)), (self.skew.dim, n + 1, n + 1), 0.0, ) basis = list(basis) for row in gs.arange(n): basis.append( gs.array_from_sparse([(row, n)], [1.0], (n + 1, n + 1))) return gs.stack(basis) def belongs(self, mat, atol=ATOL): """Evaluate if the rotation part of mat is a skew-symmetric matrix. Parameters ---------- mat : array-like, shape=[..., n + 1, n + 1] Square matrix to check. atol : float Tolerance for the equality evaluation. Optional, default: backend atol. Returns ------- belongs : array-like, shape=[...,] Boolean evaluating if rotation part of matrix is skew symmetric. """ point_dim1, point_dim2 = mat.shape[-2:] belongs = point_dim1 == point_dim2 == self.n + 1 rotation = mat[..., :self.n, :self.n] rot_belongs = self.skew.belongs(rotation, atol=atol) belongs = gs.logical_and(belongs, rot_belongs) last_line = mat[..., -1, :] all_zeros = ~gs.any(last_line, axis=-1) belongs = gs.logical_and(belongs, all_zeros) return belongs def random_point(self, n_samples=1, bound=1.0): """Sample in the lie algebra with a uniform distribution in a box. Parameters ---------- n_samples : int Number of samples. Optional, default: 1. bound : float Side of hypercube support of the uniform distribution. Optional, default: 1.0 Returns ------- point : array-like, shape=[..., n + 1, n + 1] Sample. """ point = super(SpecialEuclideanMatrixLieAlgebra, self).random_point(n_samples, bound) return self.projection(point) def projection(self, mat): """Project a matrix to the Lie Algebra. Compute the skew-symmetric projection of the rotation part of matrix. Parameters ---------- mat : array-like, shape=[..., n + 1, n + 1] Matrix. Returns ------- projected : array-like, shape=[..., n + 1, n + 1] Matrix belonging to Lie Algebra. """ rotation = mat[..., :self.n, :self.n] skew = SkewSymmetricMatrices.projection(rotation) return homogeneous_representation(skew, mat[..., :self.n, self.n], mat.shape, 0.0) def basis_representation(self, matrix_representation): """Calculate the coefficients of given matrix in the basis. Compute a 1d-array that corresponds to the input matrix in the basis representation. Parameters ---------- matrix_representation : array-like, shape=[..., n + 1, n + 1] Matrix. Returns ------- basis_representation : array-like, shape=[..., dim] Representation in the basis. """ skew_part = self.skew.basis_representation( matrix_representation[..., :self.n, :self.n]) translation_part = matrix_representation[..., :-1, self.n] return gs.concatenate([skew_part, translation_part[..., :]], axis=-1)
def __init__(self, n): dim = int(n * (n + 1) / 2) super(SpecialEuclideanMatrixLieAlgebra, self).__init__(dim, n + 1) self.skew = SkewSymmetricMatrices(n) self.n = n
class TestLieAlgebra(geomstats.tests.TestCase): def setup_method(self): self.n = 4 self.dim = int(self.n * (self.n - 1) / 2) self.algebra = SkewSymmetricMatrices(n=self.n) def test_dimension(self): result = self.algebra.dim expected = self.dim self.assertAllClose(result, expected) def test_matrix_representation_and_belongs(self): n_samples = 2 point = gs.random.rand(n_samples * self.dim) point = gs.reshape(point, (n_samples, self.dim)) mat = self.algebra.matrix_representation(point) result = gs.all(self.algebra.belongs(mat)) self.assertTrue(result) def test_basis_and_matrix_representation(self): n_samples = 2 expected = gs.random.rand(n_samples * self.dim) expected = gs.reshape(expected, (n_samples, self.dim)) mat = self.algebra.matrix_representation(expected) result = self.algebra.basis_representation(mat) self.assertAllClose(result, expected) def test_orthonormal_basis(self): group = SpecialOrthogonal(3) lie_algebra = SkewSymmetricMatrices(3) metric = InvariantMetric(group=group) basis = metric.normal_basis(lie_algebra.basis) result = metric.inner_product_at_identity(basis[0], basis[1]) self.assertAllClose(result, 0.0) result = metric.inner_product_at_identity(basis[1], basis[1]) self.assertAllClose(result, 1.0) metric_mat = from_vector_to_diagonal_matrix(gs.array([1.0, 2.0, 3.0])) metric = InvariantMetric(group=group, metric_mat_at_identity=metric_mat) basis = metric.normal_basis(lie_algebra.basis) result = metric.inner_product_at_identity(basis[0], basis[1]) self.assertAllClose(result, 0.0) result = metric.inner_product_at_identity(basis[1], basis[1]) self.assertAllClose(result, 1.0) def test_orthonormal_basis_se3(self): group = SpecialEuclidean(3) lie_algebra = group.lie_algebra metric = InvariantMetric(group=group) basis = metric.normal_basis(lie_algebra.basis) for i, x in enumerate(basis): for y in basis[i:]: result = metric.inner_product_at_identity(x, y) expected = 0.0 if gs.any(x != y) else 1.0 self.assertAllClose(result, expected) metric_mat = from_vector_to_diagonal_matrix( gs.cast(gs.arange(1, group.dim + 1), gs.float32) ) metric = InvariantMetric(group=group, metric_mat_at_identity=metric_mat) basis = metric.normal_basis(lie_algebra.basis) for i, x in enumerate(basis): for y in basis[i:]: result = metric.inner_product_at_identity(x, y) expected = 0.0 if gs.any(x != y) else 1.0 self.assertAllClose(result, expected)
def setUp(self): self.n_seq = [3, 4, 5, 6, 7, 8, 9, 10] self.skew = {n: SkewSymmetricMatrices(n=n) for n in self.n_seq}
""" import timeit import matplotlib.pyplot as plt import geomstats.backend as gs from geomstats.geometry.skew_symmetric_matrices import SkewSymmetricMatrices from geomstats.geometry.special_orthogonal import SpecialOrthogonal N = 3 MAX_ORDER = 10 GROUP = SpecialOrthogonal(n=N) DIM = int(N * (N - 1) / 2) ALGEBRA = SkewSymmetricMatrices(n=N) def main(): """Visualize convergence of the BCH formula approximation on so(n).""" norm_rv_1 = gs.random.normal(size=DIM) tan_rv_1 = ALGEBRA.matrix_representation( norm_rv_1 / gs.linalg.norm(norm_rv_1, axis=0) / 2) exp_1 = gs.linalg.expm(tan_rv_1) norm_rv_2 = gs.random.normal(size=DIM) tan_rv_2 = ALGEBRA.matrix_representation( norm_rv_2 / gs.linalg.norm(norm_rv_2, axis=0) / 2) exp_2 = gs.linalg.expm(tan_rv_2) composition = GROUP.compose(exp_1, exp_2)
def matrix_representation_and_belongs_test_data(self): smoke_data = [ dict(algebra=SkewSymmetricMatrices(4), point=gs.random.rand(2, 6)) ] return self.generate_tests(smoke_data)
def dimension_test_data(self): smoke_data = [dict(algebra=SkewSymmetricMatrices(4), expected=6)] return self.generate_tests(smoke_data)