Code review: rename get_simplex_filtration with get_simplex_and_filtration. Remove exception raise. Fix failed tests. Reword documentation

11 files changed, 161 insertions, 130 deletions

diff --git a/src/python/example/alpha_complex_from_points_example.py b/src/python/example/alpha_complex_from_points_example.py
index 844d7a82..465632eb 100755
--- a/src/python/example/alpha_complex_from_points_example.py
+++ b/src/python/example/alpha_complex_from_points_example.py
@@ -47,7 +47,10 @@ else:
     print("[4] Not found...")
 
 print("dimension=", simplex_tree.dimension())
-print("filtrations=", simplex_tree.get_filtration())
+print("filtrations=")
+for simplex_with_filtration in simplex_tree.get_filtration():
+    print("(%s, %.2f)" % tuple(simplex_with_filtration))
+
 print("star([0])=", simplex_tree.get_star([0]))
 print("coface([0], 1)=", simplex_tree.get_cofaces([0], 1))
 
diff --git a/src/python/example/rips_complex_from_points_example.py b/src/python/example/rips_complex_from_points_example.py
index 59d8a261..c05703c6 100755
--- a/src/python/example/rips_complex_from_points_example.py
+++ b/src/python/example/rips_complex_from_points_example.py
@@ -22,6 +22,9 @@ rips = gudhi.RipsComplex(points=[[0, 0], [1, 0], [0, 1], [1, 1]], max_edge_lengt
 
 simplex_tree = rips.create_simplex_tree(max_dimension=1)
 
-print("filtrations=", simplex_tree.get_filtration())
+print("filtrations=")
+for simplex_with_filtration in simplex_tree.get_filtration():
+    print("(%s, %.2f)" % tuple(simplex_with_filtration))
+
 print("star([0])=", simplex_tree.get_star([0]))
 print("coface([0], 1)=", simplex_tree.get_cofaces([0], 1))
diff --git a/src/python/example/simplex_tree_example.py b/src/python/example/simplex_tree_example.py
index 30de00da..7f20c389 100755
--- a/src/python/example/simplex_tree_example.py
+++ b/src/python/example/simplex_tree_example.py
@@ -39,7 +39,10 @@ else:
 print("dimension=", st.dimension())
 
 st.initialize_filtration()
-print("filtration=", st.get_filtration())
+print("filtration=")
+for simplex_with_filtration in st.get_filtration():
+    print("(%s, %.2f)" % tuple(simplex_with_filtration))
+
 print("filtration[1, 2]=", st.filtration([1, 2]))
 print("filtration[4, 2]=", st.filtration([4, 2]))
 
diff --git a/src/python/gudhi/simplex_tree.pxd b/src/python/gudhi/simplex_tree.pxd
index caf3c459..1b0dc881 100644
--- a/src/python/gudhi/simplex_tree.pxd
+++ b/src/python/gudhi/simplex_tree.pxd
@@ -46,7 +46,7 @@ cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
         bool prune_above_filtration(double filtration)
         bool make_filtration_non_decreasing()
         # Iterators over Simplex tree
-        pair[vector[int], double] get_simplex_filtration(Simplex_tree_simplex_handle f_simplex)
+        pair[vector[int], double] get_simplex_and_filtration(Simplex_tree_simplex_handle f_simplex)
         vector[Simplex_tree_simplex_handle].const_iterator get_filtration_iterator_begin()
         vector[Simplex_tree_simplex_handle].const_iterator get_filtration_iterator_end()
 
diff --git a/src/python/gudhi/simplex_tree.pyx b/src/python/gudhi/simplex_tree.pyx
index 478139de..22978b6e 100644
--- a/src/python/gudhi/simplex_tree.pyx
+++ b/src/python/gudhi/simplex_tree.pyx
@@ -209,20 +209,18 @@ cdef class SimplexTree:
                                                         <double>filtration)
 
     def get_filtration(self):
-        """This function returns a list of all simplices with their given
+        """This function returns a generator with simplices and their given
         filtration values.
 
         :returns:  The simplices sorted by increasing filtration values.
-        :rtype:  list of tuples(simplex, filtration)
+        :rtype:  generator with tuples(simplex, filtration)
         """
         cdef vector[Simplex_tree_simplex_handle].const_iterator it = self.get_ptr().get_filtration_iterator_begin()
         cdef vector[Simplex_tree_simplex_handle].const_iterator end = self.get_ptr().get_filtration_iterator_end()
 
-        while True:
-            yield(self.get_ptr().get_simplex_filtration(dereference(it)))
+        while it != end:
+            yield(self.get_ptr().get_simplex_and_filtration(dereference(it)))
             preincrement(it)
-            if it == end:
-                raise StopIteration
 
     def get_skeleton(self, dimension):
         """This function returns the (simplices of the) skeleton of a maximum
