Separate Mini_simplex_tree from Simplex_tree

persistence function for everybody


git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/branches/ST_cythonize@1181 636b058d-ea47-450e-bf9e-a15bfbe3eedb

Former-commit-id: db3a6446593acd319d15315f63eb9568447db9da

14 files changed, 258 insertions, 154 deletions

diff --git a/src/cython/Makefile b/src/cython/Makefile
index 530b33c1..c90135b8 100644
--- a/src/cython/Makefile
+++ b/src/cython/Makefile
@@ -3,11 +3,13 @@ ext:
 
 test:
 	python test/Simplex_tree_UT.py
+	python test/Mini_simplex_tree_UT.py
 	python test/Rips_complex_UT.py
 	python test/Alpha_complex_UT.py
 
 example:
 	python example/Simplex_tree_example.py
+	python example/Mini_simplex_tree_example.py
 	python example/Rips_complex_example.py
 	python example/Alpha_complex_example.py
 
diff --git a/src/cython/example/Alpha_complex_example.py b/src/cython/example/Alpha_complex_example.py
index da55bfd4..cf5eed55 100755
--- a/src/cython/example/Alpha_complex_example.py
+++ b/src/cython/example/Alpha_complex_example.py
@@ -39,4 +39,7 @@ 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("#######################################################################")
diff --git a/src/cython/example/Mini_simplex_tree_example.py b/src/cython/example/Mini_simplex_tree_example.py
new file mode 100755
index 00000000..87407317
--- /dev/null
+++ b/src/cython/example/Mini_simplex_tree_example.py
@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+
+import gudhi
+
+print("#######################################################################")
+print("MiniSimplexTree creation from insertion")
+
+""" Complex to build.
+     1   3
+     o---o
+    /X\ /
+   o---o   o
+   2   0   4 """
+
+triangle012 = [0, 1, 2]
+edge03 = [0, 3]
+edge13 = [1, 3]
+vertex4 = [4]
+mini_st = gudhi.MiniSimplexTree()
+mini_st.insert(triangle012)
+mini_st.insert(edge03)
+mini_st.insert(edge13)
+mini_st.insert(vertex4)
+
+# FIXME: Remove this line
+mini_st.set_dimension(2);
+
+# initialize_filtration required before plain_homology
+mini_st.initialize_filtration()
+
+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))
+
+if mini_st.get_coface_tree(triangle012, 1) == []:
+  # 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()
+
+print("filtered_tree after triangle012 removal =", mini_st.get_filtered_tree())
diff --git a/src/cython/example/Rips_complex_example.py b/src/cython/example/Rips_complex_example.py
index 0e8a0968..4713b62b 100755
--- a/src/cython/example/Rips_complex_example.py
+++ b/src/cython/example/Rips_complex_example.py
@@ -9,3 +9,5 @@ rips = gudhi.RipsComplex(points=[[0,0],[1,0],[0,1],[1,1]],max_dimension=1,max_ed
 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("persistence(2)=", rips.persistence(2))
diff --git a/src/cython/example/Simplex_tree_example.py b/src/cython/example/Simplex_tree_example.py
index 90a4a433..fa40fbe6 100755
--- a/src/cython/example/Simplex_tree_example.py
+++ b/src/cython/example/Simplex_tree_example.py
@@ -39,24 +39,3 @@ 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("#######################################################################")
-print("MiniSimplexTree creation from insertion")
-triangle012 = [0, 1, 2]
-edge03 = [0, 3]
-mini_st = gudhi.MiniSimplexTree()
-mini_st.insert(triangle012)
-mini_st.insert(edge03)
-# FIXME: Remove this line
-mini_st.set_dimension(2);
-
-edge02 = [0, 2]
-if mini_st.find(edge02):
-  # 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)
-
-print("filtered_tree after triangle012 removal =", mini_st.get_filtered_tree())
diff --git a/src/cython/gudhi.pyx b/src/cython/gudhi.pyx
index f79ecbe4..8fcc081a 100644
--- a/src/cython/gudhi.pyx
+++ b/src/cython/gudhi.pyx
@@ -1,3 +1,4 @@
 include "src/cython/Simplex_tree.pyx"
+include "src/cython/Mini_simplex_tree.pyx"
 include "src/cython/Rips_complex.pyx"
 include "src/cython/Alpha_complex.pyx"
diff --git a/src/cython/src/cpp/Persistent_cohomology_interface.h b/src/cython/src/cpp/Persistent_cohomology_interface.h
index 79c6ce06..74410333 100644
--- a/src/cython/src/cpp/Persistent_cohomology_interface.h
+++ b/src/cython/src/cpp/Persistent_cohomology_interface.h
@@ -27,17 +27,22 @@
 
 namespace Gudhi {
 
-template<typename SimplexTreeOptions = Simplex_tree_options_full_featured>
+template<class FilteredComplex>
 class Persistent_cohomology_interface : public
-persistent_cohomology::Persistent_cohomology<Simplex_tree<SimplexTreeOptions>,persistent_cohomology::Field_Zp> {
+persistent_cohomology::Persistent_cohomology<FilteredComplex,persistent_cohomology::Field_Zp> {
  public:
-  Persistent_cohomology_interface(Simplex_tree<SimplexTreeOptions>* stptr)
-  : persistent_cohomology::Persistent_cohomology<Simplex_tree<SimplexTreeOptions>,persistent_cohomology::Field_Zp>(*stptr) { }
+  Persistent_cohomology_interface(FilteredComplex* stptr)
+  : persistent_cohomology::Persistent_cohomology<FilteredComplex,persistent_cohomology::Field_Zp>(*stptr) { std::cout << "ctor" << std::endl; }
   void get_persistence(int homology_coeff_field, double min_persistence) {
-    persistent_cohomology::Persistent_cohomology<Simplex_tree<SimplexTreeOptions>,persistent_cohomology::Field_Zp>::init_coefficients(homology_coeff_field);
-    persistent_cohomology::Persistent_cohomology<Simplex_tree<SimplexTreeOptions>,persistent_cohomology::Field_Zp>::compute_persistent_cohomology(min_persistence);
-    persistent_cohomology::Persistent_cohomology<Simplex_tree<SimplexTreeOptions>,persistent_cohomology::Field_Zp>::output_diagram();
+    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; 
   }
+
 };
 
 } // namespace Gudhi
diff --git a/src/cython/src/cpp/Simplex_tree_interface.h b/src/cython/src/cpp/Simplex_tree_interface.h
index 4bdd2c9e..223590aa 100644
--- a/src/cython/src/cpp/Simplex_tree_interface.h
+++ b/src/cython/src/cpp/Simplex_tree_interface.h
@@ -120,7 +120,7 @@ class Simplex_tree_interface : public Simplex_tree<SimplexTreeOptions> {
 
 struct Simplex_tree_options_mini : Simplex_tree_options_full_featured {
   // Not doing persistence, so we don't need those
-  static const bool store_key = false;
+  static const bool store_key = true;
   static const bool store_filtration = false;
   // I have few vertices
   typedef short Vertex_handle;
diff --git a/src/cython/src/cython/Alpha_complex.pyx b/src/cython/src/cython/Alpha_complex.pyx
index 93b7054f..8d08af42 100644
--- a/src/cython/src/cython/Alpha_complex.pyx
+++ b/src/cython/src/cython/Alpha_complex.pyx
@@ -47,6 +47,11 @@ cdef extern from "Alpha_complex_interface.h" namespace "Gudhi":
         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)
+        void get_persistence(int homology_coeff_field, double min_persistence)
+
 # AlphaComplex python interface
 cdef class AlphaComplex:
     cdef Alpha_complex_interface *thisptr
@@ -129,3 +134,9 @@ cdef class AlphaComplex:
     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)
+        if pcohptr != NULL:
+            pcohptr.get_persistence(homology_coeff_field, min_persistence)
+            del pcohptr
+        return 5
diff --git a/src/cython/src/cython/Mini_simplex_tree.pyx b/src/cython/src/cython/Mini_simplex_tree.pyx
new file mode 100644
index 00000000..b923b5b4
--- /dev/null
+++ b/src/cython/src/cython/Mini_simplex_tree.pyx
@@ -0,0 +1,140 @@
+"""This file is part of the Gudhi Library. The Gudhi library
+   (Geometric Understanding in Higher Dimensions) is a generic C++
+   library for computational topology.
+
+   Author(s):       Vincent Rouvreau
+
+   Copyright (C) 2016  INRIA Saclay (France)
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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/>."""
+
+__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
+
+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()
+        double simplex_filtration(vector[int] simplex)
+        void set_filtration(double filtration)
+        void initialize_filtration()
+        int num_vertices()
+        int num_simplices()
+        void set_dimension(int dimension)
+        int dimension()
+        bint find_simplex(vector[int] simplex)
+        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)
+        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)
+        void get_persistence(int homology_coeff_field, double min_persistence)
+
+# MiniSimplexTree python interface
+cdef class MiniSimplexTree:
+    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)
+    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)
+        return self.thisptr.find_simplex(complex)
+    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)
+    def get_filtered_tree(self):
+        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))
+        return ct
+    def get_skeleton_tree(self, 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))
+        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)
+        ct = []
+        for filtered_complex in coface_tree:
+            v = []
+            for vertex in filtered_complex.first:
+                v.append(vertex)
+            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)
+        ct = []
+        for filtered_complex in coface_tree:
+            v = []
+            for vertex in filtered_complex.first:
+                v.append(vertex)
+            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)
+        if pcohptr != NULL:
+            pcohptr.get_persistence(homology_coeff_field, 0)
+            del pcohptr
+        return 5
diff --git a/src/cython/src/cython/Rips_complex.pyx b/src/cython/src/cython/Rips_complex.pyx
index 7676dde1..e722e483 100644
--- a/src/cython/src/cython/Rips_complex.pyx
+++ b/src/cython/src/cython/Rips_complex.pyx
@@ -49,6 +49,11 @@ cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
         void remove_maximal_simplex(vector[int] simplex)
         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)
