def test_intrinsic_and_extrinsic_coords_vectorization(self):
"""
Test that the composition of
intrinsic_to_extrinsic_coords and
extrinsic_to_intrinsic_coords
gives the identity.
"""
point_int = gs.array([
[0.1, 0.0, 0.0, 0.1, 0.0, 0.0],
[0.1, 0.1, 0.1, 0.4, 0.1, 0.0],
[0.1, 0.3, 0.0, 0.1, 0.0, 0.0],
[-0.1, 0.1, -0.4, 0.1, -0.01, 0.0],
[0.0, 0.0, 0.1, 0.1, -0.08, -0.1],
[0.1, 0.1, 0.1, 0.1, 0.0, -0.5],
])
point_ext = self.space.from_coordinates(point_int, "intrinsic")
result = self.space.to_coordinates(point_ext, "intrinsic")
expected = point_int
expected = helper.to_vector(expected)
self.assertAllClose(result, expected)
point_ext = gs.array([
[2.0, 1.0, 1.0, 1.0],
[4.0, 1.0, 3.0, math.sqrt(5.0)],
[3.0, 2.0, 0.0, 2.0],
])
point_int = self.space.to_coordinates(point_ext, "intrinsic")
result = self.space.from_coordinates(point_int, "intrinsic")
expected = point_ext
expected = helper.to_vector(expected)
self.assertAllClose(result, expected)
def test_intrinsic_and_extrinsic_coords(self):
"""
Test that the composition of
intrinsic_to_extrinsic_coords and
extrinsic_to_intrinsic_coords
gives the identity.
"""
point_int = tf.convert_to_tensor([.1, 0., 0., .1])
point_ext = self.space.intrinsic_to_extrinsic_coords(point_int)
result = self.space.extrinsic_to_intrinsic_coords(point_ext)
expected = point_int
expected = helper.to_vector(expected)
with self.test_session():
self.assertAllClose(gs.eval(result), gs.eval(expected))
# TODO(nina): Fix that the test fails if point_ext generated
# with tf.random_uniform
point_ext = (1. / (gs.sqrt(6.)) *
tf.convert_to_tensor([1., 0., 0., 1., 2.]))
point_int = self.space.extrinsic_to_intrinsic_coords(point_ext)
result = self.space.intrinsic_to_extrinsic_coords(point_int)
expected = point_ext
expected = helper.to_vector(expected)
with self.test_session():
self.assertAllClose(gs.eval(result), gs.eval(expected))
def test_intrinsic_and_extrinsic_coords_vectorization(self):
"""
Test that the composition of
intrinsic_to_extrinsic_coords and
extrinsic_to_intrinsic_coords
gives the identity.
"""
point_int = tf.convert_to_tensor([[.1, 0., 0., .1], [.1, .1, .1, .4],
[.1, .3, 0.,
.1], [-0.1, .1, -.4, .1],
[0., 0., .1, .1], [.1, .1, .1, .1]])
point_ext = self.space.intrinsic_to_extrinsic_coords(point_int)
result = self.space.extrinsic_to_intrinsic_coords(point_ext)
expected = point_int
expected = helper.to_vector(expected)
with self.test_session():
self.assertAllClose(gs.eval(result), gs.eval(expected))
sqrt_3 = np.sqrt(3.)
point_ext = tf.convert_to_tensor(
[[1. / sqrt_3, 0., 0., 1. / sqrt_3, 1. / sqrt_3],
[1. / sqrt_3, 1. / sqrt_3, 1. / sqrt_3, 0., 0.],
[0., 0., 1. / sqrt_3, 1. / sqrt_3, 1. / sqrt_3]],
dtype=np.float64)
point_int = self.space.extrinsic_to_intrinsic_coords(point_ext)
result = self.space.intrinsic_to_extrinsic_coords(point_int)
expected = point_ext
expected = helper.to_vector(expected)
with self.test_session():
self.assertAllClose(gs.eval(result), gs.eval(expected))
def test_intrinsic_and_extrinsic_coords_vectorization(self):
"""
Test that the composition of
intrinsic_to_extrinsic_coords and
extrinsic_to_intrinsic_coords
gives the identity.
"""
point_int = gs.array([[.1, 0., 0., .1, 0.,
0.], [.1, .1, .1, .4, .1, 0.],
[.1, .3, 0., .1, 0., 0.],
[-0.1, .1, -.4, .1, -.01, 0.],
[0., 0., .1, .1, -0.08, -0.1],
[.1, .1, .1, .1, 0., -0.5]])
point_ext = self.space.intrinsic_to_extrinsic_coords(point_int)
result = self.space.extrinsic_to_intrinsic_coords(point_ext)
expected = point_int
expected = helper.to_vector(expected)
self.assertAllClose(result, expected)
point_ext = gs.array([[2., 1., 1., 1.], [4., 1., 3.,
math.sqrt(5.)],
[3., 2., 0., 2.]])
point_int = self.space.extrinsic_to_intrinsic_coords(point_ext)
result = self.space.intrinsic_to_extrinsic_coords(point_int)
expected = point_ext
expected = helper.to_vector(expected)
self.assertAllClose(result, expected)
def test_intrinsic_and_extrinsic_coords_vectorization(self):
"""
Test that the composition of
intrinsic_to_extrinsic_coords and
extrinsic_to_intrinsic_coords
gives the identity.
"""
point_int = gs.array([[.1, 0., 0., .1], [.1, .1, .1, .4],
[.1, .3, 0., .1], [-0.1, .1, -.4, .1],
[0., 0., .1, .1], [.1, .1, .1, .1]])
point_ext = self.space.intrinsic_to_extrinsic_coords(point_int)
result = self.space.extrinsic_to_intrinsic_coords(point_ext)
expected = point_int
expected = helper.to_vector(expected)
gs.testing.assert_allclose(result, expected)
n_samples = self.n_samples
point_ext = self.space.random_uniform(n_samples=n_samples)
point_int = self.space.extrinsic_to_intrinsic_coords(point_ext)
result = self.space.intrinsic_to_extrinsic_coords(point_int)
expected = point_ext
expected = helper.to_vector(expected)
gs.testing.assert_allclose(result, expected)
def test_intrinsic_and_extrinsic_coords_vectorization(self):
"""
Test that the composition of
intrinsic_to_extrinsic_coords and
extrinsic_to_intrinsic_coords
gives the identity.
"""
point_int = gs.array([[.1, 0., 0., .1, 0.,
0.], [.1, .1, .1, .4, .1, 0.],
[.1, .3, 0., .1, 0., 0.],
[-0.1, .1, -.4, .1, -.01, 0.],
[0., 0., .1, .1, -0.08, -0.1],
[.1, .1, .1, .1, 0., -0.5]])
point_ext = self.space.intrinsic_to_extrinsic_coords(point_int)
result = self.space.extrinsic_to_intrinsic_coords(point_ext)
expected = point_int
expected = helper.to_vector(expected)
with self.test_session():
self.assertAllClose(gs.eval(result), gs.eval(expected))
point_ext = tf.convert_to_tensor([[2.0, 1.0, 1.0, 1.0],
[4.0, 1., 3.0,
math.sqrt(5)], [3.0, 2.0, 0.0,
2.0]])
point_int = self.space.extrinsic_to_intrinsic_coords(point_ext)
result = self.space.intrinsic_to_extrinsic_coords(point_int)
# TODO(nina): Make sure this holds for (x, y, z, ..) AND (-x, y,z)
expected = point_ext
expected = helper.to_vector(expected)
with self.test_session():
self.assertAllClose(gs.eval(result), gs.eval(expected))
def test_exp_vectorization(self):
n_samples = 3
dim = self.dimension + 1
one_vec = gs.array([2.0, 1.0, 1.0, 1.0])
one_base_point = gs.array([4.0, 3., 1.0, math.sqrt(5)])
n_vecs = gs.array([[2., 1., 1., 1.], [4., 1., 3.,
math.sqrt(5.)], [3., 2., 0.,
2.]])
n_base_points = gs.array(
[[2.0, 0.0, 1.0, math.sqrt(2)],
[5.0, math.sqrt(8), math.sqrt(8),
math.sqrt(8)], [1.0, 0.0, 0.0, 0.0]])
one_tangent_vec = self.space.projection_to_tangent_space(
one_vec, base_point=one_base_point)
result = self.metric.exp(one_tangent_vec, one_base_point)
self.assertAllClose(gs.shape(result), (1, dim))
n_tangent_vecs = self.space.projection_to_tangent_space(
n_vecs, base_point=one_base_point)
result = self.metric.exp(n_tangent_vecs, one_base_point)
self.assertAllClose(gs.shape(result), (n_samples, dim))
expected = np.zeros((n_samples, dim))
with self.session():
for i in range(n_samples):
expected[i] = gs.eval(
self.metric.exp(n_tangent_vecs[i], one_base_point))
expected = helper.to_vector(gs.array(expected))
self.assertAllClose(result, expected)
one_tangent_vec = self.space.projection_to_tangent_space(
one_vec, base_point=n_base_points)
result = self.metric.exp(one_tangent_vec, n_base_points)
self.assertAllClose(gs.shape(result), (n_samples, dim))
expected = np.zeros((n_samples, dim))
with self.session():
for i in range(n_samples):
expected[i] = gs.eval(
self.metric.exp(one_tangent_vec[i], n_base_points[i]))
expected = helper.to_vector(gs.array(expected))
self.assertAllClose(result, expected)
n_tangent_vecs = self.space.projection_to_tangent_space(
n_vecs, base_point=n_base_points)
result = self.metric.exp(n_tangent_vecs, n_base_points)
self.assertAllClose(gs.shape(result), (n_samples, dim))
expected = np.zeros((n_samples, dim))
with self.session():
for i in range(n_samples):
expected[i] = gs.eval(
self.metric.exp(n_tangent_vecs[i], n_base_points[i]))
expected = helper.to_vector(gs.array(expected))
self.assertAllClose(result, expected)
def test_exp_vectorization(self):
n_samples = 3
dim = self.dimension + 1
one_vec = gs.array([2.0, 1.0, 1.0, 1.0])
one_base_point = gs.array([4.0, 3.0, 1.0, math.sqrt(5)])
n_vecs = gs.array(
[
[2.0, 1.0, 1.0, 1.0],
[4.0, 1.0, 3.0, math.sqrt(5.0)],
[3.0, 2.0, 0.0, 2.0],
]
)
n_base_points = gs.array(
[
[2.0, 0.0, 1.0, math.sqrt(2)],
[5.0, math.sqrt(8), math.sqrt(8), math.sqrt(8)],
[1.0, 0.0, 0.0, 0.0],
]
)
one_tangent_vec = self.space.to_tangent(one_vec, base_point=one_base_point)
result = self.metric.exp(one_tangent_vec, one_base_point)
self.assertAllClose(gs.shape(result), (dim,))
n_tangent_vecs = self.space.to_tangent(n_vecs, base_point=one_base_point)
result = self.metric.exp(n_tangent_vecs, one_base_point)
self.assertAllClose(gs.shape(result), (n_samples, dim))
expected = []
for i in range(n_samples):
expected.append(self.metric.exp(n_tangent_vecs[i], one_base_point))
expected = gs.stack(expected, axis=0)
expected = helper.to_vector(gs.array(expected))
self.assertAllClose(result, expected, atol=1e-2)
one_tangent_vec = self.space.to_tangent(one_vec, base_point=n_base_points)
result = self.metric.exp(one_tangent_vec, n_base_points)
self.assertAllClose(gs.shape(result), (n_samples, dim))
expected = []
for i in range(n_samples):
expected.append(self.metric.exp(one_tangent_vec[i], n_base_points[i]))
expected = gs.stack(expected, axis=0)
expected = helper.to_vector(gs.array(expected))
self.assertAllClose(result, expected)
n_tangent_vecs = self.space.to_tangent(n_vecs, base_point=n_base_points)
result = self.metric.exp(n_tangent_vecs, n_base_points)
self.assertAllClose(gs.shape(result), (n_samples, dim))
expected = []
for i in range(n_samples):
expected.append(self.metric.exp(n_tangent_vecs[i], n_base_points[i]))
expected = gs.stack(expected, axis=0)
expected = helper.to_vector(gs.array(expected))
self.assertAllClose(result, expected)
def test_mean(self):
point = gs.array([1, 4])
result = self.metric.mean(points=[point, point, point])
expected = point
expected = helper.to_vector(expected)
gs.testing.assert_allclose(result, expected)
points = gs.array([[1, 2], [2, 3], [3, 4], [4, 5]])
weights = gs.array([1, 2, 1, 2])
result = self.metric.mean(points, weights)
expected = gs.array([16., 22.]) / 6.
expected = helper.to_vector(expected)
gs.testing.assert_allclose(result, expected)
def test_log_vectorization(self):
dim = self.dimension
n_samples = 3
one_point = gs.array([[-1., 0.]])
one_base_point = gs.array([[1.0, 0.]])
n_points = gs.array([
[-1., 0.],
[1., 0.],
[2., math.sqrt(3)]])
n_base_points = gs.array([
[2., -math.sqrt(3)],
[4.0, math.sqrt(15)],
[-4.0, math.sqrt(15)]])
result = self.metric.log(one_point, one_base_point)
expected = one_point - one_base_point
expected = helper.to_vector(expected)
self.assertAllClose(result, expected)
result = self.metric.log(n_points, one_base_point)
self.assertAllClose(gs.shape(result), (n_samples, dim))
result = self.metric.log(one_point, n_base_points)
self.assertAllClose(gs.shape(result), (n_samples, dim))
result = self.metric.log(n_points, n_base_points)
self.assertAllClose(gs.shape(result), (n_samples, dim))
def test_mean(self):
point = gs.array([[1., 4.]])
result = self.metric.mean(points=[point, point, point])
expected = point
expected = helper.to_vector(expected)
self.assertAllClose(result, expected)
points = gs.array([[1., 2.], [2., 3.], [3., 4.], [4., 5.]])
weights = gs.array([1., 2., 1., 2.])
result = self.metric.mean(points, weights)
expected = gs.array([16. / 6., 22. / 6.])
expected = helper.to_vector(expected)
self.assertAllClose(result, expected)
def test_exp_and_log_and_projection_to_tangent_space_general_case(self):
"""
Test that the riemannian exponential
and the riemannian logarithm are inverse.
Expect their composition to give the identity function.
NB: points on the n-dimensional sphere are
(n+1)-D vectors of norm 1.
"""
# TODO(nina): Fix that this test fails, also in numpy
# Riemannian Exp then Riemannian Log
# General case
# NB: Riemannian log gives a regularized tangent vector,
# so we take the norm modulo 2 * pi.
base_point = gs.array([0., -3., 0., 3., 4.])
base_point = base_point / gs.linalg.norm(base_point)
vector = gs.array([9., 5., 0., 0., -1.])
vector = self.space.projection_to_tangent_space(vector=vector,
base_point=base_point)
# exp = self.metric.exp(tangent_vec=vector, base_point=base_point)
# result = self.metric.log(point=exp, base_point=base_point)
expected = vector
norm_expected = gs.linalg.norm(expected)
regularized_norm_expected = gs.mod(norm_expected, 2 * gs.pi)
expected = expected / norm_expected * regularized_norm_expected
expected = helper.to_vector(expected)
def test_mean(self):
point = gs.array([2., 1., 1., 1.])
points = gs.array([point, point])
result = self.metric.mean(points)
expected = helper.to_vector(point)
self.assertAllClose(result, expected)
def test_log_and_exp_edge_case(self):
"""
Test that the riemannian exponential
and the riemannian logarithm are inverse.
Expect their composition to give the identity function.
NB: points on the n-dimensional sphere are
(n+1)-D vectors of norm 1.
"""
# Riemannian Log then Riemannian Exp
# Edge case: two very close points, base_point_2 and point_2,
# form an angle < epsilon
base_point = gs.array([1., 2., 3., 4., 6.])
base_point = base_point / gs.linalg.norm(base_point)
point = (base_point
+ 1e-12 * gs.array([-1., -2., 1., 1., .1]))
point = point / gs.linalg.norm(point)
log = self.metric.log(point=point, base_point=base_point)
result = self.metric.exp(tangent_vec=log, base_point=base_point)
expected = point
expected = helper.to_vector(expected)
self.assertAllClose(result, expected)
def test_log_vectorization(self):
dim = self.dimension
n_samples = 3
one_point = tf.convert_to_tensor([[-1., 0.]])
one_base_point = tf.convert_to_tensor([[1.0, 0.]])
n_points = tf.convert_to_tensor([[-1., 0.], [1., 0.],
[2., math.sqrt(3)]])
n_base_points = tf.convert_to_tensor([[2., -math.sqrt(3)],
[4.0, math.sqrt(15)],
[-4.0, math.sqrt(15)]])
result = self.metric.log(one_point, one_base_point)
expected = one_point - one_base_point
expected = helper.to_vector(expected)
with self.test_session():
self.assertAllClose(gs.eval(result), gs.eval(expected))
result = self.metric.log(n_points, one_base_point)
self.assertAllClose(gs.eval(result).shape, (n_samples, dim))
result = self.metric.log(one_point, n_base_points)
self.assertAllClose(gs.eval(result).shape, (n_samples, dim))
result = self.metric.log(n_points, n_base_points)
self.assertAllClose(gs.eval(result).shape, (n_samples, dim))
def test_log_vectorization(self):
n_samples = self.n_samples
dim = self.dimension
one_point = gs.array([0., 1.])
one_base_point = gs.array([2., 10.])
n_points = gs.array([
[2., 1.],
[-2., -4.],
[-5., 1.]])
n_base_points = gs.array([
[2., 10.],
[8., -1.],
[-3., 6.]])
result = self.metric.log(one_point, one_base_point)
expected = one_point - one_base_point
expected = helper.to_vector(expected)
self.assertAllClose(result, expected)
result = self.metric.log(n_points, one_base_point)
self.assertAllClose(gs.shape(result), (n_samples, dim))
result = self.metric.log(one_point, n_base_points)
self.assertAllClose(gs.shape(result), (n_samples, dim))
result = self.metric.log(n_points, n_base_points)
self.assertAllClose(gs.shape(result), (n_samples, dim))
def test_exp_and_log_and_projection_to_tangent_space_edge_case(self):
"""
Test that the riemannian exponential
and the riemannian logarithm are inverse.
Expect their composition to give the identity function.
NB: points on the n-dimensional sphere are
(n+1)-D vectors of norm 1.
"""
# Riemannian Exp then Riemannian Log
# Edge case: tangent vector has norm < epsilon
base_point = gs.array([10., -2., -.5, 34., 3.])
base_point = base_point / gs.linalg.norm(base_point)
vector = 1e-10 * gs.array([.06, -51., 6., 5., 3.])
vector = self.space.projection_to_tangent_space(vector=vector,
base_point=base_point)
exp = self.metric.exp(tangent_vec=vector, base_point=base_point)
result = self.metric.log(point=exp, base_point=base_point)
expected = self.space.projection_to_tangent_space(
vector=vector, base_point=base_point)
expected = helper.to_vector(expected)
self.assertAllClose(result, expected, atol=1e-8)
def test_exp_vectorization(self):
n_samples = self.n_samples
dim = self.dimension + 1
one_vec = self.space.random_uniform()
one_base_point = self.space.random_uniform()
n_vecs = self.space.random_uniform(n_samples=n_samples)
n_base_points = self.space.random_uniform(n_samples=n_samples)
one_tangent_vec = self.space.projection_to_tangent_space(
one_vec, base_point=one_base_point)
result = self.metric.exp(one_tangent_vec, one_base_point)
gs.testing.assert_allclose(result.shape, (1, dim))
n_tangent_vecs = self.space.projection_to_tangent_space(
n_vecs, base_point=one_base_point)
result = self.metric.exp(n_tangent_vecs, one_base_point)
gs.testing.assert_allclose(result.shape, (n_samples, dim))
expected = gs.zeros((n_samples, dim))
for i in range(n_samples):
expected[i] = self.metric.exp(n_tangent_vecs[i], one_base_point)
expected = helper.to_vector(expected)
gs.testing.assert_allclose(result, expected)
one_tangent_vec = self.space.projection_to_tangent_space(
one_vec, base_point=n_base_points)
result = self.metric.exp(one_tangent_vec, n_base_points)
gs.testing.assert_allclose(result.shape, (n_samples, dim))
expected = gs.zeros((n_samples, dim))
for i in range(n_samples):
expected[i] = self.metric.exp(one_tangent_vec[i], n_base_points[i])
expected = helper.to_vector(expected)
gs.testing.assert_allclose(result, expected)
n_tangent_vecs = self.space.projection_to_tangent_space(
n_vecs, base_point=n_base_points)
result = self.metric.exp(n_tangent_vecs, n_base_points)
gs.testing.assert_allclose(result.shape, (n_samples, dim))
expected = gs.zeros((n_samples, dim))
for i in range(n_samples):
expected[i] = self.metric.exp(n_tangent_vecs[i], n_base_points[i])
expected = helper.to_vector(expected)
gs.testing.assert_allclose(result, expected)
def test_log(self):
base_point = gs.array([-1., 0.])
point = gs.array([2., math.sqrt(3)])
result = self.metric.log(point=point, base_point=base_point)
expected = point - base_point
expected = helper.to_vector(expected)
self.assertAllClose(result, expected)
def test_log(self):
base_point = gs.array([0, 1])
point = gs.array([2, 10])
result = self.metric.log(point=point, base_point=base_point)
expected = point - base_point
expected = helper.to_vector(expected)
gs.testing.assert_allclose(result, expected)
def test_exp(self):
base_point = gs.array([1.0, 0.])
vector = gs.array([2., math.sqrt(3)])
result = self.metric.exp(tangent_vec=vector, base_point=base_point)
expected = base_point + vector
expected = helper.to_vector(expected)
self.assertAllClose(result, expected)
def test_exp(self):
base_point = gs.array([0, 1])
vector = gs.array([2, 10])
result = self.metric.exp(tangent_vec=vector, base_point=base_point)
expected = base_point + vector
expected = helper.to_vector(expected)
gs.testing.assert_allclose(result, expected)
def test_log(self):
base_point = tf.convert_to_tensor([-1., 0.])
point = tf.convert_to_tensor([2., math.sqrt(3)])
result = self.metric.log(point=point, base_point=base_point)
expected = point - base_point
expected = helper.to_vector(expected)
with self.test_session():
self.assertAllClose(gs.eval(result), gs.eval(expected))
def test_exp(self):
base_point = tf.convert_to_tensor([1.0, 0.])
vector = tf.convert_to_tensor([2., math.sqrt(3)])
result = self.metric.exp(tangent_vec=vector, base_point=base_point)
expected = base_point + vector
expected = helper.to_vector(expected)
with self.test_session():
self.assertAllClose(gs.eval(result), gs.eval(expected))
def test_mean(self):
point = gs.array([0., 0., 0., 0., 1.])
points = gs.zeros((2, point.shape[0]))
points[0, :] = point
points[1, :] = point
result = self.metric.mean(points)
expected = helper.to_vector(point)
self.assertAllClose(expected, result)
def test_mean(self):
# TODO(nina): Fix the fact that it doesn't work for [1., 4.]
point = tf.convert_to_tensor([[1., 4.]])
result = self.metric.mean(points=[point, point, point])
expected = point
expected = helper.to_vector(expected)
with self.test_session():
self.assertAllClose(gs.eval(result), gs.eval(expected))
points = tf.convert_to_tensor([[1., 2.], [2., 3.], [3., 4.], [4., 5.]])
weights = gs.array([1., 2., 1., 2.])
result = self.metric.mean(points, weights)
expected = tf.convert_to_tensor([16. / 6., 22. / 6.])
expected = helper.to_vector(expected)
with self.test_session():
self.assertAllClose(gs.eval(result), gs.eval(expected))
def test_estimate_hyperbolic(self):
point = gs.array([2., 1., 1., 1.])
points = gs.array([point, point])
mean = FrechetMean(metric=self.hyperbolic.metric)
mean.fit(X=points)
result = mean.estimate_
expected = helper.to_vector(point)
self.assertAllClose(result, expected)
def test_intrinsic_and_extrinsic_coords(self):
"""
Test that the composition of
intrinsic_to_extrinsic_coords and
extrinsic_to_intrinsic_coords
gives the identity.
"""
point_int = gs.ones(self.dimension)
point_ext = self.space.intrinsic_to_extrinsic_coords(point_int)
result = self.space.extrinsic_to_intrinsic_coords(point_ext)
expected = point_int
expected = helper.to_vector(expected)
self.assertAllClose(result, expected)
point_ext = gs.array([2.0, 1.0, 1.0, 1.0])
point_int = self.space.extrinsic_to_intrinsic_coords(point_ext)
result = self.space.intrinsic_to_extrinsic_coords(point_int)
expected = point_ext
expected = helper.to_vector(expected)
self.assertAllClose(result, expected)
def test_intrinsic_and_extrinsic_coords(self):
"""
Test that the composition of
intrinsic_to_extrinsic_coords and
extrinsic_to_intrinsic_coords
gives the identity.
"""
point_int = gs.array([.1, 0., 0., .1])
point_ext = self.space.intrinsic_to_extrinsic_coords(point_int)
result = self.space.extrinsic_to_intrinsic_coords(point_ext)
expected = point_int
expected = helper.to_vector(expected)
self.assertAllClose(result, expected)
point_ext = (1. / (gs.sqrt(6.)) * gs.array([1., 0., 0., 1., 2.]))
point_int = self.space.extrinsic_to_intrinsic_coords(point_ext)
result = self.space.intrinsic_to_extrinsic_coords(point_int)
expected = point_ext
expected = helper.to_vector(expected)
self.assertAllClose(result, expected)
def test_estimate_sphere(self):
point = gs.array([0., 0., 0., 0., 1.])
points = gs.zeros((2, point.shape[0]))
points[0, :] = point
points[1, :] = point
mean = FrechetMean(metric=self.sphere.metric)
mean.fit(X=points)
result = mean.estimate_
expected = helper.to_vector(point)
self.assertAllClose(expected, result)
