geomstats · ninamiolane · Jan 23, 2022 · Dec 30, 2021 · Dec 30, 2021 · Dec 30, 2021
diff --git a/geomstats/geometry/positive_lower_triangular_matrices.py b/geomstats/geometry/positive_lower_triangular_matrices.py
@@ -131,6 +131,7 @@ def differential_gram(tangent_vec, base_point):
         ----------
         tangent_vec : array_like, shape=[..., n, n]
             Tangent vector at base point.
+            Symmetric Matrix.
         base_point : array_like, shape=[..., n, n]
             Base point.
 
@@ -151,7 +152,7 @@ def inverse_differential_gram(tangent_vec, base_point):
         ----------
         tangent_vec : array_like, shape=[..., n, n]
             tanget vector at gram(base_point)
-            Symmetric Matrix
+            Symmetric Matrix.
         base_point : array_like, shape=[..., n, n]
             Base point.
 

diff --git a/pytest.ini b/pytest.ini
@@ -0,0 +1,4 @@
+[pytest]
+markers =
+    smoke: simple and basic numerical tests.
+    random: tests that use randomized data.
diff --git a/tests/conftest.py b/tests/conftest.py
@@ -1,17 +1,16 @@
 """Pytest utility classes, functions and fixtures."""
 
 import inspect
+import itertools
 import os
+import random
 import types
 
 import numpy as np
 import pytest
 
 import geomstats.backend as gs
 
-smoke = pytest.mark.smoke
-random = pytest.mark.random
-
 
 def autograd_backend():
     """Check if autograd is set as backend."""
@@ -119,11 +118,136 @@ def generate_tests(self, smoke_test_data, random_test_data=[]):
         _: list
             Tests.
         """
-        smoke_tests = [
-            pytest.param(*data.values(), marks=smoke) for data in smoke_test_data
-        ]
-        random_tests = [pytest.param(*data, marks=random) for data in random_test_data]
-        return smoke_tests + random_tests
+        tests = []
+        if smoke_test_data:
+            smoke_tests = [
+                pytest.param(*data.values(), marks=pytest.mark.smoke)
+                for data in smoke_test_data
+            ]
+            tests += smoke_tests
+        if random_test_data:
+            random_tests = [
+                pytest.param(*data.values(), marks=pytest.mark.random)
+                if isinstance(data, dict)
+                else pytest.param(*data, marks=pytest.mark.random)
+                for data in random_test_data
+            ]
+            tests += random_tests
+        return tests
+
+    def _log_exp_composition_data(
+        self, space, n_samples=100, max_n=10, n_n=5, **kwargs
+    ):
+        """Generate Data that checks for log and exp are inverse. Specifically
+
+            :math: `Exp_{base_point}(Log_{base_point}(point)) = point`
+
+
+        Parameters
+        ----------
+        space : cls
+            Manifold class on which metric is present.
+        max_n : int
+            Maximum value when generating 'n'.
+            Optional, default: 20
+        n_n : int
+            Number of 'n' to be generated.
+            Optional, default: 5
+        n_samples : int
+            Optional, default: 100
+
+        Returns
+        -------
+        _ : list
+            Test Data.
+        """
+        random_n = random.sample(range(1, max_n), n_n)
+        random_data = []
+        for n in random_n:
+            for prod in itertools.product(*kwargs.values()):
+                space_n = space(n)
+                base_point = space_n.random_point(n_samples)
+                point = space_n.random_point(n_samples)
+                random_data.append((n,) + prod + (point, base_point))
+        return self.generate_tests([], random_data)
+
+    def _geodesic_belongs_data(
+        self, space, max_n=10, n_n=5, n_geodesics=10, n_t=10, **kwargs
+    ):
+        """Generate Data that checks for points on geodesic belongs to data.
+
+        Parameters
+        ----------
+        space : cls
+            Manifold class on which metric is present.
+        max_n : int
+            Maximum value when generating 'n'.
+            Optional, default: 10
+        n_n : int
+            Maximum value when generating 'n'.
+            Optional, default: 5
+        n_geodesics : int
+            Number of geodesics to be generated.
+            Optional, d
5D39
efault: 10
+        n_t : int
+            Number of points to be sampled on each geodesic.
+            Optional, default: 10
+        Returns
+        -------
+        _ : list
+            Test Data.
+        """
+        random_n = random.sample(range(2, max_n), n_n)
+        random_data = []
+        for n in random_n:
+            for prod in itertools.product(*kwargs.values()):
+                space_n = space(n)
+                initial_point = space_n.random_point()
+                initial_tangent_points = space_n.random_tangent_vec(
+                    n_geodesics, base_point=initial_point
+                )
+                random_t = gs.linspace(start=-1.0, stop=1.0, num=n_t)
+                for initial_tangent_point, t in itertools.product(
+                    initial_tangent_points, random_t
+                ):
+                    random_data.append(
+                        (n,) + prod + (initial_point, initial_tangent_point, t)
+                    )
+        return self.generate_tests([], random_data)
+
+    def _squared_dist_is_symmetric_data(
+        self, space, max_n=5, n_n=3, n_samples=10, **kwargs
+    ):
+        """Generate Data that checks squared_dist is symmetric.
+
+        Parameters
+        ----------
+        space : cls
+            Manifold class on which metric is present.
+        max_n : int
+            Range of 'n' to generated.
+            Optional, default: 10
+        n_n : int
+            Maximum value when generating 'n'.
+            Optional, default: 3
+        n_samples : int
+            Number of points to be generated.
+            Optional, default: 10
+        Returns
+        -------
+        _ : list
+            Test Data.
+        """
+        random_n = random.sample(range(2, max_n), n_n)
+        random_data = []
+        for n in random_n:
+            for prod in itertools.product(*kwargs.values()):
+                space_n = space(n)
+                points_a = space_n.random_point(n_samples)
+                points_b = space_n.random_point(n_samples)
+                for point_a, point_b in itertools.product(points_a, points_b):
+                    random_data.append((n,) + prod + (point_a, point_b))
+        return self.generate_tests([], random_data)
 
 
 class Parametrizer(type):
@@ -133,7 +257,9 @@ class Parametrizer(type):
     (except class methods and static methods). Two conventions need to be respected:
 
         1.There should be a TestData object named 'testing_data'.
-        2.Every test function should have its corresponding data function inside TestData object.
+        2.Every test function should have its corresponding data function inside
+        TestData object.
+
         Ex. test_exp() should have method called exp_data() inside 'testing_data'."""
 
     def __new__(cls, name, bases, attrs):

