Merge pull request #180 from lucasimi/bugfix/cubical-cover-extra-interval

Bugfix/cubical cover extra interval

Author: lucasimi

src/tdamapper/cover.py

@@ -303,10 +303,14 @@ def fit(self, X):
         else:
             self.__overlap_frac = self.overlap_frac
         self.__n_intervals = self.n_intervals
-        if (self.__overlap_frac <= 0.0) or (self.__overlap_frac > 0.5):
+        if self.__overlap_frac <= 0.0:
+            raise ValueError(
+                'The parameter overlap_frac is expected to be '
+                '> 0.0'
+            )
+        if self.__overlap_frac > 0.5:
             warn_user(
-                'The parameter overlap_frac is expected within range '
-                '(0.0, 0.5]'
+                'The parameter overlap_frac is expected to be <= 0.5'
             )
         self.__min, self.__max, self.__delta = self._get_bounds(X)
         radius = 1.0 / (2.0 - 2.0 * self.__overlap_frac)
@@ -337,16 +341,20 @@ def search(self, x):
         return self.__cover.search(center)
 
     def _get_center(self, x):
-        cell = self.__n_intervals * (x - self.__min) // self.__delta
+        offset = self._offset(x)
         center = self._phi(x)
-        return tuple(cell), center
+        return tuple(offset), center
 
     def _get_overlap_frac(self, dim, overlap_vol_frac):
         beta = math.pow(1.0 - overlap_vol_frac, 1.0 / dim)
         return 1.0 - 1.0 / (2.0 - beta)
 
+    def _offset(self, x):
+        return np.minimum(self.__n_intervals - 1, np.floor(self._gamma_n(x)))
+
     def _phi(self, x):
-        return self._gamma_n_inv(0.5 + np.floor(self._gamma_n(x)))
+        offset = self._offset(x)
+        return self._gamma_n_inv(0.5 + offset)
 
     def _gamma_n(self, x):
         return self.__n_intervals * (x - self.__min) / self.__delta

tests/test_unit_core.py

@@ -144,6 +144,14 @@ def test_proximity_cubical_line(self):
         g = mp.fit_transform(data, data)
         self.assertEqual(4, len(g.nodes))
 
+    def test_standard_cubical_line(self):
+        data = np.array([[float(i)] for i in range(1000)])
+        cover = StandardCubicalCover(n_intervals=4, overlap_frac=0.5)
+        clustering = TrivialClustering()
+        mp = MapperAlgorithm(cover, clustering)
+        g = mp.fit_transform(data, data)
+        self.assertEqual(4, len(g.nodes))
+
     def test_cubical_line(self):
         data = np.array([[float(i)] for i in range(1000)])
         cover = CubicalCover(n_intervals=4, overlap_frac=0.5)
@@ -152,6 +160,14 @@ def test_cubical_line(self):
         g = mp.fit_transform(data, data)
         self.assertEqual(4, len(g.nodes))
 
+    def test_cubical_no_overlap(self):
+        data = np.array([[0.0], [1.0], [2.0]])
+        cover = StandardCubicalCover(n_intervals=2, overlap_frac=0)
+        clustering = TrivialClustering()
+        mp = MapperAlgorithm(cover, clustering)
+        with self.assertRaises(ValueError):
+            mp.fit_transform(data, data)
+
     def test_mock_connected_components(self):
         data = [0, 1, 2, 3]
 

tests/test_unit_params.py

@@ -18,13 +18,13 @@ def __test_clone(self, obj):
         obj_repr = repr(obj)
         obj_cln = clone(obj)
         cln_repr = repr(obj_cln)
-        self.assertEquals(obj_repr, cln_repr)
+        self.assertEqual(obj_repr, cln_repr)
 
     def __test_repr(self, obj):
         obj_repr = repr(obj)
         _obj = eval(obj_repr)
         _obj_repr = repr(_obj)
-        self.assertEquals(obj_repr, _obj_repr)
+        self.assertEqual(obj_repr, _obj_repr)
 
     def __test_clone_and_repr(self, obj):
         self.__test_clone(obj)
@@ -38,16 +38,16 @@ def test_params_mapper_algorithm(self):
             ),
         )
         params = est.get_params(deep=False)
-        self.assertEquals(5, len(params))
+        self.assertEqual(5, len(params))
         params = est.get_params()
-        self.assertEquals(12, len(params))
-        self.assertEquals(3, params['cover__n_intervals'])
-        self.assertEquals(0.3, params['cover__overlap_frac'])
+        self.assertEqual(12, len(params))
+        self.assertEqual(3, params['cover__n_intervals'])
+        self.assertEqual(0.3, params['cover__overlap_frac'])
         est.set_params(cover__n_intervals=2, cover__overlap_frac=0.2)
         params = est.get_params()
-        self.assertEquals(12, len(params))
-        self.assertEquals(2, params['cover__n_intervals'])
-        self.assertEquals(0.2, params['cover__overlap_frac'])
+        self.assertEqual(12, len(params))
+        self.assertEqual(2, params['cover__n_intervals'])
+        self.assertEqual(0.2, params['cover__overlap_frac'])
 
     def test_params_mapper_clustering(self):
         est = MapperClustering(
@@ -57,16 +57,16 @@ def test_params_mapper_clustering(self):
             ),
         )
         params = est.get_params(deep=False)
-        self.assertEquals(3, len(params))
+        self.assertEqual(3, len(params))
         params = est.get_params()
-        self.assertEquals(10, len(params))
-        self.assertEquals(3, params['cover__n_intervals'])
-        self.assertEquals(0.3, params['cover__overlap_frac'])
+        self.assertEqual(10, len(params))
+        self.assertEqual(3, params['cover__n_intervals'])
+        self.assertEqual(0.3, params['cover__overlap_frac'])
         est.set_params(cover__n_intervals=2, cover__overlap_frac=0.2)
         params = est.get_params()
-        self.assertEquals(10, len(params))
-        self.assertEquals(2, params['cover__n_intervals'])
-        self.assertEquals(0.2, params['cover__overlap_frac'])
+        self.assertEqual(10, len(params))
+        self.assertEqual(2, params['cover__n_intervals'])
+        self.assertEqual(0.2, params['cover__overlap_frac'])
 
     def test_clone_and_repr_ball_cover(self):
         self.__test_clone_and_repr(BallCover())

tests/test_unit_proximity.py

@@ -43,7 +43,7 @@ def test_cubical_proximity(self):
         data = list(range(m, M + 1))
         cover = CubicalCover(n_intervals=n, overlap_frac=p)
         cover.fit(data)
-        for x in data:
+        for x in data[:-1]:
             result = cover.search(x)
             i = math.floor((x - m) / (w - delta))
             a_i = m + i * (w - delta) - delta / 2.0
@@ -53,7 +53,9 @@ def test_cubical_proximity(self):
                 self.assertTrue(c in expected)
             for c in expected:
                 self.assertTrue(c in result)
-            #self.assertEqual(set(expected), set(result))
+        x = data[-1]
+        last_result = cover.search(x)
+        self.assertEqual(result, last_result)
 
     def test_cubical_params(self):
         cover = CubicalCover(n_intervals=10, overlap_frac=0.5)