class TestL2CurvesMetric(RiemannianMetricTestCase, metaclass=Parametrizer):
metric = connection = L2CurvesMetric
skip_test_exp_belongs = True
skip_test_exp_shape = True
skip_test_log_shape = True
skip_test_exp_geodesic_ivp = True
skip_test_parallel_transport_ivp_is_isometry = True
skip_test_parallel_transport_bvp_is_isometry = True
skip_test_dist_is_norm_of_log = tf_backend()
skip_test_dist_is_symmetric = tf_backend()
skip_test_squared_dist_is_symmetric = tf_backend()
skip_test_inner_product_is_symmetric = tf_backend()
testing_data = L2CurvesMetricTestData()
def test_l2_metric_geodesic(
self, ambient_manifold, curve_a, curve_b, times, n_sampling_points
):
"""Test the geodesic method of L2LandmarksMetric."""
l2_metric_s2 = L2CurvesMetric(ambient_manifold=s2)
curves_ab = l2_metric_s2.geodesic(curve_a, curve_b)
curves_ab = curves_ab(times)
result = curves_ab
expected = []
for k in range(n_sampling_points):
geod = l2_metric_s2.ambient_metric.geodesic(
initial_point=curve_a[k, :], end_point=curve_b[k, :]
)
expected.append(geod(times))
expected = gs.stack(expected, axis=1)
self.assertAllClose(result, expected)
class TestHermitianMetric(RiemannianMetricTestCase, metaclass=Parametrizer):
metric = connection = HermitianMetric
skip_test_exp = tf_backend()
skip_test_log = tf_backend()
skip_test_inner_product = tf_backend()
skip_test_dist = geomstats.tests.tf_backend()
skip_test_parallel_transport_ivp_is_isometry = True
skip_test_parallel_transport_bvp_is_isometry = True
skip_test_exp_geodesic_ivp = True
testing_data = HermitianMetricTestData()
def test_exp(self, dim, tangent_vec, base_point, expected):
metric = HermitianMetric(dim)
self.assertAllClose(
metric.exp(gs.array(tangent_vec), gs.array(base_point)), gs.array(expected)
)
def test_log(self, dim, point, base_point, expected):
metric = HermitianMetric(dim)
self.assertAllClose(
metric.log(gs.array(point), gs.array(base_point)), gs.array(expected)
)
def test_inner_product(self, dim, tangent_vec_a, tangent_vec_b, expected):
metric = HermitianMetric(dim)
self.assertAllClose(
metric.inner_product(gs.array(tangent_vec_a), gs.array(tangent_vec_b)),
gs.array(expected),
)
def test_squared_norm(self, dim, vec, expected):
metric = HermitianMetric(dim)
self.assertAllClose(metric.squared_norm(gs.array(vec)), gs.array(expected))
def test_norm(self, dim, vec, expected):
metric = HermitianMetric(dim)
self.assertAllClose(metric.norm(gs.array(vec)), gs.array(expected))
def test_metric_matrix(self, dim, expected):
self.assertAllClose(HermitianMetric(dim).metric_matrix(), gs.array(expected))
def test_squared_dist(self, dim, point_a, point_b, expected):
metric = HermitianMetric(dim)
result = metric.squared_dist(point_a, point_b)
self.assertAllClose(result, gs.array(expected))
def test_dist(self, dim, point_a, point_b, expected):
metric = HermitianMetric(dim)
result = metric.dist(point_a, point_b)
self.assertAllClose(result, gs.array(expected))
class TestHermitian(VectorSpaceTestCase, metaclass=Parametrizer):
space = Hermitian
skip_test_basis_belongs = True
skip_test_basis_cardinality = True
skip_test_belongs = tf_backend()
testing_data = HermitianTestData()
def test_belongs(self, dim, vec, expected):
self.assertAllClose(self.space(dim).belongs(gs.array(vec)), gs.array(expected))
class TestClosedDiscreteCurves(ManifoldTestCase, metaclass=Parametrizer):
space = ClosedDiscreteCurves
skip_test_projection_belongs = tf_backend()
skip_test_random_tangent_vec_is_tangent = True
skip_test_to_tangent_is_tangent = True
testing_data = ClosedDiscreteCurvesTestData()
@geomstats.tests.np_and_autograd_only
def test_projection_closed_curves(self, ambient_manifold, curve):
planar_closed_curve = ClosedDiscreteCurves(ambient_manifold)
proj = planar_closed_curve.projection(curve)
expected = proj
result = planar_closed_curve.projection(proj)
self.assertAllClose(result, expected)
result = proj[-1, :]
expected = proj[0, :]
self.assertAllClose(result, expected, rtol=10 * gs.rtol)
class TestSRVMetric(RiemannianMetricTestCase, metaclass=Parametrizer):
metric = connection = SRVMetric
skip_test_exp_shape = True
skip_test_log_shape = True
skip_test_exp_geodesic_ivp = True
skip_test_parallel_transport_ivp_is_isometry = True
skip_test_parallel_transport_bvp_is_isometry = True
skip_test_geodesic_bvp_belongs = True
skip_test_geodesic_ivp_belongs = True
skip_test_exp_after_log = tf_backend()
skip_test_exp_belongs = tf_backend()
skip_test_exp_ladder_parallel_transport = tf_backend()
skip_test_inner_product_is_symmetric = tf_backend()
skip_test_log_after_exp = tf_backend()
skip_test_log_is_tangent = tf_backend()
testing_data = SRVMetricTestData()
def test_srv_inner_product(self, curve_a, curve_b, curve_c, times):
l2_metric_s2 = L2CurvesMetric(ambient_manifold=s2)
srv_metric_r3 = SRVMetric(ambient_manifold=r3)
curves_ab = l2_metric_s2.geodesic(curve_a, curve_b)
curves_bc = l2_metric_s2.geodesic(curve_b, curve_c)
curves_ab = curves_ab(times)
curves_bc = curves_bc(times)
srvs_ab = srv_metric_r3.srv_transform(curves_ab)
srvs_bc = srv_metric_r3.srv_transform(curves_bc)
result = srv_metric_r3.l2_curves_metric.inner_product(srvs_ab, srvs_bc)
products = srvs_ab * srvs_bc
expected = [gs.sum(product) for product in products]
expected = gs.array(expected) / (srvs_ab.shape[-2] + 1)
self.assertAllClose(result, expected)
result = result.shape
expected = [srvs_ab.shape[0]]
self.assertAllClose(result, expected)
def test_srv_norm(self, curve_a, curve_b, times):
l2_metric_s2 = L2CurvesMetric(ambient_manifold=s2)
srv_metric_r3 = SRVMetric(ambient_manifold=r3)
curves_ab = l2_metric_s2.geodesic(curve_a, curve_b)
curves_ab = curves_ab(times)
srvs_ab = srv_metric_r3.srv_transform(curves_ab)
result = srv_metric_r3.l2_curves_metric.norm(srvs_ab)
products = srvs_ab * srvs_ab
sums = [gs.sum(product) for product in products]
squared_norm = gs.array(sums) / (srvs_ab.shape[-2] + 1)
expected = gs.sqrt(squared_norm)
self.assertAllClose(result, expected)
result = result.shape
expected = [srvs_ab.shape[0]]
self.assertAllClose(result, expected)
def test_srv_transform_and_srv_transform_inverse(self, rtol, atol):
"""Test that srv and its inverse are inverse."""
metric = SRVMetric(ambient_manifold=r3)
curve = DiscreteCurves(r3).random_point(n_samples=2)
srv = metric.srv_transform(curve)
srv_inverse = metric.srv_transform_inverse(srv, curve[:, 0])
result = srv.shape
expected = (curve.shape[0], curve.shape[1] - 1, 3)
self.assertAllClose(result, expected)
result = srv_inverse
expected = curve
self.assertAllClose(result, expected, rtol, atol)
@geomstats.tests.np_and_autograd_only
def test_aux_differential_srv_transform(
self, dim, n_sampling_points, n_curves, curve_fun_a
):
"""Test differential of square root velocity transform.
Check that its value at (curve, tangent_vec) coincides
with the derivative at zero of the square root velocity
transform of a path of curves starting at curve with
initial derivative tangent_vec.
"""
srv_metric_r3 = SRVMetric(r3)
sampling_times = gs.linspace(0.0, 1.0, n_sampling_points)
curve_a = curve_fun_a(sampling_times)
tangent_vec = gs.transpose(
gs.tile(gs.linspace(1.0, 2.0, n_sampling_points), (dim, 1))
)
result = srv_metric_r3.aux_differential_srv_transform(tangent_vec, curve_a)
times = gs.linspace(0.0, 1.0, n_curves)
path_of_curves = curve_a + gs.einsum("i,jk->ijk", times, tangent_vec)
srv_path = srv_metric_r3.srv_transform(path_of_curves)
expected = n_curves * (srv_path[1] - srv_path[0])
self.assertAllClose(result, expected, atol=1e-3, rtol=1e-3)
@geomstats.tests.np_and_autograd_only
def test_aux_differential_srv_transform_inverse(
self, dim, n_sampling_points, curve_a
):
"""Test inverse of differential of square root velocity transform.
Check that it is the inverse of aux_differential_srv_transform.
"""
tangent_vec = gs.transpose(
gs.tile(gs.linspace(0.0, 1.0, n_sampling_points), (dim, 1))
)
srv_metric_r3 = SRVMetric(r3)
d_srv = srv_metric_r3.aux_differential_srv_transform(tangent_vec, curve_a)
result = srv_metric_r3.aux_differential_srv_transform_inverse(d_srv, curve_a)
expected = tangent_vec
self.assertAllClose(result, expected, atol=1e-3, rtol=1e-3)
def test_aux_differential_srv_transform_vectorization(
self, dim, n_sampling_points, curve_a, curve_b
):
"""Test differential of square root velocity transform.
Check vectorization.
"""
dim = 3
curves = gs.stack((curve_a, curve_b))
tangent_vecs = gs.random.rand(2, n_sampling_points, dim)
srv_metric_r3 = SRVMetric(r3)
result = srv_metric_r3.aux_differential_srv_transform(tangent_vecs, curves)
res_a = srv_metric_r3.aux_differential_srv_transform(tangent_vecs[0], curve_a)
res_b = srv_metric_r3.aux_differential_srv_transform(tangent_vecs[1], curve_b)
expected = gs.stack([res_a, res_b])
self.assertAllClose(result, expected)
def test_srv_inner_product_elastic(self, dim, n_sampling_points, curve_a):
"""Test inner product of SRVMetric.
Check that the pullback metric gives an elastic metric
with parameters a=1, b=1/2.
"""
tangent_vec_a = gs.random.rand(n_sampling_points, dim)
tangent_vec_b = gs.random.rand(n_sampling_points, dim)
r3 = Euclidean(dim)
srv_metric_r3 = SRVMetric(r3)
result = srv_metric_r3.inner_product(tangent_vec_a, tangent_vec_b, curve_a)
d_vec_a = (n_sampling_points - 1) * (
tangent_vec_a[1:, :] - tangent_vec_a[:-1, :]
)
d_vec_b = (n_sampling_points - 1) * (
tangent_vec_b[1:, :] - tangent_vec_b[:-1, :]
)
velocity_vec = (n_sampling_points - 1) * (curve_a[1:, :] - curve_a[:-1, :])
velocity_norm = r3.metric.norm(velocity_vec)
unit_velocity_vec = gs.einsum("ij,i->ij", velocity_vec, 1 / velocity_norm)
a_param = 1
b_param = 1 / 2
integrand = (
a_param**2 * gs.sum(d_vec_a * d_vec_b, axis=1)
- (a_param**2 - b_param**2)
* gs.sum(d_vec_a * unit_velocity_vec, axis=1)
* gs.sum(d_vec_b * unit_velocity_vec, axis=1)
) / velocity_norm
expected = gs.sum(integrand) / n_sampling_points
self.assertAllClose(result, expected)
def test_srv_inner_product_and_dist(self, dim, curve_a, curve_b):
"""Test that norm of log and dist coincide
for curves with same / different starting points, and for
the translation invariant / non invariant SRV metric.
"""
r3 = Euclidean(dim=dim)
curve_b_transl = curve_b + gs.array([1.0, 0.0, 0.0])
curve_b = [curve_b, curve_b_transl]
translation_invariant = [True, False]
for curve in curve_b:
for param in translation_invariant:
srv_metric = SRVMetric(ambient_manifold=r3, translation_invariant=param)
log = srv_metric.log(point=curve, base_point=curve_a)
result = srv_metric.norm(vector=log, base_point=curve_a)
expected = srv_metric.dist(curve_a, curve)
self.assertAllClose(result, expected)
def test_srv_inner_product_vectorization(
self, dim, n_sampling_points, curve_a, curve_b
):
"""Test inner product of SRVMetric.
Check vectorization.
"""
curves = gs.stack((curve_a, curve_b))
tangent_vecs_1 = gs.random.rand(2, n_sampling_points, dim)
tangent_vecs_2 = gs.random.rand(2, n_sampling_points, dim)
srv_metric_r3 = SRVMetric(r3)
result = srv_metric_r3.inner_product(tangent_vecs_1, tangent_vecs_2, curves)
res_a = srv_metric_r3.inner_product(
tangent_vecs_1[0], tangent_vecs_2[0], curve_a
)
res_b = srv_metric_r3.inner_product(
tangent_vecs_1[1], tangent_vecs_2[1], curve_b
)
expected = gs.stack((res_a, res_b))
self.assertAllClose(result, expected)
@geomstats.tests.np_autograd_and_torch_only
def test_split_horizontal_vertical(
self, times, n_discretized_curves, curve_a, curve_b
):
"""Test split horizontal vertical.
Check that horizontal and vertical parts of any tangent
vector are othogonal with respect to the SRVMetric inner
product, and check vectorization.
"""
srv_metric_r3 = SRVMetric(r3)
quotient_srv_metric_r3 = DiscreteCurves(ambient_manifold=r3).quotient_srv_metric
geod = srv_metric_r3.geodesic(initial_curve=curve_a, end_curve=curve_b)
geod = geod(times)
tangent_vec = n_discretized_curves * (geod[1, :, :] - geod[0, :, :])
(
tangent_vec_hor,
tangent_vec_ver,
_,
) = quotient_srv_metric_r3.split_horizontal_vertical(tangent_vec, curve_a)
result = srv_metric_r3.inner_product(tangent_vec_hor, tangent_vec_ver, curve_a)
expected = 0.0
self.assertAllClose(result, expected, atol=1e-4)
tangent_vecs = n_discretized_curves * (geod[1:] - geod[:-1])
_, _, result = quotient_srv_metric_r3.split_horizontal_vertical(
tangent_vecs, geod[:-1]
)
expected = []
for i in range(n_discretized_curves - 1):
_, _, res = quotient_srv_metric_r3.split_horizontal_vertical(
tangent_vecs[i], geod[i]
)
expected.append(res)
expected = gs.stack(expected)
self.assertAllClose(result, expected)
def test_space_derivative(
self, dim, n_points, n_discretized_curves, n_sampling_points
):
"""Test space derivative.
Check result on an example and vectorization.
"""
n_points = 3
dim = 3
srv_metric_r3 = SRVMetric(Euclidean(dim))
curve = gs.random.rand(n_points, dim)
result = srv_metric_r3.space_derivative(curve)
delta = 1 / n_points
d_curve_1 = (curve[1] - curve[0]) / delta
d_curve_2 = (curve[2] - curve[0]) / (2 * delta)
d_curve_3 = (curve[2] - curve[1]) / delta
expected = gs.squeeze(
gs.vstack(
(
gs.to_ndarray(d_curve_1, 2),
gs.to_ndarray(d_curve_2, 2),
gs.to_ndarray(d_curve_3, 2),
)
)
)
self.assertAllClose(result, expected)
path_of_curves = gs.random.rand(n_discretized_curves, n_sampling_points, dim)
result = srv_metric_r3.space_derivative(path_of_curves)
expected = []
for i in range(n_discretized_curves):
expected.append(srv_metric_r3.space_derivative(path_of_curves[i]))
expected = gs.stack(expected)
self.assertAllClose(result, expected)
def test_srv_metric_pointwise_inner_products(
self, times, curve_a, curve_b, curve_c, n_discretized_curves, n_sampling_points
):
l2_metric_s2 = L2CurvesMetric(ambient_manifold=s2)
srv_metric_r3 = SRVMetric(ambient_manifold=r3)
curves_ab = l2_metric_s2.geodesic(curve_a, curve_b)
curves_bc = l2_metric_s2.geodesic(curve_b, curve_c)
curves_ab = curves_ab(times)
curves_bc = curves_bc(times)
tangent_vecs = l2_metric_s2.log(point=curves_bc, base_point=curves_ab)
result = srv_metric_r3.l2_curves_metric.pointwise_inner_products(
tangent_vec_a=tangent_vecs, tangent_vec_b=tangent_vecs, base_curve=curves_ab
)
expected_shape = (n_discretized_curves, n_sampling_points)
self.assertAllClose(gs.shape(result), expected_shape)
result = srv_metric_r3.l2_curves_metric.pointwise_inner_products(
tangent_vec_a=tangent_vecs[0],
tangent_vec_b=tangent_vecs[0],
base_curve=curves_ab[0],
)
expected_shape = (n_sampling_points,)
self.assertAllClose(gs.shape(result), expected_shape)
def test_srv_transform_and_inverse(self, times, curve_a, curve_b):
"""Test of SRVT and its inverse.
N.B: Here curves_ab are seen as curves in R3 and not S2.
"""
l2_metric_s2 = L2CurvesMetric(ambient_manifold=s2)
srv_metric_r3 = SRVMetric(ambient_manifold=r3)
curves_ab = l2_metric_s2.geodesic(curve_a, curve_b)
curves_ab = curves_ab(times)
curves = curves_ab
srv_curves = srv_metric_r3.srv_transform(curves)
starting_points = curves[:, 0, :]
result = srv_metric_r3.srv_transform_inverse(srv_curves, starting_points)
expected = curves
self.assertAllClose(result, expected)
point_1 = gs.array([0.1, 0.2, 0.3])
point_2 = gs.array([0.5, 5.0, 60.0])
translation_large = gs.array([0.0, 5.0, 6.0])
translation_small = gs.array([0.0, 0.6, 0.7])
elements_all = {
"translation_large": translation_large,
"translation_small": translation_small,
"point_1": point_1,
"point_2": point_2,
}
elements = elements_all
if tf_backend():
# Tf is extremely slow
elements = {"point_1": point_1, "point_2": point_2}
elements_matrices_all = {
key:
SpecialEuclidean(2,
point_type="vector").matrix_from_vector(elements_all[key])
for key in elements_all
}
elements_matrices = elements_matrices_all
class SpecialEuclideanTestData(_LieGroupTestData):
n_list = random.sample(range(2, 4), 2)
space_args_list = [(n, ) for n in n_list] + [(2, "vector"), (3, "vector")]
class TestSpecialEuclidean(LieGroupTestCase, metaclass=Parametrizer):
space = group = SpecialEuclidean
skip_test_log_after_exp = tf_backend()
skip_test_exp_after_log = tf_backend()
testing_data = SpecialEuclideanTestData()
def test_belongs(self, n, mat, expected):
self.assertAllClose(
SpecialEuclidean(n).belongs(gs.array(mat)), gs.array(expected)
)
def test_random_point_belongs(self, n, n_samples):
group = self.cls(n)
self.assertTrue(gs.all(group(n).random_point(n_samples)))
def test_identity(self, n, expected):
self.assertAllClose(SpecialEuclidean(n).identity, gs.array(expected))
def test_is_tangent(self, n, tangent_vec, base_point, expected):
result = SpecialEuclidean(n).is_tangent(
gs.array(tangent_vec), gs.array(base_point)
)
self.assertAllClose(result, gs.array(expected))
def test_metrics_default_point_type(self, n, metric_str):
group = self.space(n)
self.assertTrue(getattr(group, metric_str).default_point_type == "matrix")
def test_inverse_shape(self, n, points, expected):
group = self.space(n)
self.assertAllClose(gs.shape(group.inverse(points)), expected)
def test_compose_shape(self, n, point_a, point_b, expected):
group = self.space(n)
result = gs.shape(group.compose(gs.array(point_a), gs.array(point_b)))
self.assertAllClose(result, expected)
def test_regularize_shape(self, n, point_type, n_samples):
group = self.space(n, point_type)
points = group.random_point(n_samples=n_samples)
regularized_points = group.regularize(points)
self.assertAllClose(
gs.shape(regularized_points),
(n_samples, *group.get_point_type_shape()),
)
def test_compose(self, n, point_type, point_1, point_2, expected):
group = self.space(n, point_type)
result = group.compose(point_1, point_2)
self.assertAllClose(result, expected)
def test_group_exp_from_identity(self, n, point_type, tangent_vec, expected):
group = self.space(n, point_type)
result = group.exp(base_point=group.identity, tangent_vec=tangent_vec)
self.assertAllClose(result, expected)
def test_group_log_from_identity(self, n, point_type, point, expected):
group = self.space(n, point_type)
result = group.log(base_point=group.identity, point=point)
self.assertAllClose(result, expected)
class TestSpecialEuclidean(LieGroupTestCase, metaclass=Parametrizer):
space = group = SpecialEuclidean
skip_test_exp_then_log = tf_backend()
skip_test_log_then_exp = tf_backend()
class SpecialEuclideanTestData(_LieGroupTestData):
n_list = random.sample(range(2, 4), 2)
space_args_list = [(n,) for n in n_list] + [(2, "vector"), (3, "vector")]
shape_list = [(n + 1, n + 1) for n in n_list] + [(3,)] + [(6,)]
n_tangent_vecs_list = [2, 3] * 2
n_points_list = [2, 3] * 2
n_vecs_list = [2, 3] * 2
def belongs_test_data(self):
smoke_data = [
dict(
n=2, mat=group_useful_matrix(gs.pi / 3, elem_33=1.0), expected=True
),
dict(
n=2, mat=group_useful_matrix(gs.pi / 3, elem_33=0.0), expected=False
),
dict(
n=2,
mat=[
group_useful_matrix(gs.pi / 3, elem_33=1.0),
group_useful_matrix(gs.pi / 3, elem_33=0.0),
],
expected=[True, False],
),
]
return self.generate_tests(smoke_data)
def identity_test_data(self):
smoke_data = [
dict(n=2, expected=gs.eye(3)),
dict(n=3, expected=gs.eye(4)),
dict(n=10, expected=gs.eye(11)),
]
return self.generate_tests(smoke_data)
def is_tangent_test_data(self):
theta = gs.pi / 3
vec_1 = gs.array([[0.0, -theta, 2.0], [theta, 0.0, 3.0], [0.0, 0.0, 0.0]])
vec_2 = gs.array([[0.0, -theta, 2.0], [theta, 0.0, 3.0], [0.0, 0.0, 1.0]])
point = group_useful_matrix(theta)
smoke_data = [
dict(n=2, tangent_vec=point @ vec_1, base_point=point, expected=True),
dict(n=2, tangent_vec=point @ vec_2, base_point=point, expected=False),
dict(
n=2,
tangent_vec=[point @ vec_1, point @ vec_2],
base_point=point,
expected=[True, False],
),
]
return self.generate_tests(smoke_data)
def basis_representation_test_data(self):
n_list = random.sample(range(2, 50), 10)
n_samples = 100
random_data = [
dict(n=n, vec=gs.random.rand(n_samples, self.group.dim)) for n in n_list
]
return self.generate_tests([], random_data)
def metrics_default_point_type_test_data(self):
n_list = random.sample(range(2, 5), 2)
metric_str_list = [
"left_canonical_metric",
"right_canonical_metric",
"metric",
]
random_data = itertools.product(n_list, metric_str_list)
return self.generate_tests([], random_data)
def inverse_shape_test_data(self):
n_list = random.sample(range(2, 50), 10)
n_samples = 10
random_data = [
dict(
n=n,
points=SpecialEuclidean(n).random_point(n_samples),
expected=(n_samples, n + 1, n + 1),
)
for n in n_list
]
return self.generate_tests([], random_data)
def compose_shape_test_data(self):
n_list = random.sample(range(2, 50), 10)
n_samples = 10
random_data = [
dict(
n=n,
point_a=SpecialEuclidean(n).random_point(n_samples),
point_b=SpecialEuclidean(n).random_point(n_samples),
expected=(n_samples, n + 1, n + 1),
)
for n in n_list
]
random_data += [
dict(
n=n,
point_a=SpecialEuclidean(n).random_point(),
point_b=SpecialEuclidean(n).random_point(n_samples),
expected=(n_samples, n + 1, n + 1),
)
for n in n_list
]
random_data += [
dict(
n=n,
point_a=SpecialEuclidean(n).random_point(n_samples),
point_b=SpecialEuclidean(n).random_point(),
expected=(n_samples, n + 1, n + 1),
)
for n in n_list
]
return self.generate_tests([], random_data)
def random_point_belongs_test_data(self):
smoke_space_args_list = [(2, True), (3, True), (2, False)]
smoke_n_points_list = [1, 2, 1]
return self._random_point_belongs_test_data(
smoke_space_args_list,
smoke_n_points_list,
self.space_args_list,
self.n_points_list,
)
def projection_belongs_test_data(self):
return self._projection_belongs_test_data(
self.space_args_list,
self.shape_list,
self.n_points_list,
belongs_atol=1e-2,
)
def to_tangent_is_tangent_test_data(self):
return self._to_tangent_is_tangent_test_data(
SpecialEuclidean,
self.space_args_list,
self.shape_list,
self.n_vecs_list,
)
def random_tangent_vec_is_tangent_test_data(self):
return self._random_tangent_vec_is_tangent_test_data(
SpecialEuclidean,
self.space_args_list,
self.n_vecs_list,
is_tangent_atol=gs.atol * 100,
)
def exp_then_log_test_data(self):
return self._exp_then_log_test_data(
SpecialEuclidean,
self.space_args_list,
self.shape_list,
self.n_tangent_vecs_list,
amplitude=100,
atol=gs.atol * 10000,
)
def log_then_exp_test_data(self):
return self._log_then_exp_test_data(
SpecialEuclidean,
self.space_args_list,
self.n_points_list,
atol=gs.atol * 10000,
)
def regularize_test_data(self):
smoke_data = [
dict(
n=2,
point_type="vector",
point=elements_all["point_1"],
expected=elements_all["point_1"],
)
]
return self.generate_tests(smoke_data)
def regularize_shape_test_data(self):
smoke_data = [dict(n=2, point_type="vector", n_samples=3)]
return self.generate_tests(smoke_data)
def compose_inverse_point_with_point_is_identity_test_data(self):
return self._compose_inverse_point_with_point_is_identity_test_data(
SpecialEuclidean, self.space_args_list, self.n_points_list
)
def compose_point_with_inverse_point_is_identity_test_data(self):
return self._compose_point_with_inverse_point_is_identity_test_data(
SpecialEuclidean, self.space_args_list, self.n_points_list
)
def compose_point_with_identity_is_point_test_data(self):
return self._compose_point_with_identity_is_point_test_data(
SpecialEuclidean, self.space_args_list, self.n_points_list
)
def compose_identity_with_point_is_point_test_data(self):
return self._compose_identity_with_point_is_point_test_data(
SpecialEuclidean, self.space_args_list, self.n_points_list
)
def compose_test_data(self):
smoke_data = [
dict(
n=2,
point_typ="vector",
point_1=elements_all["translation_small"],
point_2=elements_all["translation_large"],
expected=elements_all["translation_small"]
+ elements_all["translation_large"],
)
]
return self.generate_tests(smoke_data)
def group_exp_from_identity_test_data(self):
smoke_data = [
dict(
n=2,
point_type="vector",
tangent_vec=elements_all["translation_small"],
expected=elements_all["translation_small"],
),
dict(
n=2,
point_type="vector",
tangent_vec=gs.stack([elements_all["translation_small"]] * 2),
expected=gs.stack([elements_all["translation_small"]] * 2),
),
]
return self.generate_tests(smoke_data)
def group_log_from_identity_test_data(self):
smoke_data = [
dict(
n=2,
point_type="vector",
point=elements_all["translation_small"],
expected=elements_all["translation_small"],
),
dict(
n=2,
point_type="vector",
point=gs.stack([elements_all["translation_small"]] * 2),
expected=gs.stack([elements_all["translation_small"]] * 2),
),
]
return self.generate_tests(smoke_data)
testing_data = SpecialEuclideanTestData()
def test_belongs(self, n, mat, expected):
self.assertAllClose(
SpecialEuclidean(n).belongs(gs.array(mat)), gs.array(expected)
)
def test_random_point_belongs(self, n, n_samples):
group = self.cls(n)
self.assertAllClose(gs.all(group(n).random_point(n_samples)), gs.array(True))
def test_identity(self, n, expected):
self.assertAllClose(SpecialEuclidean(n).identity, gs.array(expected))
def test_is_tangent(self, n, tangent_vec, base_point, expected):
result = SpecialEuclidean(n).is_tangent(
gs.array(tangent_vec), gs.array(base_point)
)
self.assertAllClose(result, gs.array(expected))
def test_metrics_default_point_type(self, n, metric_str):
group = self.space(n)
self.assertTrue(getattr(group, metric_str).default_point_type == "matrix")
def test_inverse_shape(self, n, points, expected):
group = self.space(n)
self.assertAllClose(gs.shape(group.inverse(points)), expected)
def test_compose_shape(self, n, point_a, point_b, expected):
group = self.space(n)
result = gs.shape(group.compose(gs.array(point_a), gs.array(point_b)))
self.assertAllClose(result, expected)
def test_regularize_shape(self, n, point_type, n_samples):
group = self.space(n, point_type)
points = group.random_point(n_samples=n_samples)
regularized_points = group.regularize(points)
self.assertAllClose(
gs.shape(regularized_points),
(n_samples, *group.get_point_type_shape()),
)
def test_compose(self, n, point_type, point_1, point_2, expected):
group = self.space(n, point_type)
result = group.compose(point_1, point_2)
self.assertAllClose(result, expected)
def test_group_exp_from_identity(self, n, point_type, tangent_vec, expected):
group = self.space(n, point_type)
result = group.exp(base_point=group.identity, tangent_vec=tangent_vec)
self.assertAllClose(result, expected)
def test_group_log_from_identity(self, n, point_type, point, expected):
group = self.space(n, point_type)
result = group.log(base_point=group.identity, point=point)
self.assertAllClose(result, expected)