diff --git a/tests/tests_geomstats/test_full_rank_matrices.py b/tests/tests_geomstats/test_full_rank_matrices.py
@@ -1,51 +1,63 @@
 """Unit tests for full rank matrices."""
 
-import warnings
-
 import geomstats.backend as gs
-import geomstats.tests
-import tests.helper as helper
 from geomstats.geometry.full_rank_matrices import FullRankMatrices
+from tests.conftest import Parametrizer, TestCase, TestData
+
+
+class TestFullRankMatrices(TestCase, metaclass=Parametrizer):
+
+    cls = FullRankMatrices
+
+    class TestDataFullRankMatrices(TestData):
+        def belongs_data(self):
+            smoke_data = [
+                dict(
+                    m=3,
+                    n=2,
+                    mat=[
+                        [-1.6473486, -1.18240309],
+                        [0.1944016, 0.18169231],
+                        [-1.13933855, -0.64971248],
+                    ],
+                    expected=True,
+                ),
+                dict(
+                    m=3, n=2, mat=[[1.0, -1.0], [1.0, -1.0], [0.0, 0.0]], expected=False
+                ),
+            ]
+            return self.generate_tests(smoke_data)
+
+        def random_and_belongs_data(self):
+            smoke_data = [
+                dict(m=1, n=1, n_points=1),
+                dict(m=1, n=1, n_points=1000),
+                dict(m=2, n=2, n_points=1),
+                dict(m=2, n=2, n_points=100),
+                dict(m=10, n=5, n_points=100),
+            ]
+            return self.generate_tests(smoke_data)
+
+        def projection_and_belongs_data(self):
+            shapes = [(1, 1), (1, 1), (1, 10), (2, 2), (10, 5), (15, 15)]
+            sizes = [1, 10, 1, 1, 100, 10]
+            random_data = [
+                dict(m=m, n=n, mats=gs.random.normal(size=(size, m, n)))
+                for (m, n), size in zip(shapes, sizes)
+            ]
 
+            return self.generate_tests([], random_data)
 
-class TestFullRankMatrices(geomstats.tests.TestCase):
-    """Test of Full Rank Matrices methods."""
-
-    def setup_method(self):
-        """Set up the test."""
-        warnings.simplefilter("ignore", category=ImportWarning)
-
-        gs.random.seed(1234)
+    testing_data = TestDataFullRankMatrices()
 
-        self.m = 3
-        self.n = 2
-        self.space = FullRankMatrices(self.m, self.n)
+    def test_belongs(self, m, n, mat, expected):
+        self.assertAllClose(self.cls(m, n).belongs(gs.array(mat)), gs.array(expected))
 
-    def test_belongs(self):
-        """Test of belongs method."""
-        fr = self.space
-        mat_fr = gs.array(
-            [
-                [-1.6473486, -1.18240309],
-                [0.1944016, 0.18169231],
-                [-1.13933855, -0.64971248],
-            ]
+    def test_random_and_belongs(self, m, n, n_points):
+        cls = self.cls(m, n)
+        self.assertAllClose(
+            gs.all(cls.belongs(cls.random_point(n_points))), gs.array(True)
         )
-        mat_not_fr = gs.array([[1.0, -1.0], [1.0, -1.0], [0.0, 0.0]])
-        result = fr.belongs(mat_fr)
-        self.assertTrue(result)
-        result = fr.belongs(mat_not_fr)
-        self.assertFalse(result)
-
-    def test_projection_and_belongs(self):
-        """Test of projection method."""
-        shape = (2, self.m, self.n)
-        result = helper.test_projection_and_belongs(self.space, shape, atol=gs.atol)
-        for res in result:
-            self.assertTrue(res)
-
-    def test_random_and_belongs(self):
-        """Test of random point sampling method."""
-        mat = self.space.random_point(5)
-        result = self.space.belongs(mat)
-        self.assertTrue(gs.all(result))
+
+    def test_projection_and_belongs(self, m, n, mat):
+        self.assertAllClose(gs.all(self.cls(m, n).belongs(mat)), True)