Merge remote-tracking branch 'origin/master' into tomato2

3 files changed, 103 insertions, 11 deletions

diff --git a/src/python/test/test_alpha_complex.py b/src/python/test/test_alpha_complex.py
index 77121302..943ad2c4 100755
--- a/src/python/test/test_alpha_complex.py
+++ b/src/python/test/test_alpha_complex.py
@@ -24,14 +24,18 @@ __copyright__ = "Copyright (C) 2016 Inria"
 __license__ = "MIT"
 
 
-def test_empty_alpha():
-    alpha_complex = AlphaComplex(points=[[0, 0]])
+def _empty_alpha(precision):
+    alpha_complex = AlphaComplex(points=[[0, 0]], precision = precision)
     assert alpha_complex.__is_defined() == True
 
+def test_empty_alpha():
+    _empty_alpha('fast')
+    _empty_alpha('safe')
+    _empty_alpha('exact')
 
-def test_infinite_alpha():
+def _infinite_alpha(precision):
     point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
-    alpha_complex = AlphaComplex(points=point_list)
+    alpha_complex = AlphaComplex(points=point_list, precision = precision)
     assert alpha_complex.__is_defined() == True
 
     simplex_tree = alpha_complex.create_simplex_tree()
@@ -79,10 +83,14 @@ def test_infinite_alpha():
     else:
         assert False
 
+def test_infinite_alpha():
+    _infinite_alpha('fast')
+    _infinite_alpha('safe')
+    _infinite_alpha('exact')
 
-def test_filtered_alpha():
+def _filtered_alpha(precision):
     point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
-    filtered_alpha = AlphaComplex(points=point_list)
+    filtered_alpha = AlphaComplex(points=point_list, precision = precision)
 
     simplex_tree = filtered_alpha.create_simplex_tree(max_alpha_square=0.25)
 
@@ -119,7 +127,12 @@ def test_filtered_alpha():
     assert simplex_tree.get_star([0]) == [([0], 0.0), ([0, 1], 0.25), ([0, 2], 0.25)]
     assert simplex_tree.get_cofaces([0], 1) == [([0, 1], 0.25), ([0, 2], 0.25)]
 
-def test_safe_alpha_persistence_comparison():
+def test_filtered_alpha():
+    _filtered_alpha('fast')
+    _filtered_alpha('safe')
+    _filtered_alpha('exact')
+
+def _safe_alpha_persistence_comparison(precision):
     #generate periodic signal
     time = np.arange(0, 10, 1)
     signal = [math.sin(x) for x in time]
@@ -131,10 +144,10 @@ def test_safe_alpha_persistence_comparison():
     embedding2 = [[signal[i], delayed[i]] for i in range(len(time))]
     
     #build alpha complex and simplex tree
-    alpha_complex1 = AlphaComplex(points=embedding1)
+    alpha_complex1 = AlphaComplex(points=embedding1, precision = precision)
     simplex_tree1 = alpha_complex1.create_simplex_tree()
     
-    alpha_complex2 = AlphaComplex(points=embedding2)
+    alpha_complex2 = AlphaComplex(points=embedding2, precision = precision)
     simplex_tree2 = alpha_complex2.create_simplex_tree()
     
     diag1 = simplex_tree1.persistence()
@@ -143,3 +156,47 @@ def test_safe_alpha_persistence_comparison():
     for (first_p, second_p) in zip_longest(diag1, diag2):
         assert first_p[0] == pytest.approx(second_p[0])
         assert first_p[1] == pytest.approx(second_p[1])
