diff options
-rwxr-xr-x | src/cython/example/Alpha_complex_example.py | 38 | ||||
-rwxr-xr-x | src/cython/example/Mini_simplex_tree_example.py | 15 | ||||
-rwxr-xr-x | src/cython/example/Rips_complex_example.py | 10 | ||||
-rwxr-xr-x | src/cython/example/Simplex_tree_example.py | 27 | ||||
-rw-r--r-- | src/cython/src/cpp/Persistent_cohomology_interface.h | 6 | ||||
-rw-r--r-- | src/cython/src/cython/Alpha_complex.pyx | 91 | ||||
-rw-r--r-- | src/cython/src/cython/Mini_simplex_tree.pyx | 87 | ||||
-rw-r--r-- | src/cython/src/cython/Rips_complex.pyx | 95 | ||||
-rw-r--r-- | src/cython/src/cython/Simplex_tree.pyx | 86 | ||||
-rwxr-xr-x | src/cython/test/Alpha_complex_UT.py | 86 | ||||
-rwxr-xr-x | src/cython/test/Mini_simplex_tree_UT.py | 36 | ||||
-rwxr-xr-x | src/cython/test/Rips_complex_UT.py | 35 | ||||
-rwxr-xr-x | src/cython/test/Simplex_tree_UT.py | 106 |
13 files changed, 434 insertions, 284 deletions
diff --git a/src/cython/example/Alpha_complex_example.py b/src/cython/example/Alpha_complex_example.py index cf5eed55..a724b0c4 100755 --- a/src/cython/example/Alpha_complex_example.py +++ b/src/cython/example/Alpha_complex_example.py @@ -2,44 +2,44 @@ import gudhi -print("#######################################################################") +print("#####################################################################") print("AlphaComplex creation from points") -alpha_complex = gudhi.AlphaComplex(points=[[0,0],[1,0],[0,1],[1,1]], max_alpha_square=60.0) +alpha_complex = gudhi.AlphaComplex(points=[[0, 0], [1, 0], [0, 1], [1, 1]], + max_alpha_square=60.0) -if alpha_complex.find([0,1]): - print("[0,1] Found !!") +if alpha_complex.find([0, 1]): + print("[0, 1] Found !!") else: - print("[0,1] Not found...") + print("[0, 1] Not found...") if alpha_complex.find([4]): - print("[4] Found !!") + print("[4] Found !!") else: - print("[4] Not found...") + print("[4] Not found...") -if alpha_complex.insert([0,1,2], filtration=4.0): - print("[0,1,2] Inserted !!") +if alpha_complex.insert([0, 1, 2], filtration=4.0): + print("[0, 1, 2] Inserted !!") else: - print("[0,1,2] Not inserted...") + print("[0, 1, 2] Not inserted...") -if alpha_complex.insert([0,1,4], filtration=4.0): - print("[0,1,4] Inserted !!") +if alpha_complex.insert([0, 1, 4], filtration=4.0): + print("[0, 1, 4] Inserted !!") else: - print("[0,1,4] Not inserted...") + print("[0, 1, 4] Not inserted...") if alpha_complex.find([4]): - print("[4] Found !!") + print("[4] Found !!") else: - print("[4] Not found...") + print("[4] Not found...") print("dimension=", alpha_complex.dimension()) print("filtered_tree=", alpha_complex.get_filtered_tree()) print("star([0])=", alpha_complex.get_star_tree([0])) -print("coface([0],1)=", alpha_complex.get_coface_tree([0], 1)) +print("coface([0], 1)=", alpha_complex.get_coface_tree([0], 1)) print("point[0]=", alpha_complex.get_point(0)) print("point[5]=", alpha_complex.get_point(5)) alpha_complex.initialize_filtration() -print("persistence(2)=", alpha_complex.persistence(2)) - -print("#######################################################################") +print("persistence(2)=", alpha_complex.persistence(homology_coeff_field=2, + min_persistence=0)) diff --git a/src/cython/example/Mini_simplex_tree_example.py b/src/cython/example/Mini_simplex_tree_example.py index 87407317..6cd5bf29 100755 --- a/src/cython/example/Mini_simplex_tree_example.py +++ b/src/cython/example/Mini_simplex_tree_example.py @@ -2,7 +2,7 @@ import gudhi -print("#######################################################################") +print("#####################################################################") print("MiniSimplexTree creation from insertion") """ Complex to build. @@ -10,7 +10,8 @@ print("MiniSimplexTree creation from insertion") o---o /X\ / o---o o - 2 0 4 """ + 2 0 4 +""" triangle012 = [0, 1, 2] edge03 = [0, 3] @@ -23,7 +24,7 @@ mini_st.insert(edge13) mini_st.insert(vertex4) # FIXME: Remove this line -mini_st.set_dimension(2); +mini_st.set_dimension(2) # initialize_filtration required before plain_homology mini_st.initialize_filtration() @@ -32,12 +33,12 @@ print("plain_homology(2)=", mini_st.plain_homology(2)) edge02 = [0, 2] if mini_st.find(edge02): - # Only coface is 012 - print("coface(edge02,1)=", mini_st.get_coface_tree(edge02, 1)) + # Only coface is 012 + print("coface(edge02,1)=", mini_st.get_coface_tree(edge02, 1)) if mini_st.get_coface_tree(triangle012, 1) == []: - # Precondition: Check the simplex has no coface before removing it. - mini_st.remove_maximal_simplex(triangle012) + # Precondition: Check the simplex has no coface before removing it. + mini_st.remove_maximal_simplex(triangle012) # initialize_filtration required after removing mini_st.initialize_filtration() diff --git a/src/cython/example/Rips_complex_example.py b/src/cython/example/Rips_complex_example.py index 4713b62b..6a39fc77 100755 --- a/src/cython/example/Rips_complex_example.py +++ b/src/cython/example/Rips_complex_example.py @@ -2,12 +2,14 @@ import gudhi -print("#######################################################################") +print("#####################################################################") print("RipsComplex creation from points") -rips = gudhi.RipsComplex(points=[[0,0],[1,0],[0,1],[1,1]],max_dimension=1,max_edge_length=42) +rips = gudhi.RipsComplex(points=[[0, 0], [1, 0], [0, 1], [1, 1]], + max_dimension=1, max_edge_length=42) print("filtered_tree=", rips.get_filtered_tree()) print("star([0])=", rips.get_star_tree([0])) -print("coface([0],1)=", rips.get_coface_tree([0], 1)) +print("coface([0], 1)=", rips.get_coface_tree([0], 1)) -print("persistence(2)=", rips.persistence(2)) +print("persistence(2)=", rips.persistence(homology_coeff_field=2, + min_persistence=0)) diff --git a/src/cython/example/Simplex_tree_example.py b/src/cython/example/Simplex_tree_example.py index fa40fbe6..e8585d83 100755 --- a/src/cython/example/Simplex_tree_example.py +++ b/src/cython/example/Simplex_tree_example.py @@ -4,22 +4,22 @@ import gudhi st = gudhi.SimplexTree() -print("#######################################################################") +print("#####################################################################") print("SimplexTree creation from insertion") -if st.insert([0,1]): - print("Inserted !!") +if st.insert([0, 1]): + print("Inserted !!") else: - print("Not inserted...") + print("Not inserted...") -if st.find([0,1]): - print("Found !!") +if st.find([0, 1]): + print("Found !!") else: - print("Not found...") + print("Not found...") -if st.insert([0,1,2], filtration=4.0): - print("Inserted !!") +if st.insert([0, 1, 2], filtration=4.0): + print("Inserted !!") else: - print("Not inserted...") + print("Not inserted...") # FIXME: Remove this line st.set_dimension(3) @@ -28,8 +28,8 @@ print("dimension=", st.dimension()) st.set_filtration(4.0) st.initialize_filtration() print("filtration=", st.get_filtration()) -print("filtration[1,2]=", st.filtration([1,2])) -print("filtration[4,2]=", st.filtration([4,2])) +print("filtration[1, 2]=", st.filtration([1, 2])) +print("filtration[4, 2]=", st.filtration([4, 2])) print("num_simplices=", st.num_simplices()) print("num_vertices=", st.num_vertices()) @@ -38,4 +38,5 @@ print("skeleton_tree[2]=", st.get_skeleton_tree(2)) print("skeleton_tree[1]=", st.get_skeleton_tree(1)) print("skeleton_tree[0]=", st.get_skeleton_tree(0)) -print("persistence(2)=", st.persistence(2)) +print("persistence(2)=", st.persistence(homology_coeff_field=2, + min_persistence=0)) diff --git a/src/cython/src/cpp/Persistent_cohomology_interface.h b/src/cython/src/cpp/Persistent_cohomology_interface.h index 74410333..adfca638 100644 --- a/src/cython/src/cpp/Persistent_cohomology_interface.h +++ b/src/cython/src/cpp/Persistent_cohomology_interface.h @@ -32,15 +32,11 @@ class Persistent_cohomology_interface : public persistent_cohomology::Persistent_cohomology<FilteredComplex,persistent_cohomology::Field_Zp> { public: Persistent_cohomology_interface(FilteredComplex* stptr) - : persistent_cohomology::Persistent_cohomology<FilteredComplex,persistent_cohomology::Field_Zp>(*stptr) { std::cout << "ctor" << std::endl; } + : persistent_cohomology::Persistent_cohomology<FilteredComplex,persistent_cohomology::Field_Zp>(*stptr) { } void get_persistence(int homology_coeff_field, double min_persistence) { - std::cout << "1" << std::endl; persistent_cohomology::Persistent_cohomology<FilteredComplex,persistent_cohomology::Field_Zp>::init_coefficients(homology_coeff_field); - std::cout << "2" << std::endl; persistent_cohomology::Persistent_cohomology<FilteredComplex,persistent_cohomology::Field_Zp>::compute_persistent_cohomology(min_persistence); - std::cout << "3" << std::endl; persistent_cohomology::Persistent_cohomology<FilteredComplex,persistent_cohomology::Field_Zp>::output_diagram(); - std::cout << "4" << std::endl; } }; diff --git a/src/cython/src/cython/Alpha_complex.pyx b/src/cython/src/cython/Alpha_complex.pyx index 8d08af42..a06134c8 100644 --- a/src/cython/src/cython/Alpha_complex.pyx +++ b/src/cython/src/cython/Alpha_complex.pyx @@ -1,3 +1,7 @@ +from cython cimport numeric +from libcpp.vector cimport vector +from libcpp.utility cimport pair + """This file is part of the Gudhi Library. The Gudhi library (Geometric Understanding in Higher Dimensions) is a generic C++ library for computational topology. @@ -17,19 +21,16 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>.""" + along with this program. If not, see <http://www.gnu.org/licenses/>. +""" -__author__ = "Vincent Rouvreau" -__copyright__ = "Copyright (C) 2016 INRIA Saclay (France)" -__license__ = "GPL v3" - -from cython cimport numeric -from libcpp.vector cimport vector -from libcpp.utility cimport pair +__author__ = "Vincent Rouvreau" +__copyright__ = "Copyright (C) 2016 INRIA Saclay (France)" +__license__ = "GPL v3" cdef extern from "Alpha_complex_interface.h" namespace "Gudhi": cdef cppclass Alpha_complex_interface "Gudhi::alphacomplex::Alpha_complex_interface": - Alpha_complex_interface(vector[vector[double]] points,double max_alpha_square) + Alpha_complex_interface(vector[vector[double]] points, double max_alpha_square) double filtration() double simplex_filtration(vector[int] simplex) void set_filtration(double filtration) @@ -39,103 +40,131 @@ cdef extern from "Alpha_complex_interface.h" namespace "Gudhi": void set_dimension(int dimension) int dimension() bint find_simplex(vector[int] simplex) - bint insert_simplex_and_subfaces(vector[int] simplex, double filtration) + bint insert_simplex_and_subfaces(vector[int] simplex, + double filtration) vector[pair[vector[int], double]] get_filtered_tree() vector[pair[vector[int], double]] get_skeleton_tree(int dimension) vector[pair[vector[int], double]] get_star_tree(vector[int] simplex) - vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, int dimension) + vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, + int dimension) void remove_maximal_simplex(vector[int] simplex) vector[double] get_point(int vertex) cdef extern from "Persistent_cohomology_interface.h" namespace "Gudhi": cdef cppclass Alpha_complex_persistence_interface "Gudhi::Persistent_cohomology_interface<Gudhi::alphacomplex::Alpha_complex< CGAL::Epick_d< CGAL::Dynamic_dimension_tag > >>": - Alpha_complex_persistence_interface(Alpha_complex_interface* st) + Alpha_complex_persistence_interface(Alpha_complex_interface * st) void get_persistence(int homology_coeff_field, double min_persistence) # AlphaComplex python interface cdef class AlphaComplex: - cdef Alpha_complex_interface *thisptr + cdef Alpha_complex_interface * thisptr + def __cinit__(self, points=None, max_alpha_square=float('inf')): if points is not None: - self.thisptr = new Alpha_complex_interface(points, max_alpha_square) + self.thisptr = new Alpha_complex_interface(points, + max_alpha_square) + def __dealloc__(self): if self.thisptr != NULL: del self.thisptr + def get_filtration(self): return self.thisptr.filtration() + def filtration(self, simplex): return self.thisptr.simplex_filtration(simplex) + def set_filtration(self, filtration): - self.thisptr.set_filtration(<double>filtration) + self.thisptr.set_filtration(<double> filtration) + def initialize_filtration(self): self.thisptr.initialize_filtration() + def num_vertices(self): return self.thisptr.num_vertices() + def num_simplices(self): return self.thisptr.num_simplices() + def dimension(self): return self.thisptr.dimension() + def set_dimension(self, dim): self.thisptr.set_dimension(<int>dim) + def find(self, simplex): cdef vector[int] complex for i in simplex: - complex.push_back(i) + complex.push_back(i) return self.thisptr.find_simplex(complex) - def insert(self, simplex, filtration = 0.0): + + def insert(self, simplex, filtration=0.0): cdef vector[int] complex for i in simplex: - complex.push_back(i) - return self.thisptr.insert_simplex_and_subfaces(complex, <double>filtration) + complex.push_back(i) + return self.thisptr.insert_simplex_and_subfaces(complex, + <double>filtration) + def get_filtered_tree(self): - cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_filtered_tree() + cdef vector[pair[vector[int], double]] coface_tree \ + = self.thisptr.get_filtered_tree() ct = [] for filtered_complex in coface_tree: v = [] for vertex in filtered_complex.first: v.append(vertex) - ct.append((v,filtered_complex.second)) + ct.append((v, filtered_complex.second)) return ct + def get_skeleton_tree(self, dim): - cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_skeleton_tree(<int>dim) + cdef vector[pair[vector[int], double]] coface_tree \ + = self.thisptr.get_skeleton_tree(<int>dim) ct = [] for filtered_complex in coface_tree: v = [] for vertex in filtered_complex.first: v.append(vertex) - ct.append((v,filtered_complex.second)) + ct.append((v, filtered_complex.second)) return ct + def get_star_tree(self, simplex): cdef vector[int] complex for i in simplex: - complex.push_back(i) - cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_star_tree(complex) + complex.push_back(i) + cdef vector[pair[vector[int], double]] coface_tree \ + = self.thisptr.get_star_tree(complex) ct = [] for filtered_complex in coface_tree: v = [] for vertex in filtered_complex.first: v.append(vertex) - ct.append((v,filtered_complex.second)) + ct.append((v, filtered_complex.second)) return ct + def get_coface_tree(self, simplex, dim): cdef vector[int] complex for i in simplex: - complex.push_back(i) - cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_coface_tree(complex, <int>dim) + complex.push_back(i) + cdef vector[pair[vector[int], double]] coface_tree \ + = self.thisptr.get_coface_tree(complex, <int>dim) ct = [] for filtered_complex in coface_tree: v = [] for vertex in filtered_complex.first: v.append(vertex) - ct.append((v,filtered_complex.second)) + ct.append((v, filtered_complex.second)) return ct + def remove_maximal_simplex(self, simplex): self.thisptr.remove_maximal_simplex(simplex) + def get_point(self, vertex): cdef vector[double] point = self.thisptr.get_point(vertex) return point - def persistence(self, homology_coeff_field, min_persistence = 0): - cdef Alpha_complex_persistence_interface *pcohptr = new Alpha_complex_persistence_interface(self.thisptr) + + def persistence(self, homology_coeff_field=11, min_persistence=0): + cdef Alpha_complex_persistence_interface * pcohptr \ + = new Alpha_complex_persistence_interface(self.thisptr) if pcohptr != NULL: pcohptr.get_persistence(homology_coeff_field, min_persistence) del pcohptr diff --git a/src/cython/src/cython/Mini_simplex_tree.pyx b/src/cython/src/cython/Mini_simplex_tree.pyx index b923b5b4..b836fb88 100644 --- a/src/cython/src/cython/Mini_simplex_tree.pyx +++ b/src/cython/src/cython/Mini_simplex_tree.pyx @@ -1,3 +1,7 @@ +from cython cimport numeric +from libcpp.vector cimport vector +from libcpp.utility cimport pair + """This file is part of the Gudhi Library. The Gudhi library (Geometric Understanding in Higher Dimensions) is a generic C++ library for computational topology. @@ -17,19 +21,17 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>.""" + along with this program. If not, see <http://www.gnu.org/licenses/>. +""" -__author__ = "Vincent Rouvreau" -__copyright__ = "Copyright (C) 2016 INRIA Saclay (France)" -__license__ = "GPL v3" - -from cython cimport numeric -from libcpp.vector cimport vector -from libcpp.utility cimport pair +__author__ = "Vincent Rouvreau" +__copyright__ = "Copyright (C) 2016 INRIA Saclay (France)" +__license__ = "GPL v3" cdef extern from "Simplex_tree_interface.h" namespace "Gudhi": cdef cppclass Simplex_tree_options_mini: pass + cdef cppclass Simplex_tree_interface_mini "Gudhi::Simplex_tree_interface<Gudhi::Simplex_tree_options_mini>": Simplex_tree() double filtration() @@ -41,99 +43,124 @@ cdef extern from "Simplex_tree_interface.h" namespace "Gudhi": void set_dimension(int dimension) int dimension() bint find_simplex(vector[int] simplex) - bint insert_simplex_and_subfaces(vector[int] simplex, double filtration) + bint insert_simplex_and_subfaces(vector[int] simplex, + double filtration) vector[pair[vector[int], double]] get_filtered_tree() vector[pair[vector[int], double]] get_skeleton_tree(int dimension) vector[pair[vector[int], double]] get_star_tree(vector[int] simplex) - vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, int dimension) - void graph_expansion(vector[vector[double]] points,int max_dimension,double max_edge_length) + vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, + int dimension) void remove_maximal_simplex(vector[int] simplex) cdef extern from "Persistent_cohomology_interface.h" namespace "Gudhi": cdef cppclass Mini_simplex_tree_persistence_interface "Gudhi::Persistent_cohomology_interface<Gudhi::Simplex_tree<Gudhi::Simplex_tree_options_mini>>": - Mini_simplex_tree_persistence_interface(Simplex_tree_interface_mini* st) + Mini_simplex_tree_persistence_interface(Simplex_tree_interface_mini * st) void get_persistence(int homology_coeff_field, double min_persistence) # MiniSimplexTree python interface cdef class MiniSimplexTree: - cdef Simplex_tree_interface_mini *thisptr + cdef Simplex_tree_interface_mini * thisptr + def __cinit__(self): self.thisptr = new Simplex_tree_interface_mini() + def __dealloc__(self): if self.thisptr != NULL: del self.thisptr + def get_filtration(self): return self.thisptr.filtration() + def filtration(self, simplex): return self.thisptr.simplex_filtration(simplex) + def set_filtration(self, filtration): - self.thisptr.set_filtration(<double>filtration) + self.thisptr.set_filtration(<double> filtration) + def initialize_filtration(self): self.thisptr.initialize_filtration() + def num_vertices(self): return self.thisptr.num_vertices() + def num_simplices(self): return self.thisptr.num_simplices() + def dimension(self): return self.thisptr.dimension() + def set_dimension(self, dim): self.thisptr.set_dimension(<int>dim) + def find(self, simplex): cdef vector[int] complex for i in simplex: - complex.push_back(i) + complex.push_back(i) return self.thisptr.find_simplex(complex) - def insert(self, simplex, filtration = 0.0): + + def insert(self, simplex, filtration=0.0): cdef vector[int] complex for i in simplex: - complex.push_back(i) - return self.thisptr.insert_simplex_and_subfaces(complex, <double>filtration) + complex.push_back(i) + return self.thisptr.insert_simplex_and_subfaces(complex, + <double>filtration) + def get_filtered_tree(self): - cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_filtered_tree() + cdef vector[pair[vector[int], double]] coface_tree \ + = self.thisptr.get_filtered_tree() ct = [] for filtered_complex in coface_tree: v = [] for vertex in filtered_complex.first: v.append(vertex) - ct.append((v,filtered_complex.second)) + ct.append((v, filtered_complex.second)) return ct + def get_skeleton_tree(self, dim): - cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_skeleton_tree(<int>dim) + cdef vector[pair[vector[int], double]] coface_tree \ + = self.thisptr.get_skeleton_tree(<int>dim) ct = [] for filtered_complex in coface_tree: v = [] for vertex in filtered_complex.first: v.append(vertex) - ct.append((v,filtered_complex.second)) + ct.append((v, filtered_complex.second)) return ct + def get_star_tree(self, simplex): cdef vector[int] complex for i in simplex: - complex.push_back(i) - cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_star_tree(complex) + complex.push_back(i) + cdef vector[pair[vector[int], double]] coface_tree \ + = self.thisptr.get_star_tree(complex) ct = [] for filtered_complex in coface_tree: v = [] for vertex in filtered_complex.first: v.append(vertex) - ct.append((v,filtered_complex.second)) + ct.append((v, filtered_complex.second)) return ct + def get_coface_tree(self, simplex, dim): cdef vector[int] complex for i in simplex: - complex.push_back(i) - cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_coface_tree(complex, <int>dim) + complex.push_back(i) + cdef vector[pair[vector[int], double]] coface_tree \ + = self.thisptr.get_coface_tree(complex, <int>dim) ct = [] for filtered_complex in coface_tree: v = [] for vertex in filtered_complex.first: v.append(vertex) - ct.append((v,filtered_complex.second)) + ct.append((v, filtered_complex.second)) return ct + def remove_maximal_simplex(self, simplex): self.thisptr.remove_maximal_simplex(simplex) - def plain_homology(self, homology_coeff_field): - cdef Mini_simplex_tree_persistence_interface *pcohptr = new Mini_simplex_tree_persistence_interface(self.thisptr) + + def plain_homology(self, homology_coeff_field=11): + cdef Mini_simplex_tree_persistence_interface * pcohptr \ + = new Mini_simplex_tree_persistence_interface(self.thisptr) if pcohptr != NULL: pcohptr.get_persistence(homology_coeff_field, 0) del pcohptr diff --git a/src/cython/src/cython/Rips_complex.pyx b/src/cython/src/cython/Rips_complex.pyx index e722e483..3ca890d9 100644 --- a/src/cython/src/cython/Rips_complex.pyx +++ b/src/cython/src/cython/Rips_complex.pyx @@ -1,3 +1,7 @@ +from cython cimport numeric +from libcpp.vector cimport vector +from libcpp.utility cimport pair + """This file is part of the Gudhi Library. The Gudhi library (Geometric Understanding in Higher Dimensions) is a generic C++ library for computational topology. @@ -17,19 +21,17 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>.""" + along with this program. If not, see <http://www.gnu.org/licenses/>. +""" -__author__ = "Vincent Rouvreau" -__copyright__ = "Copyright (C) 2016 INRIA Saclay (France)" -__license__ = "GPL v3" - -from cython cimport numeric -from libcpp.vector cimport vector -from libcpp.utility cimport pair +__author__ = "Vincent Rouvreau" +__copyright__ = "Copyright (C) 2016 INRIA Saclay (France)" +__license__ = "GPL v3" cdef extern from "Simplex_tree_interface.h" namespace "Gudhi": cdef cppclass Simplex_tree_options_full_featured: pass + cdef cppclass Rips_complex_interface "Gudhi::Simplex_tree_interface<Gudhi::Simplex_tree_options_full_featured>": Simplex_tree() double filtration() @@ -41,102 +43,131 @@ cdef extern from "Simplex_tree_interface.h" namespace "Gudhi": void set_dimension(int dimension) int dimension() bint find_simplex(vector[int] simplex) - bint insert_simplex_and_subfaces(vector[int] simplex, double filtration) + bint insert_simplex_and_subfaces(vector[int] simplex, + double filtration) vector[pair[vector[int], double]] get_filtered_tree() vector[pair[vector[int], double]] get_skeleton_tree(int dimension) vector[pair[vector[int], double]] get_star_tree(vector[int] simplex) - vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, int dimension) + vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, + int dimension) void remove_maximal_simplex(vector[int] simplex) - void graph_expansion(vector[vector[double]] points,int max_dimension,double max_edge_length) + void graph_expansion(vector[vector[double]] points, int max_dimension, + double max_edge_length) cdef extern from "Persistent_cohomology_interface.h" namespace "Gudhi": cdef cppclass Rips_complex_persistence_interface "Gudhi::Persistent_cohomology_interface<Gudhi::Simplex_tree<Gudhi::Simplex_tree_options_full_featured>>": - Rips_complex_persistence_interface(Rips_complex_interface* st) + Rips_complex_persistence_interface(Rips_complex_interface * st) void get_persistence(int homology_coeff_field, double min_persistence) # RipsComplex python interface cdef class RipsComplex: - cdef Rips_complex_interface *thisptr - def __cinit__(self, points=None, max_dimension=3, max_edge_length=float('inf')): + cdef Rips_complex_interface * thisptr + + def __cinit__(self, points=None, max_dimension=3, + max_edge_length=float('inf')): self.thisptr = new Rips_complex_interface() # Constructor from graph expansion if points is not None: - self.thisptr.graph_expansion(points,max_dimension,max_edge_length) + self.thisptr.graph_expansion(points, max_dimension, + max_edge_length) + def __dealloc__(self): if self.thisptr != NULL: del self.thisptr + def get_filtration(self): return self.thisptr.filtration() + def filtration(self, simplex): return self.thisptr.simplex_filtration(simplex) + def set_filtration(self, filtration): - self.thisptr.set_filtration(<double>filtration) + self.thisptr.set_filtration(<double> filtration) + def initialize_filtration(self): self.thisptr.initialize_filtration() + def num_vertices(self): return self.thisptr.num_vertices() + def num_simplices(self): return self.thisptr.num_simplices() + def dimension(self): return self.thisptr.dimension() + def set_dimension(self, dim): self.thisptr.set_dimension(<int>dim) + def find(self, simplex): cdef vector[int] complex for i in simplex: - complex.push_back(i) + complex.push_back(i) return self.thisptr.find_simplex(complex) - def insert(self, simplex, filtration = 0.0): + + def insert(self, simplex, filtration=0.0): cdef vector[int] complex for i in simplex: - complex.push_back(i) - return self.thisptr.insert_simplex_and_subfaces(complex, <double>filtration) + complex.push_back(i) + return self.thisptr.insert_simplex_and_subfaces(complex, + <double>filtration) + def get_filtered_tree(self): - cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_filtered_tree() + cdef vector[pair[vector[int], double]] coface_tree \ + = self.thisptr.get_filtered_tree() ct = [] for filtered_complex in coface_tree: v = [] for vertex in filtered_complex.first: v.append(vertex) - ct.append((v,filtered_complex.second)) + ct.append((v, filtered_complex.second)) return ct + def get_skeleton_tree(self, dim): - cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_skeleton_tree(<int>dim) + cdef vector[pair[vector[int], double]] coface_tree \ + = self.thisptr.get_skeleton_tree(<int>dim) ct = [] for filtered_complex in coface_tree: v = [] for vertex in filtered_complex.first: v.append(vertex) - ct.append((v,filtered_complex.second)) + ct.append((v, filtered_complex.second)) return ct + def get_star_tree(self, simplex): cdef vector[int] complex for i in simplex: - complex.push_back(i) - cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_star_tree(complex) + complex.push_back(i) + cdef vector[pair[vector[int], double]] coface_tree \ + = self.thisptr.get_star_tree(complex) ct = [] for filtered_complex in coface_tree: v = [] for vertex in filtered_complex.first: v.append(vertex) - ct.append((v,filtered_complex.second)) + ct.append((v, filtered_complex.second)) return ct + def get_coface_tree(self, simplex, dim): cdef vector[int] complex for i in simplex: - complex.push_back(i) - cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_coface_tree(complex, <int>dim) + complex.push_back(i) + cdef vector[pair[vector[int], double]] coface_tree \ + = self.thisptr.get_coface_tree(complex, <int>dim) ct = [] for filtered_complex in coface_tree: v = [] for vertex in filtered_complex.first: v.append(vertex) - ct.append((v,filtered_complex.second)) + ct.append((v, filtered_complex.second)) return ct + def remove_maximal_simplex(self, simplex): self.thisptr.remove_maximal_simplex(simplex) - def persistence(self, homology_coeff_field, min_persistence = 0): - cdef Rips_complex_persistence_interface *pcohptr = new Rips_complex_persistence_interface(self.thisptr) + + def persistence(self, homology_coeff_field=11, min_persistence=0): + cdef Rips_complex_persistence_interface * pcohptr \ + = new Rips_complex_persistence_interface(self.thisptr) if pcohptr != NULL: pcohptr.get_persistence(homology_coeff_field, min_persistence) del pcohptr diff --git a/src/cython/src/cython/Simplex_tree.pyx b/src/cython/src/cython/Simplex_tree.pyx index 1543f792..e3cdc27b 100644 --- a/src/cython/src/cython/Simplex_tree.pyx +++ b/src/cython/src/cython/Simplex_tree.pyx @@ -1,3 +1,7 @@ +from cython cimport numeric +from libcpp.vector cimport vector +from libcpp.utility cimport pair + """This file is part of the Gudhi Library. The Gudhi library (Geometric Understanding in Higher Dimensions) is a generic C++ library for computational topology. @@ -17,19 +21,17 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>.""" + along with this program. If not, see <http://www.gnu.org/licenses/>. +""" -__author__ = "Vincent Rouvreau" -__copyright__ = "Copyright (C) 2016 INRIA Saclay (France)" -__license__ = "GPL v3" - -from cython cimport numeric -from libcpp.vector cimport vector -from libcpp.utility cimport pair +__author__ = "Vincent Rouvreau" +__copyright__ = "Copyright (C) 2016 INRIA Saclay (France)" +__license__ = "GPL v3" cdef extern from "Simplex_tree_interface.h" namespace "Gudhi": cdef cppclass Simplex_tree_options_full_featured: pass + cdef cppclass Simplex_tree_interface_full_featured "Gudhi::Simplex_tree_interface<Gudhi::Simplex_tree_options_full_featured>": Simplex_tree() double filtration() @@ -41,98 +43,124 @@ cdef extern from "Simplex_tree_interface.h" namespace "Gudhi": void set_dimension(int dimension) int dimension() bint find_simplex(vector[int] simplex) - bint insert_simplex_and_subfaces(vector[int] simplex, double filtration) + bint insert_simplex_and_subfaces(vector[int] simplex, + double filtration) vector[pair[vector[int], double]] get_filtered_tree() vector[pair[vector[int], double]] get_skeleton_tree(int dimension) vector[pair[vector[int], double]] get_star_tree(vector[int] simplex) - vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, int dimension) + vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, + int dimension) void remove_maximal_simplex(vector[int] simplex) cdef extern from "Persistent_cohomology_interface.h" namespace "Gudhi": cdef cppclass Simplex_tree_persistence_interface "Gudhi::Persistent_cohomology_interface<Gudhi::Simplex_tree<Gudhi::Simplex_tree_options_full_featured>>": - Simplex_tree_persistence_interface(Simplex_tree_interface_full_featured* st) + Simplex_tree_persistence_interface(Simplex_tree_interface_full_featured * st) void get_persistence(int homology_coeff_field, double min_persistence) # SimplexTree python interface cdef class SimplexTree: - cdef Simplex_tree_interface_full_featured *thisptr + cdef Simplex_tree_interface_full_featured * thisptr + def __cinit__(self): self.thisptr = new Simplex_tree_interface_full_featured() + def __dealloc__(self): if self.thisptr != NULL: del self.thisptr + def get_filtration(self): return self.thisptr.filtration() + def filtration(self, simplex): return self.thisptr.simplex_filtration(simplex) + def set_filtration(self, filtration): - self.thisptr.set_filtration(<double>filtration) + self.thisptr.set_filtration(<double> filtration) + def initialize_filtration(self): self.thisptr.initialize_filtration() + def num_vertices(self): return self.thisptr.num_vertices() + def num_simplices(self): return self.thisptr.num_simplices() + def dimension(self): return self.thisptr.dimension() + def set_dimension(self, dim): self.thisptr.set_dimension(<int>dim) + def find(self, simplex): cdef vector[int] complex for i in simplex: - complex.push_back(i) + complex.push_back(i) return self.thisptr.find_simplex(complex) - def insert(self, simplex, filtration = 0.0): + + def insert(self, simplex, filtration=0.0): cdef vector[int] complex for i in simplex: - complex.push_back(i) - return self.thisptr.insert_simplex_and_subfaces(complex, <double>filtration) + complex.push_back(i) + return self.thisptr.insert_simplex_and_subfaces(complex, + <double>filtration) + def get_filtered_tree(self): - cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_filtered_tree() + cdef vector[pair[vector[int], double]] coface_tree \ + = self.thisptr.get_filtered_tree() ct = [] for filtered_complex in coface_tree: v = [] for vertex in filtered_complex.first: v.append(vertex) - ct.append((v,filtered_complex.second)) + ct.append((v, filtered_complex.second)) return ct + def get_skeleton_tree(self, dim): - cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_skeleton_tree(<int>dim) + cdef vector[pair[vector[int], double]] coface_tree \ + = self.thisptr.get_skeleton_tree(<int>dim) ct = [] for filtered_complex in coface_tree: v = [] for vertex in filtered_complex.first: v.append(vertex) - ct.append((v,filtered_complex.second)) + ct.append((v, filtered_complex.second)) return ct + def get_star_tree(self, simplex): cdef vector[int] complex for i in simplex: - complex.push_back(i) - cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_star_tree(complex) + complex.push_back(i) + cdef vector[pair[vector[int], double]] coface_tree \ + = self.thisptr.get_star_tree(complex) ct = [] for filtered_complex in coface_tree: v = [] for vertex in filtered_complex.first: v.append(vertex) - ct.append((v,filtered_complex.second)) + ct.append((v, filtered_complex.second)) return ct + def get_coface_tree(self, simplex, dim): cdef vector[int] complex for i in simplex: - complex.push_back(i) - cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_coface_tree(complex, <int>dim) + complex.push_back(i) + cdef vector[pair[vector[int], double]] coface_tree \ + = self.thisptr.get_coface_tree(complex, <int>dim) ct = [] for filtered_complex in coface_tree: v = [] for vertex in filtered_complex.first: v.append(vertex) - ct.append((v,filtered_complex.second)) + ct.append((v, filtered_complex.second)) return ct + def remove_maximal_simplex(self, simplex): self.thisptr.remove_maximal_simplex(simplex) - def persistence(self, homology_coeff_field, min_persistence = 0): - cdef Simplex_tree_persistence_interface *pcohptr = new Simplex_tree_persistence_interface(self.thisptr) + + def persistence(self, homology_coeff_field=11, min_persistence=0): + cdef Simplex_tree_persistence_interface * pcohptr \ + = new Simplex_tree_persistence_interface(self.thisptr) if pcohptr != NULL: pcohptr.get_persistence(homology_coeff_field, min_persistence) del pcohptr diff --git a/src/cython/test/Alpha_complex_UT.py b/src/cython/test/Alpha_complex_UT.py index 96331991..c14c43e2 100755 --- a/src/cython/test/Alpha_complex_UT.py +++ b/src/cython/test/Alpha_complex_UT.py @@ -2,43 +2,57 @@ import unittest import gudhi -class TestAlphaComplex(unittest.TestCase): - - def test_infinite_alpha(self): - point_list=[[0,0],[1,0],[0,1],[1,1]] - alpha_complex = gudhi.AlphaComplex(points=point_list) - - self.assertEqual(alpha_complex.num_simplices(), 11) - self.assertEqual(alpha_complex.num_vertices(), 4) - - self.assertEqual(alpha_complex.get_filtered_tree(), [([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)]) - self.assertEqual(alpha_complex.get_star_tree([0]), [([0], 0.0), ([0, 1], 0.25), ([0, 1, 2], 0.5), ([0, 2], 0.25)]) - self.assertEqual(alpha_complex.get_coface_tree([0], 1), [([0, 1], 0.25), ([0, 2], 0.25)]) - self.assertEqual(point_list[0], alpha_complex.get_point(0)) - self.assertEqual(point_list[1], alpha_complex.get_point(1)) - self.assertEqual(point_list[2], alpha_complex.get_point(2)) - self.assertEqual(point_list[3], alpha_complex.get_point(3)) - self.assertEqual([], alpha_complex.get_point(4)) - self.assertEqual([], alpha_complex.get_point(125)) - - def test_filtered_alpha(self): - point_list=[[0,0],[1,0],[0,1],[1,1]] - filtered_alpha = gudhi.AlphaComplex(points=point_list,max_alpha_square=0.25) - - self.assertEqual(filtered_alpha.num_simplices(), 8) - self.assertEqual(filtered_alpha.num_vertices(), 4) - - self.assertEqual(point_list[0], filtered_alpha.get_point(0)) - self.assertEqual(point_list[1], filtered_alpha.get_point(1)) - self.assertEqual(point_list[2], filtered_alpha.get_point(2)) - self.assertEqual(point_list[3], filtered_alpha.get_point(3)) - self.assertEqual([], filtered_alpha.get_point(4)) - self.assertEqual([], filtered_alpha.get_point(125)) +class TestAlphaComplex(unittest.TestCase): - self.assertEqual(filtered_alpha.get_filtered_tree(), [([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)]) - self.assertEqual(filtered_alpha.get_star_tree([0]), [([0], 0.0), ([0, 1], 0.25), ([0, 2], 0.25)]) - self.assertEqual(filtered_alpha.get_coface_tree([0], 1), [([0, 1], 0.25), ([0, 2], 0.25)]) + def test_infinite_alpha(self): + point_list = [[0, 0], [1, 0], [0, 1], [1, 1]] + alpha_complex = gudhi.AlphaComplex(points=point_list) + + self.assertEqual(alpha_complex.num_simplices(), 11) + self.assertEqual(alpha_complex.num_vertices(), 4) + + self.assertEqual(alpha_complex.get_filtered_tree(), + [([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)]) + self.assertEqual(alpha_complex.get_star_tree([0]), + [([0], 0.0), ([0, 1], 0.25), ([0, 1, 2], 0.5), + ([0, 2], 0.25)]) + self.assertEqual(alpha_complex.get_coface_tree([0], 1), + [([0, 1], 0.25), ([0, 2], 0.25)]) + + self.assertEqual(point_list[0], alpha_complex.get_point(0)) + self.assertEqual(point_list[1], alpha_complex.get_point(1)) + self.assertEqual(point_list[2], alpha_complex.get_point(2)) + self.assertEqual(point_list[3], alpha_complex.get_point(3)) + self.assertEqual([], alpha_complex.get_point(4)) + self.assertEqual([], alpha_complex.get_point(125)) + + def test_filtered_alpha(self): + point_list = [[0, 0], [1, 0], [0, 1], [1, 1]] + filtered_alpha = gudhi.AlphaComplex(points=point_list, + max_alpha_square=0.25) + + self.assertEqual(filtered_alpha.num_simplices(), 8) + self.assertEqual(filtered_alpha.num_vertices(), 4) + + self.assertEqual(point_list[0], filtered_alpha.get_point(0)) + self.assertEqual(point_list[1], filtered_alpha.get_point(1)) + self.assertEqual(point_list[2], filtered_alpha.get_point(2)) + self.assertEqual(point_list[3], filtered_alpha.get_point(3)) + self.assertEqual([], filtered_alpha.get_point(4)) + self.assertEqual([], filtered_alpha.get_point(125)) + + self.assertEqual(filtered_alpha.get_filtered_tree(), + [([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)]) + self.assertEqual(filtered_alpha.get_star_tree([0]), + [([0], 0.0), ([0, 1], 0.25), ([0, 2], 0.25)]) + self.assertEqual(filtered_alpha.get_coface_tree([0], 1), + [([0, 1], 0.25), ([0, 2], 0.25)]) if __name__ == '__main__': - unittest.main()
\ No newline at end of file + unittest.main() diff --git a/src/cython/test/Mini_simplex_tree_UT.py b/src/cython/test/Mini_simplex_tree_UT.py index 0d2ce3c3..8f2f56df 100755 --- a/src/cython/test/Mini_simplex_tree_UT.py +++ b/src/cython/test/Mini_simplex_tree_UT.py @@ -2,26 +2,28 @@ import unittest import gudhi + class TestMiniSimplexTree(unittest.TestCase): - def test_mini(self): - triangle012 = [0,1,2] - edge03 = [0,3] - mini_st = gudhi.MiniSimplexTree() - self.assertTrue(mini_st.insert(triangle012)) - self.assertTrue(mini_st.insert(edge03)) - # FIXME: Remove this line - mini_st.set_dimension(2); + def test_mini(self): + triangle012 = [0, 1, 2] + edge03 = [0, 3] + mini_st = gudhi.MiniSimplexTree() + self.assertTrue(mini_st.insert(triangle012)) + self.assertTrue(mini_st.insert(edge03)) + # FIXME: Remove this line + mini_st.set_dimension(2) - edge02 = [0,2] - self.assertTrue(mini_st.find(edge02)) - self.assertEqual(mini_st.get_coface_tree(edge02, 1), [([0, 1, 2], 0.0)]) + edge02 = [0, 2] + self.assertTrue(mini_st.find(edge02)) + self.assertEqual(mini_st.get_coface_tree(edge02, 1), + [([0, 1, 2], 0.0)]) - # remove_maximal_simplex test - self.assertEqual(mini_st.get_coface_tree(triangle012, 1), []) - mini_st.remove_maximal_simplex(triangle012) - self.assertTrue(mini_st.find(edge02)) - self.assertFalse(mini_st.find(triangle012)) + # remove_maximal_simplex test + self.assertEqual(mini_st.get_coface_tree(triangle012, 1), []) + mini_st.remove_maximal_simplex(triangle012) + self.assertTrue(mini_st.find(edge02)) + self.assertFalse(mini_st.find(triangle012)) if __name__ == '__main__': - unittest.main()
\ No newline at end of file + unittest.main() diff --git a/src/cython/test/Rips_complex_UT.py b/src/cython/test/Rips_complex_UT.py index d27e180c..ccff5c2d 100755 --- a/src/cython/test/Rips_complex_UT.py +++ b/src/cython/test/Rips_complex_UT.py @@ -2,23 +2,34 @@ import unittest import gudhi + class TestRipsComplex(unittest.TestCase): - def test_rips(self): - point_list=[[0,0],[1,0],[0,1],[1,1]] - rips_complex = gudhi.RipsComplex(points=point_list,max_dimension=1,max_edge_length=42) + def test_rips(self): + point_list = [[0, 0], [1, 0], [0, 1], [1, 1]] + rips_complex = gudhi.RipsComplex(points=point_list, max_dimension=1, + max_edge_length=42) - self.assertEqual(rips_complex.num_simplices(), 10) - self.assertEqual(rips_complex.num_vertices(), 4) + self.assertEqual(rips_complex.num_simplices(), 10) + self.assertEqual(rips_complex.num_vertices(), 4) - self.assertEqual(rips_complex.get_filtered_tree(), [([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)]) - self.assertEqual(rips_complex.get_star_tree([0]), [([0], 0.0), ([0, 1], 1.0), ([0, 2], 1.0), ([0, 3], 1.4142135623730951)]) - self.assertEqual(rips_complex.get_coface_tree([0], 1), [([0, 1], 1.0), ([0, 2], 1.0), ([0, 3], 1.4142135623730951)]) + self.assertEqual(rips_complex.get_filtered_tree(), + [([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)]) + self.assertEqual(rips_complex.get_star_tree([0]), + [([0], 0.0), ([0, 1], 1.0), ([0, 2], 1.0), + ([0, 3], 1.4142135623730951)]) + self.assertEqual(rips_complex.get_coface_tree([0], 1), + [([0, 1], 1.0), ([0, 2], 1.0), + ([0, 3], 1.4142135623730951)]) - filtered_rips = gudhi.RipsComplex(points=point_list,max_dimension=1,max_edge_length=1.0) + filtered_rips = gudhi.RipsComplex(points=point_list, max_dimension=1, + max_edge_length=1.0) - self.assertEqual(filtered_rips.num_simplices(), 8) - self.assertEqual(filtered_rips.num_vertices(), 4) + self.assertEqual(filtered_rips.num_simplices(), 8) + self.assertEqual(filtered_rips.num_vertices(), 4) if __name__ == '__main__': - unittest.main()
\ No newline at end of file + unittest.main() diff --git a/src/cython/test/Simplex_tree_UT.py b/src/cython/test/Simplex_tree_UT.py index b3ded581..392c6d71 100755 --- a/src/cython/test/Simplex_tree_UT.py +++ b/src/cython/test/Simplex_tree_UT.py @@ -2,56 +2,64 @@ import unittest import gudhi + class TestSimplexTree(unittest.TestCase): - def test_insertion(self): - st = gudhi.SimplexTree() - - # insert test - self.assertTrue(st.insert([0,1])) - self.assertTrue(st.insert([0,1,2], filtration=4.0)) - self.assertEqual(st.num_simplices(), 7) - self.assertEqual(st.num_vertices(), 3) - - # find test - self.assertTrue(st.find([0,1,2])) - self.assertTrue(st.find([0,1])) - self.assertTrue(st.find([0,2])) - self.assertTrue(st.find([0])) - self.assertTrue(st.find([1])) - self.assertTrue(st.find([2])) - self.assertFalse(st.find([3])) - self.assertFalse(st.find([0,3])) - self.assertFalse(st.find([1,3])) - self.assertFalse(st.find([2,3])) - - # filtration test - st.set_filtration(5.0) - st.initialize_filtration() - self.assertEqual(st.get_filtration(), 5.0) - self.assertEqual(st.filtration([0,1,2]), 4.0) - self.assertEqual(st.filtration([0,2]), 4.0) - self.assertEqual(st.filtration([1,2]), 4.0) - self.assertEqual(st.filtration([2]), 4.0) - self.assertEqual(st.filtration([0,1]), 0.0) - self.assertEqual(st.filtration([0]), 0.0) - self.assertEqual(st.filtration([1]), 0.0) - - # skeleton_tree test - self.assertEqual(st.get_skeleton_tree(2), [([0, 1, 2], 4.0), ([0, 1], 0.0), ([0, 2], 4.0), ([0], 0.0), ([1, 2], 4.0), ([1], 0.0), ([2], 4.0)]) - self.assertEqual(st.get_skeleton_tree(1), [([0, 1], 0.0), ([0, 2], 4.0), ([0], 0.0), ([1, 2], 4.0), ([1], 0.0), ([2], 4.0)]) - self.assertEqual(st.get_skeleton_tree(0), [([0], 0.0), ([1], 0.0), ([2], 4.0)]) - - # remove_maximal_simplex test - self.assertEqual(st.get_coface_tree([0,1,2], 1), []) - st.remove_maximal_simplex([0,1,2]) - self.assertEqual(st.get_skeleton_tree(2), [([0, 1], 0.0), ([0, 2], 4.0), ([0], 0.0), ([1, 2], 4.0), ([1], 0.0), ([2], 4.0)]) - self.assertFalse(st.find([0,1,2])) - self.assertTrue(st.find([0,1])) - self.assertTrue(st.find([0,2])) - self.assertTrue(st.find([0])) - self.assertTrue(st.find([1])) - self.assertTrue(st.find([2])) + def test_insertion(self): + st = gudhi.SimplexTree() + + # insert test + self.assertTrue(st.insert([0, 1])) + self.assertTrue(st.insert([0, 1, 2], filtration=4.0)) + self.assertEqual(st.num_simplices(), 7) + self.assertEqual(st.num_vertices(), 3) + + # find test + self.assertTrue(st.find([0, 1, 2])) + self.assertTrue(st.find([0, 1])) + self.assertTrue(st.find([0, 2])) + self.assertTrue(st.find([0])) + self.assertTrue(st.find([1])) + self.assertTrue(st.find([2])) + self.assertFalse(st.find([3])) + self.assertFalse(st.find([0, 3])) + self.assertFalse(st.find([1, 3])) + self.assertFalse(st.find([2, 3])) + + # filtration test + st.set_filtration(5.0) + st.initialize_filtration() + self.assertEqual(st.get_filtration(), 5.0) + self.assertEqual(st.filtration([0, 1, 2]), 4.0) + self.assertEqual(st.filtration([0, 2]), 4.0) + self.assertEqual(st.filtration([1, 2]), 4.0) + self.assertEqual(st.filtration([2]), 4.0) + self.assertEqual(st.filtration([0, 1]), 0.0) + self.assertEqual(st.filtration([0]), 0.0) + self.assertEqual(st.filtration([1]), 0.0) + + # skeleton_tree test + self.assertEqual(st.get_skeleton_tree(2), + [([0, 1, 2], 4.0), ([0, 1], 0.0), ([0, 2], 4.0), + ([0], 0.0), ([1, 2], 4.0), ([1], 0.0), ([2], 4.0)]) + self.assertEqual(st.get_skeleton_tree(1), + [([0, 1], 0.0), ([0, 2], 4.0), ([0], 0.0), + ([1, 2], 4.0), ([1], 0.0), ([2], 4.0)]) + self.assertEqual(st.get_skeleton_tree(0), + [([0], 0.0), ([1], 0.0), ([2], 4.0)]) + + # remove_maximal_simplex test + self.assertEqual(st.get_coface_tree([0, 1, 2], 1), []) + st.remove_maximal_simplex([0, 1, 2]) + self.assertEqual(st.get_skeleton_tree(2), + [([0, 1], 0.0), ([0, 2], 4.0), ([0], 0.0), + ([1, 2], 4.0), ([1], 0.0), ([2], 4.0)]) + self.assertFalse(st.find([0, 1, 2])) + self.assertTrue(st.find([0, 1])) + self.assertTrue(st.find([0, 2])) + self.assertTrue(st.find([0])) + self.assertTrue(st.find([1])) + self.assertTrue(st.find([2])) if __name__ == '__main__': - unittest.main()
\ No newline at end of file + unittest.main() |