+        void get_persistence(int homology_coeff_field, double min_persistence)
+
 # RipsComplex python interface
 cdef class RipsComplex:
     cdef Rips_complex_interface *thisptr
@@ -130,3 +135,9 @@ cdef class RipsComplex:
         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)
+        if pcohptr != NULL:
+            pcohptr.get_persistence(homology_coeff_field, min_persistence)
+            del pcohptr
+        return 5
diff --git a/src/cython/src/cython/Simplex_tree.pyx b/src/cython/src/cython/Simplex_tree.pyx
index b1689679..1543f792 100644
--- a/src/cython/src/cython/Simplex_tree.pyx
+++ b/src/cython/src/cython/Simplex_tree.pyx
@@ -49,8 +49,8 @@ cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
         void remove_maximal_simplex(vector[int] simplex)
 
 cdef extern from "Persistent_cohomology_interface.h" namespace "Gudhi":
-    cdef cppclass Persistent_cohomology_interface_full_featured "Gudhi::Persistent_cohomology_interface<Gudhi::Simplex_tree_options_full_featured>":
-        Persistent_cohomology_interface_full_featured(Simplex_tree_interface_full_featured* st)
+    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)
         void get_persistence(int homology_coeff_field, double min_persistence)
 
 # SimplexTree python interface