+
+
+def test_safe_alpha_persistence_comparison():
+    # Won't work for 'fast' version
+    _safe_alpha_persistence_comparison('safe')
+    _safe_alpha_persistence_comparison('exact')
+
+def _delaunay_complex(precision):
+    point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
+    filtered_alpha = AlphaComplex(points=point_list, precision = precision)
+
+    simplex_tree = filtered_alpha.create_simplex_tree(default_filtration_value = True)
+
+    assert simplex_tree.num_simplices() == 11
+    assert simplex_tree.num_vertices() == 4
+
+    assert point_list[0] == filtered_alpha.get_point(0)
+    assert point_list[1] == filtered_alpha.get_point(1)
+    assert point_list[2] == filtered_alpha.get_point(2)
+    assert point_list[3] == filtered_alpha.get_point(3)
+    try:
+        filtered_alpha.get_point(4) == []
+    except IndexError:
+        pass
+    else:
+        assert False
+    try:
+        filtered_alpha.get_point(125) == []
+    except IndexError:
+        pass
+    else:
+        assert False
+
+    for filtered_value in simplex_tree.get_filtration():
+        assert math.isnan(filtered_value[1])
+    for filtered_value in simplex_tree.get_star([0]):
+        assert math.isnan(filtered_value[1])
+    for filtered_value in simplex_tree.get_cofaces([0], 1):
+        assert math.isnan(filtered_value[1])
+
+def test_delaunay_complex():
+    _delaunay_complex('fast')
+    _delaunay_complex('safe')
+    _delaunay_complex('exact')
diff --git a/src/python/test/test_bottleneck_distance.py b/src/python/test/test_bottleneck_distance.py
index 70b2abad..6915bea8 100755
--- a/src/python/test/test_bottleneck_distance.py
+++ b/src/python/test/test_bottleneck_distance.py
@@ -9,6 +9,8 @@
 """
 
 import gudhi
+import gudhi.hera
+import pytest
 
 __author__ = "Vincent Rouvreau"
 __copyright__ = "Copyright (C) 2016 Inria"
@@ -19,5 +21,7 @@ def test_basic_bottleneck():
     diag1 = [[2.7, 3.7], [9.6, 14.0], [34.2, 34.974], [3.0, float("Inf")]]
     diag2 = [[2.8, 4.45], [9.5, 14.1], [3.2, float("Inf")]]
 
-    assert gudhi.bottleneck_distance(diag1, diag2, 0.1) == 0.8081763781405569
     assert gudhi.bottleneck_distance(diag1, diag2) == 0.75
+    assert gudhi.bottleneck_distance(diag1, diag2, 0.1) == pytest.approx(0.75, abs=0.1)
+    assert gudhi.hera.bottleneck_distance(diag1, diag2, 0) == 0.75
+    assert gudhi.hera.bottleneck_distance(diag1, diag2, 0.1) == pytest.approx(0.75, rel=0.1)
diff --git a/src/python/test/test_representations.py b/src/python/test/test_representations.py
index dba7f952..589cee00 100755
--- a/src/python/test/test_representations.py
+++ b/src/python/test/test_representations.py
@@ -1,12 +1,43 @@
 import os
 import sys
 import matplotlib.pyplot as plt
+import numpy as np
+import pytest
+
 
 def test_representations_examples():
     # Disable graphics for testing purposes
-    plt.show = lambda:None
+    plt.show = lambda: None
     here = os.path.dirname(os.path.realpath(__file__))
     sys.path.append(here + "/../example")
     import diagram_vectorizations_distances_kernels
 
     return None
+
+
+from gudhi.representations.metrics import *
+from gudhi.representations.kernel_methods import *
+
+
+def _n_diags(n):
+    l = []
+    for _ in range(n):
+        a = np.random.rand(50, 2)
+        a[:, 1] += a[:, 0]  # So that y >= x
+        l.append(a)
+    return l
+
+
+def test_multiple():
+    l1 = _n_diags(9)
+    l2 = _n_diags(11)
+    l1b = l1.copy()
+    d1 = pairwise_persistence_diagram_distances(l1, e=0.00001, n_jobs=4)
+    d2 = BottleneckDistance(epsilon=0.00001).fit_transform(l1)
+    d3 = pairwise_persistence_diagram_distances(l1, l1b, e=0.00001, n_jobs=4)
+    assert d1 == pytest.approx(d2)
+    assert d3 == pytest.approx(d2, abs=1e-5) # Because of 0 entries (on the diagonal)
+    d1 = pairwise_persistence_diagram_distances(l1, l2, metric="wasserstein", order=2, internal_p=2)
+    d2 = WassersteinDistance(order=2, internal_p=2, n_jobs=4).fit(l2).transform(l1)
+    print(d1.shape, d2.shape)
+    assert d1 == pytest.approx(d2, rel=.02)