diff --git a/src/python/include/Simplex_tree_interface.h b/src/python/include/Simplex_tree_interface.h
index 843966cd..c0bbc3d9 100644
--- a/src/python/include/Simplex_tree_interface.h
+++ b/src/python/include/Simplex_tree_interface.h
@@ -33,8 +33,8 @@ class Simplex_tree_interface : public Simplex_tree<SimplexTreeOptions> {
   using Simplex_handle = typename Base::Simplex_handle;
   using Insertion_result = typename std::pair<Simplex_handle, bool>;
   using Simplex = std::vector<Vertex_handle>;
-  using Filtered_simplex = std::pair<Simplex, Filtration_value>;
-  using Filtered_simplices = std::vector<Filtered_simplex>;
+  using Simplex_and_filtration = std::pair<Simplex, Filtration_value>;
+  using Filtered_simplices = std::vector<Simplex_and_filtration>;
 
  public:
   bool find_simplex(const Simplex& vh) {
@@ -83,7 +83,7 @@ class Simplex_tree_interface : public Simplex_tree<SimplexTreeOptions> {
     Base::initialize_filtration();
   }
 
-  Filtered_simplex get_simplex_filtration(Simplex_handle f_simplex) {
+  Simplex_and_filtration get_simplex_and_filtration(Simplex_handle f_simplex) {
     Simplex simplex;
     for (auto vertex : Base::simplex_vertex_range(f_simplex)) {
       simplex.insert(simplex.begin(), vertex);
diff --git a/src/python/test/test_alpha_complex.py b/src/python/test/test_alpha_complex.py
index 3761fe16..ceead919 100755
--- a/src/python/test/test_alpha_complex.py
+++ b/src/python/test/test_alpha_complex.py
@@ -40,19 +40,21 @@ def test_infinite_alpha():
     assert simplex_tree.num_simplices() == 11
     assert simplex_tree.num_vertices() == 4
 
-    assert simplex_tree.get_filtration() == [
-        ([0], 0.0),
-        ([1], 0.0),
-        ([2], 0.0),
-        ([3], 0.0),
-        ([0, 1], 0.25),
-        ([0, 2], 0.25),
-        ([1, 3], 0.25),
-        ([2, 3], 0.25),
-        ([1, 2], 0.5),
-        ([0, 1, 2], 0.5),
-        ([1, 2, 3], 0.5),
-    ]
+    filtration_generator = simplex_tree.get_filtration()
+    assert(next(filtration_generator) == ([0], 0.0))
+    assert(next(filtration_generator) == ([1], 0.0))
+    assert(next(filtration_generator) == ([2], 0.0))
+    assert(next(filtration_generator) == ([3], 0.0))
+    assert(next(filtration_generator) == ([0, 1], 0.25))
+    assert(next(filtration_generator) == ([0, 2], 0.25))
+    assert(next(filtration_generator) == ([1, 3], 0.25))
+    assert(next(filtration_generator) == ([2, 3], 0.25))
+    assert(next(filtration_generator) == ([1, 2], 0.5))
+    assert(next(filtration_generator) == ([0, 1, 2], 0.5))
+    assert(next(filtration_generator) == ([1, 2, 3], 0.5))
+    with pytest.raises(StopIteration):
+        next(filtration_generator)
+
     assert simplex_tree.get_star([0]) == [
         ([0], 0.0),
         ([0, 1], 0.25),
@@ -105,16 +107,18 @@ def test_filtered_alpha():
     else:
         assert False
 
-    assert simplex_tree.get_filtration() == [
-        ([0], 0.0),
-        ([1], 0.0),
-        ([2], 0.0),
-        ([3], 0.0),
-        ([0, 1], 0.25),
-        ([0, 2], 0.25),
-        ([1, 3], 0.25),
-        ([2, 3], 0.25),
-    ]
+    filtration_generator = simplex_tree.get_filtration()
+    assert(next(filtration_generator) == ([0], 0.0))
+    assert(next(filtration_generator) == ([1], 0.0))
+    assert(next(filtration_generator) == ([2], 0.0))
+    assert(next(filtration_generator) == ([3], 0.0))
+    assert(next(filtration_generator) == ([0, 1], 0.25))
+    assert(next(filtration_generator) == ([0, 2], 0.25))
+    assert(next(filtration_generator) == ([1, 3], 0.25))
+    assert(next(filtration_generator) == ([2, 3], 0.25))
+    with pytest.raises(StopIteration):
+        next(filtration_generator)
+
     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)]
 
diff --git a/src/python/test/test_euclidean_witness_complex.py b/src/python/test/test_euclidean_witness_complex.py
index c18d2484..16ff1ef4 100755
--- a/src/python/test/test_euclidean_witness_complex.py
+++ b/src/python/test/test_euclidean_witness_complex.py
@@ -9,6 +9,7 @@
 """
 
 import gudhi
+import pytest
 
 __author__ = "Vincent Rouvreau"
 __copyright__ = "Copyright (C) 2016 Inria"
@@ -40,15 +41,16 @@ def test_witness_complex():
     assert landmarks[1] == euclidean_witness_complex.get_point(1)
     assert landmarks[2] == euclidean_witness_complex.get_point(2)
 
-    assert simplex_tree.get_filtration() == [
-        ([0], 0.0),
-        ([1], 0.0),
-        ([0, 1], 0.0),
-        ([2], 0.0),
-        ([0, 2], 0.0),
-        ([1, 2], 0.0),
-        ([0, 1, 2], 0.0),
-    ]
+    filtration_generator = simplex_tree.get_filtration()
+    assert(next(filtration_generator) == ([0], 0.0))
+    assert(next(filtration_generator) == ([1], 0.0))
+    assert(next(filtration_generator) == ([0, 1], 0.0))
+    assert(next(filtration_generator) == ([2], 0.0))
+    assert(next(filtration_generator) == ([0, 2], 0.0))
+    assert(next(filtration_generator) == ([1, 2], 0.0))
+    assert(next(filtration_generator) == ([0, 1, 2], 0.0))
+    with pytest.raises(StopIteration):
+        next(filtration_generator)
 
 
 def test_empty_euclidean_strong_witness_complex():
@@ -78,18 +80,24 @@ def test_strong_witness_complex():
     assert landmarks[1] == euclidean_strong_witness_complex.get_point(1)
     assert landmarks[2] == euclidean_strong_witness_complex.get_point(2)
 
-    assert simplex_tree.get_filtration() == [([0], 0.0), ([1], 0.0), ([2], 0.0)]
+    filtration_generator = simplex_tree.get_filtration()
+    assert(next(filtration_generator) == ([0], 0.0))
+    assert(next(filtration_generator) == ([1], 0.0))
+    assert(next(filtration_generator) == ([2], 0.0))
+    with pytest.raises(StopIteration):
+        next(filtration_generator)
 
     simplex_tree = euclidean_strong_witness_complex.create_simplex_tree(
         max_alpha_square=100.0
     )
 
-    assert simplex_tree.get_filtration() == [
-        ([0], 0.0),
-        ([1], 0.0),
-        ([2], 0.0),
-        ([1, 2], 15.0),
-        ([0, 2], 34.0),
-        ([0, 1], 37.0),
-        ([0, 1, 2], 37.0),
-    ]
+    filtration_generator = simplex_tree.get_filtration()
+    assert(next(filtration_generator) == ([0], 0.0))
+    assert(next(filtration_generator) == ([1], 0.0))
+    assert(next(filtration_generator) == ([2], 0.0))
+    assert(next(filtration_generator) == ([1, 2], 15.0))
+    assert(next(filtration_generator) == ([0, 2], 34.0))
+    assert(next(filtration_generator) == ([0, 1], 37.0))
+    assert(next(filtration_generator) == ([0, 1, 2], 37.0))
+    with pytest.raises(StopIteration):
+        next(filtration_generator)
diff --git a/src/python/test/test_rips_complex.py b/src/python/test/test_rips_complex.py
index b02a68e1..bd31c47c 100755
--- a/src/python/test/test_rips_complex.py
+++ b/src/python/test/test_rips_complex.py
@@ -10,6 +10,7 @@
 
 from gudhi import RipsComplex
 from math import sqrt
+import pytest
 
 __author__ = "Vincent Rouvreau"
 __copyright__ = "Copyright (C) 2016 Inria"
@@ -32,18 +33,20 @@ def test_rips_from_points():
     assert simplex_tree.num_simplices() == 10
     assert simplex_tree.num_vertices() == 4
 
-    assert simplex_tree.get_filtration() == [
-        ([0], 0.0),
-        ([1], 0.0),
-        ([2], 0.0),
-        ([3], 0.0),
-        ([0, 1], 1.0),
-        ([0, 2], 1.0),
-        ([1, 3], 1.0),
-        ([2, 3], 1.0),
-        ([1, 2], 1.4142135623730951),
-        ([0, 3], 1.4142135623730951),
-    ]
+    filtration_generator = simplex_tree.get_filtration()
+    assert(next(filtration_generator) == ([0], 0.0))
+    assert(next(filtration_generator) == ([1], 0.0))
+    assert(next(filtration_generator) == ([2], 0.0))
+    assert(next(filtration_generator) == ([3], 0.0))
+    assert(next(filtration_generator) == ([0, 1], 1.0))
+    assert(next(filtration_generator) == ([0, 2], 1.0))
+    assert(next(filtration_generator) == ([1, 3], 1.0))
+    assert(next(filtration_generator) == ([2, 3], 1.0))
+    assert(next(filtration_generator) == ([1, 2], 1.4142135623730951))
+    assert(next(filtration_generator) == ([0, 3], 1.4142135623730951))
+    with pytest.raises(StopIteration):
+        next(filtration_generator)
+
     assert simplex_tree.get_star([0]) == [
         ([0], 0.0),
         ([0, 1], 1.0),
@@ -95,18 +98,20 @@ def test_rips_from_distance_matrix():
     assert simplex_tree.num_simplices() == 10
     assert simplex_tree.num_vertices() == 4
 
-    assert simplex_tree.get_filtration() == [
-        ([0], 0.0),
-        ([1], 0.0),
-        ([2], 0.0),
-        ([3], 0.0),
-        ([0, 1], 1.0),
-        ([0, 2], 1.0),
-        ([1, 3], 1.0),
-        ([2, 3], 1.0),
-        ([1, 2], 1.4142135623730951),
-        ([0, 3], 1.4142135623730951),
-    ]
+    filtration_generator = simplex_tree.get_filtration()
+    assert(next(filtration_generator) == ([0], 0.0))
+    assert(next(filtration_generator) == ([1], 0.0))
+    assert(next(filtration_generator) == ([2], 0.0))
+    assert(next(filtration_generator) == ([3], 0.0))
+    assert(next(filtration_generator) == ([0, 1], 1.0))
+    assert(next(filtration_generator) == ([0, 2], 1.0))
+    assert(next(filtration_generator) == ([1, 3], 1.0))
+    assert(next(filtration_generator) == ([2, 3], 1.0))
+    assert(next(filtration_generator) == ([1, 2], 1.4142135623730951))
+    assert(next(filtration_generator) == ([0, 3], 1.4142135623730951))
+    with pytest.raises(StopIteration):
+        next(filtration_generator)
+
     assert simplex_tree.get_star([0]) == [
         ([0], 0.0),
         ([0, 1], 1.0),
diff --git a/src/python/test/test_simplex_tree.py b/src/python/test/test_simplex_tree.py
index 1822c43b..0f3db7ac 100755
--- a/src/python/test/test_simplex_tree.py
+++ b/src/python/test/test_simplex_tree.py
@@ -9,6 +9,7 @@
 """
 
 from gudhi import SimplexTree
+import pytest
 
 __author__ = "Vincent Rouvreau"
 __copyright__ = "Copyright (C) 2016 Inria"
@@ -126,55 +127,58 @@ def test_expansion():
 
     assert st.num_vertices() == 7
     assert st.num_simplices() == 17
-    assert st.get_filtration() == [
-        ([2], 0.1),
-        ([3], 0.1),
-        ([2, 3], 0.1),
-        ([0], 0.2),
-        ([0, 2], 0.2),
-        ([1], 0.3),
-        ([0, 1], 0.3),
-        ([1, 3], 0.4),
-        ([1, 2], 0.5),
-        ([5], 0.6),
-        ([6], 0.6),
-        ([5, 6], 0.6),
-        ([4], 0.7),
-        ([2, 4], 0.7),
-        ([0, 3], 0.8),
-        ([4, 6], 0.9),
-        ([3, 6], 1.0),
-    ]
+
+    filtration_generator = st.get_filtration()
+    assert(next(filtration_generator) == ([2], 0.1))
+    assert(next(filtration_generator) == ([3], 0.1))
+    assert(next(filtration_generator) == ([2, 3], 0.1))
+    assert(next(filtration_generator) == ([0], 0.2))
+    assert(next(filtration_generator) == ([0, 2], 0.2))
+    assert(next(filtration_generator) == ([1], 0.3))
+    assert(next(filtration_generator) == ([0, 1], 0.3))
+    assert(next(filtration_generator) == ([1, 3], 0.4))
+    assert(next(filtration_generator) == ([1, 2], 0.5))
+    assert(next(filtration_generator) == ([5], 0.6))
+    assert(next(filtration_generator) == ([6], 0.6))
+    assert(next(filtration_generator) == ([5, 6], 0.6))
+    assert(next(filtration_generator) == ([4], 0.7))
+    assert(next(filtration_generator) == ([2, 4], 0.7))
+    assert(next(filtration_generator) == ([0, 3], 0.8))
+    assert(next(filtration_generator) == ([4, 6], 0.9))
+    assert(next(filtration_generator) == ([3, 6], 1.0))
+    with pytest.raises(StopIteration):
+        next(filtration_generator)
 
     st.expansion(3)
     assert st.num_vertices() == 7
     assert st.num_simplices() == 22
     st.initialize_filtration()
 
-    assert st.get_filtration() == [
-        ([2], 0.1),
-        ([3], 0.1),
-        ([2, 3], 0.1),
-        ([0], 0.2),
-        ([0, 2], 0.2),
-        ([1], 0.3),
-        ([0, 1], 0.3),
-        ([1, 3], 0.4),
-        ([1, 2], 0.5),
-        ([0, 1, 2], 0.5),
-        ([1, 2, 3], 0.5),
-        ([5], 0.6),
-        ([6], 0.6),
-        ([5, 6], 0.6),
-        ([4], 0.7),
-        ([2, 4], 0.7),
-        ([0, 3], 0.8),
-        ([0, 1, 3], 0.8),
-        ([0, 2, 3], 0.8),
-        ([0, 1, 2, 3], 0.8),
-        ([4, 6], 0.9),
-        ([3, 6], 1.0),
-    ]
+    filtration_generator = st.get_filtration()
+    assert(next(filtration_generator) == ([2], 0.1))
+    assert(next(filtration_generator) == ([3], 0.1))
+    assert(next(filtration_generator) == ([2, 3], 0.1))
+    assert(next(filtration_generator) == ([0], 0.2))
+    assert(next(filtration_generator) == ([0, 2], 0.2))
+    assert(next(filtration_generator) == ([1], 0.3))
+    assert(next(filtration_generator) == ([0, 1], 0.3))
+    assert(next(filtration_generator) == ([1, 3], 0.4))
+    assert(next(filtration_generator) == ([1, 2], 0.5))
+    assert(next(filtration_generator) == ([0, 1, 2], 0.5))
+    assert(next(filtration_generator) == ([1, 2, 3], 0.5))
+    assert(next(filtration_generator) == ([5], 0.6))
+    assert(next(filtration_generator) == ([6], 0.6))
+    assert(next(filtration_generator) == ([5, 6], 0.6))
+    assert(next(filtration_generator) == ([4], 0.7))
+    assert(next(filtration_generator) == ([2, 4], 0.7))
+    assert(next(filtration_generator) == ([0, 3], 0.8))
+    assert(next(filtration_generator) == ([0, 1, 3], 0.8))
+    assert(next(filtration_generator) == ([0, 2, 3], 0.8))
+    assert(next(filtration_generator) == ([0, 1, 2, 3], 0.8))
+    assert(next(filtration_generator) == ([4, 6], 0.9))
+    assert(next(filtration_generator) == ([3, 6], 1.0))
+    with pytest.raises(StopIteration):
+        next(filtration_generator)
 
 
 def test_automatic_dimension():
diff --git a/src/python/test/test_tangential_complex.py b/src/python/test/test_tangential_complex.py
index e650e99c..90e2c75b 100755
--- a/src/python/test/test_tangential_complex.py
+++ b/src/python/test/test_tangential_complex.py
@@ -9,6 +9,7 @@
 """
 
 from gudhi import TangentialComplex, SimplexTree
+import pytest
 
 __author__ = "Vincent Rouvreau"
 __copyright__ = "Copyright (C) 2016 Inria"
@@ -37,14 +38,16 @@ def test_tangential():
     assert st.num_simplices() == 6
     assert st.num_vertices() == 4
 
-    assert st.get_filtration() == [
-        ([0], 0.0),
-        ([1], 0.0),
-        ([2], 0.0),
-        ([0, 2], 0.0),
-        ([3], 0.0),
-        ([1, 3], 0.0),
-    ]
+    filtration_generator = st.get_filtration()
+    assert(next(filtration_generator) == ([0], 0.0))
+    assert(next(filtration_generator) == ([1], 0.0))
+    assert(next(filtration_generator) == ([2], 0.0))
+    assert(next(filtration_generator) == ([0, 2], 0.0))
+    assert(next(filtration_generator) == ([3], 0.0))
+    assert(next(filtration_generator) == ([1, 3], 0.0))
+    with pytest.raises(StopIteration):
+        next(filtration_generator)
+
     assert st.get_cofaces([0], 1) == [([0, 2], 0.0)]
 
     assert point_list[0] == tc.get_point(0)