@@ -132,112 +132,9 @@ cdef class SimplexTree:
     def remove_maximal_simplex(self, simplex):
         self.thisptr.remove_maximal_simplex(simplex)
     def persistence(self, homology_coeff_field, min_persistence = 0):
-        cdef Persistent_cohomology_interface_full_featured *pcohptr = new Persistent_cohomology_interface_full_featured(self.thisptr)
+        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
         return 5
 
-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()
-        double simplex_filtration(vector[int] simplex)
-        void set_filtration(double filtration)
-        void initialize_filtration()
-        int num_vertices()
-        int num_simplices()
-        void set_dimension(int dimension)
-        int dimension()
-        bint find_simplex(vector[int] simplex)
-        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)
-        void remove_maximal_simplex(vector[int] simplex)
-
-# SimplexTree python interface
-cdef class MiniSimplexTree:
-    cdef Simplex_tree_interface_mini *thisptr
-    def __cinit__(self, points=None, max_dimension=3, max_edge_length=float('inf')):
-        self.thisptr = new Simplex_tree_interface_mini()
-        # Constructor from graph expansion
-        if points is not None:
-            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)
-    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)
-        return self.thisptr.find_simplex(complex)
-    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)
-    def get_filtered_tree(self):
-        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))
-        return ct
-    def get_skeleton_tree(self, 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))
-        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)
-        ct = []
-        for filtered_complex in coface_tree:
-            v = []
-            for vertex in filtered_complex.first:
-                v.append(vertex)
-            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)
-        ct = []
-        for filtered_complex in coface_tree:
-            v = []
-            for vertex in filtered_complex.first:
-                v.append(vertex)
-            ct.append((v,filtered_complex.second))
-        return ct
-    def remove_maximal_simplex(self, simplex):
-        self.thisptr.remove_maximal_simplex(simplex)
diff --git a/src/cython/test/Mini_simplex_tree_UT.py b/src/cython/test/Mini_simplex_tree_UT.py
new file mode 100755
index 00000000..0d2ce3c3
--- /dev/null
+++ b/src/cython/test/Mini_simplex_tree_UT.py
@@ -0,0 +1,27 @@
+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);
+
+    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))
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file
diff --git a/src/cython/test/Simplex_tree_UT.py b/src/cython/test/Simplex_tree_UT.py
index 050ef289..b3ded581 100755
--- a/src/cython/test/Simplex_tree_UT.py
+++ b/src/cython/test/Simplex_tree_UT.py
@@ -53,24 +53,5 @@ class TestSimplexTree(unittest.TestCase):
     self.assertTrue(st.find([1]))
     self.assertTrue(st.find([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)])
-
-    # 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