Cover tests (#5)

* Add test to ensure that filter values covered by single interval

* Refactor variables in unit test to reveal intent

* Add check_array and reshaping in OneDimensionalCover's transform

* Ensure that n_intervals=1 case gives correct output if input array contains only one float

* Add test for filter cover by union of intervals

* Refactor cover unit tests to reflect changes in filter arrays

* Remove redundant import

giotto/mapper/cover.py

@@ -1,5 +1,6 @@
 import numpy as np
 from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.utils import check_array
 from itertools import product
 
 
@@ -12,6 +13,13 @@ def fit(self, X, y=None):
         return self
 
     def transform(self, X, y=None):
+        X = check_array(X, ensure_2d=False)
+        if X.ndim == 1:
+            X = X[:, None]
+
+        if X.size == 1:
+            return np.array([[True]])
+
         M, m = np.max(X), np.min(X)
         L = M - m
         # Let the length of each interval be l. The equation to solve for

giotto/mapper/tests/test_cover.py

@@ -1,13 +1,58 @@
 import numpy as np
 from hypothesis import given
-from hypothesis.extra.numpy import array_shapes, arrays
+from hypothesis.extra.numpy import arrays
+from hypothesis.strategies import floats, integers
+from numpy.testing import assert_almost_equal
+from functools import reduce
 
 from giotto.mapper.cover import OneDimensionalCover
 
 
-@given(X=arrays(dtype=np.float, shape=array_shapes(min_dims=1, max_dims=1)))
-def test_one_dimensional_cover_shape(X):
-    cover = OneDimensionalCover()
-    n_samples, n_intervals = len(X), cover.n_intervals
-    Xt = cover.fit_transform(X.reshape(-1, 1))
-    assert (n_samples, n_intervals) == Xt.shape
+@given(
+    filter_values=arrays(
+        dtype=np.float,
+        elements=floats(allow_nan=False, allow_infinity=False),
+        shape=integers(min_value=2, max_value=1e3)),
+    n_intervals=integers(min_value=1, max_value=100)
+)
+def test_one_dimensional_cover_shape(filter_values, n_intervals):
+    cover = OneDimensionalCover(n_intervals=n_intervals)
+    n_samples, n_intervals = len(filter_values), cover.n_intervals
+    interval_masks = cover.fit_transform(filter_values)
+    assert (n_samples, n_intervals) == interval_masks.shape
+
+
+@given(
+    filter_values=arrays(dtype=np.float,
+                         elements=floats(allow_nan=False,
+                                         allow_infinity=False,
+                                         max_value=1e3),
+                         shape=integers(min_value=1, max_value=100)
+                         )
+)
+def test_filter_values_covered_by_single_interval(filter_values):
+    cover = OneDimensionalCover(n_intervals=1)
+    interval_masks = cover.fit_transform(filter_values)
+    # TODO: generate filter_values with desired shape
+    assert_almost_equal(
+        filter_values[:, None][interval_masks], filter_values)
+
+
+@given(
+    filter_values=arrays(dtype=np.float,
+                         elements=floats(allow_nan=False,
+                                         allow_infinity=False,
+                                         max_value=1e3),
+                         shape=integers(min_value=1, max_value=100),
+                         unique=True),
+    n_intervals=integers(min_value=1, max_value=10)
+)
+def test_filter_values_covered_by_interval_union(filter_values, n_intervals):
+    cover = OneDimensionalCover(n_intervals=n_intervals)
+    interval_masks = cover.fit_transform(filter_values)
+    intervals = [filter_values[interval_masks[:, i]]
+                 for i in range(interval_masks.shape[1])]
+    intervals_union = reduce(np.union1d, intervals)
+    filter_values_union = filter_values[np.in1d(
+        filter_values, intervals_union)]
+    assert_almost_equal(filter_values_union, filter_values)