Merge master and resolve conflict on .github/next_release.md

25 files changed, 466 insertions, 348 deletions

diff --git a/.github/next_release.md b/.github/next_release.md
index 211ae117..b90aab33 100644
--- a/.github/next_release.md
+++ b/.github/next_release.md
@@ -6,10 +6,15 @@ We are now using GitHub to develop the GUDHI library, do not hesitate to [fork t
 
 Below is a list of changes made since GUDHI 3.5.0:
 
+- [Alpha complex](https://gudhi.inria.fr/python/latest/alpha_complex_user.html)
+     - the python weighted version for alpha complex is now available in any dimension D.
+     - `alpha_complex = gudhi.AlphaComplex(off_file='/data/points/tore3D_300.off')` is deprecated, please use [read_points_from_off_file](https://gudhi.inria.fr/python/latest/point_cloud.html#gudhi.read_points_from_off_file) instead.
+
 - [Representations](https://gudhi.inria.fr/python/latest/representations.html#gudhi.representations.vector_methods.BettiCurve)
      - A more flexible Betti curve class capable of computing exact curves
 
-- [Python installation](link)
+- Installation
+     - Boost ≥ 1.66.0 is now required (was ≥ 1.56.0).
      - Python >= 3.5 and cython >= 0.27 are now required.
 
 - [Module](link)
diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index e03bb161..028ec9bb 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -20,6 +20,7 @@
 #include <stdlib.h>
 #include <math.h>  // isnan, fmax
 #include <memory>  // for std::unique_ptr
+#include <cstddef>  // for std::size_t
 
 #include <CGAL/Delaunay_triangulation.h>
 #include <CGAL/Regular_triangulation.h>  // aka. Weighted Delaunay triangulation
@@ -213,6 +214,15 @@ class Alpha_complex {
   Alpha_complex (Alpha_complex&& other) = delete;
   Alpha_complex& operator= (Alpha_complex&& other) = delete;
 
+  /** \brief Returns the number of finite vertices in the triangulation.
+   */
+  std::size_t num_vertices() const {
+    if (triangulation_ == nullptr)
+      return 0;
+    else
+      return triangulation_->number_of_vertices();
+  }
+
   /** \brief get_point returns the point corresponding to the vertex given as parameter.
    *
    * @param[in] vertex Vertex handle of the point to retrieve.
@@ -373,7 +383,7 @@ class Alpha_complex {
 
     // --------------------------------------------------------------------------------------------
     // Simplex_tree construction from loop on triangulation finite full cells list
-    if (triangulation_->number_of_vertices() > 0) {
+    if (num_vertices() > 0) {
       for (auto cit = triangulation_->finite_full_cells_begin();
            cit != triangulation_->finite_full_cells_end();
            ++cit) {
diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex_3d.h b/src/Alpha_complex/include/gudhi/Alpha_complex_3d.h
index ccc3d852..df5c630e 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex_3d.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex_3d.h
@@ -12,7 +12,6 @@
 #ifndef ALPHA_COMPLEX_3D_H_
 #define ALPHA_COMPLEX_3D_H_
 
-#include <boost/version.hpp>
 #include <boost/variant.hpp>
 #include <boost/range/size.hpp>
 #include <boost/range/combine.hpp>
diff --git a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
index 4b37e4bd..f74ad217 100644
--- a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
+++ b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
@@ -56,6 +56,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_OFF_file, TestedKernel, list_of
   Gudhi::Simplex_tree<> simplex_tree_60;
   BOOST_CHECK(alpha_complex_from_file.create_complex(simplex_tree_60, max_alpha_square_value));
 
+  std::clog << "alpha_complex_from_file.num_vertices()=" << alpha_complex_from_file.num_vertices() << std::endl;
+  BOOST_CHECK(alpha_complex_from_file.num_vertices() == 7);
+
   std::clog << "simplex_tree_60.dimension()=" << simplex_tree_60.dimension() << std::endl;
   BOOST_CHECK(simplex_tree_60.dimension() == 2);
 
@@ -72,6 +75,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_OFF_file, TestedKernel, list_of
   Gudhi::Simplex_tree<> simplex_tree_59;
   BOOST_CHECK(alpha_complex_from_file.create_complex(simplex_tree_59, max_alpha_square_value));
   
+  std::clog << "alpha_complex_from_file.num_vertices()=" << alpha_complex_from_file.num_vertices() << std::endl;
+  BOOST_CHECK(alpha_complex_from_file.num_vertices() == 7);
+
   std::clog << "simplex_tree_59.dimension()=" << simplex_tree_59.dimension() << std::endl;
   BOOST_CHECK(simplex_tree_59.dimension() == 2);
 
@@ -120,6 +126,9 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) {
   Gudhi::Simplex_tree<> simplex_tree;
   BOOST_CHECK(alpha_complex_from_points.create_complex(simplex_tree));
   
+  std::clog << "alpha_complex_from_points.num_vertices()=" << alpha_complex_from_points.num_vertices() << std::endl;
+  BOOST_CHECK(alpha_complex_from_points.num_vertices() == points.size());
+
   // Another way to check num_simplices
   std::clog << "Iterator on alpha complex simplices in the filtration order, with [filtration value]:" << std::endl;
   int num_simplices = 0;
@@ -240,6 +249,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_empty_points, TestedKernel, lis
   // ----------------------------------------------------------------------------
   Gudhi::alpha_complex::Alpha_complex<TestedKernel> alpha_complex_from_points(points);
 
+  std::clog << "alpha_complex_from_points.num_vertices()=" << alpha_complex_from_points.num_vertices() << std::endl;
+  BOOST_CHECK(alpha_complex_from_points.num_vertices() == points.size());
+
   // Test to the limit
   BOOST_CHECK_THROW (alpha_complex_from_points.get_point(0), std::out_of_range);
 
@@ -291,6 +303,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_with_duplicated_points, TestedKernel
   std::clog << "create_complex" << std::endl;
   BOOST_CHECK(alpha_complex_from_points.create_complex(simplex_tree));
   
+  std::clog << "alpha_complex_from_points.num_vertices()=" << alpha_complex_from_points.num_vertices() << std::endl;
+  BOOST_CHECK(alpha_complex_from_points.num_vertices() < points.size());
+
   std::clog << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices()
       << std::endl;
   BOOST_CHECK(simplex_tree.num_vertices() < points.size());
diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h
index ee64a277..e5522cc7 100644
--- a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h
+++ b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h
@@ -14,7 +14,6 @@
 #include <gudhi/Debug_utils.h>
 
 #include <boost/iterator/iterator_facade.hpp>
-#include <boost/version.hpp>
 #include <boost/container/static_vector.hpp>
 
 #include <vector>
diff --git a/src/Subsampling/include/gudhi/sparsify_point_set.h b/src/Subsampling/include/gudhi/sparsify_point_set.h
index 4571b8f3..b325fe3c 100644
--- a/src/Subsampling/include/gudhi/sparsify_point_set.h
+++ b/src/Subsampling/include/gudhi/sparsify_point_set.h
@@ -11,12 +11,7 @@
 #ifndef SPARSIFY_POINT_SET_H_
 #define SPARSIFY_POINT_SET_H_
 
-#include <boost/version.hpp>
-#if BOOST_VERSION < 106600
-# include <boost/function_output_iterator.hpp>
-#else
 # include <boost/iterator/function_output_iterator.hpp>
-#endif
 
 #include <gudhi/Kd_tree_search.h>
 #ifdef GUDHI_SUBSAMPLING_PROFILING
diff --git a/src/cmake/modules/GUDHI_third_party_libraries.cmake b/src/cmake/modules/GUDHI_third_party_libraries.cmake
index c8aa1665..7c982b3b 100644
--- a/src/cmake/modules/GUDHI_third_party_libraries.cmake
+++ b/src/cmake/modules/GUDHI_third_party_libraries.cmake
@@ -1,6 +1,6 @@
 # This files manage third party libraries required by GUDHI
 
-find_package(Boost 1.56.0 QUIET OPTIONAL_COMPONENTS filesystem unit_test_framework program_options)
+find_package(Boost 1.66.0 QUIET OPTIONAL_COMPONENTS filesystem unit_test_framework program_options)
 
 # Boost_FOUND is not reliable
 if(NOT Boost_VERSION)
diff --git a/src/common/doc/installation.h b/src/common/doc/installation.h
index ef668dfb..67d026bd 100644
--- a/src/common/doc/installation.h
+++ b/src/common/doc/installation.h
@@ -5,7 +5,7 @@
  * Examples of GUDHI headers inclusion can be found in \ref utilities.
  * 
  * \section compiling Compiling
- * The library uses c++14 and requires <a target="_blank" href="http://www.boost.org/">Boost</a>  &ge; 1.56.0
+ * The library uses c++14 and requires <a target="_blank" href="http://www.boost.org/">Boost</a>  &ge; 1.66.0
  * and <a target="_blank" href="https://www.cmake.org/">CMake</a> &ge; 3.5.
  * It is a multi-platform library and compiles on Linux, Mac OSX and Visual Studio 2015.
  * 
diff --git a/src/common/include/gudhi/reader_utils.h b/src/common/include/gudhi/reader_utils.h
index a1b104e2..29d5423d 100644
--- a/src/common/include/gudhi/reader_utils.h
+++ b/src/common/include/gudhi/reader_utils.h
@@ -14,11 +14,7 @@
 #include <gudhi/graph_simplicial_complex.h>
 #include <gudhi/Debug_utils.h>
 
-#if BOOST_VERSION < 106600
-# include <boost/function_output_iterator.hpp>
-#else
 # include <boost/iterator/function_output_iterator.hpp>
-#endif
 #include <boost/graph/adjacency_list.hpp>
 
 #include <iostream>
diff --git a/src/python/CMakeLists.txt b/src/python/CMakeLists.txt
index 12ffcd85..fbfb0d1f 100644
--- a/src/python/CMakeLists.txt
+++ b/src/python/CMakeLists.txt
@@ -171,12 +171,14 @@ if(PYTHONINTERP_FOUND)
       set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}'nerve_gic', ")
     endif ()
     if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
-      set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}'alpha_complex', ")
       set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}'subsampling', ")
       set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}'tangential_complex', ")
       set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}'euclidean_witness_complex', ")
       set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}'euclidean_strong_witness_complex', ")
     endif ()
+    if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
+      set(GUDHI_CYTHON_MODULES "${GUDHI_CYTHON_MODULES}'alpha_complex', ")
+    endif ()
 
     add_gudhi_debug_info("Boost version ${Boost_VERSION}")
     if(CGAL_FOUND)
@@ -263,6 +265,10 @@ if(PYTHONINTERP_FOUND)
       set(GUDHI_PYTHON_INCLUDE_DIRS "${GUDHI_PYTHON_INCLUDE_DIRS}'${TBB_INCLUDE_DIRS}', ")
     endif()
 
+    if(DEBUG_TRACES)
+      set(GUDHI_PYTHON_EXTRA_COMPILE_ARGS "${GUDHI_PYTHON_EXTRA_COMPILE_ARGS}'-DDEBUG_TRACES', ")
+    endif(DEBUG_TRACES)
+
     if(UNIX AND WITH_GUDHI_PYTHON_RUNTIME_LIBRARY_DIRS)
       set( GUDHI_PYTHON_RUNTIME_LIBRARY_DIRS "${GUDHI_PYTHON_LIBRARY_DIRS}")
     endif(UNIX AND WITH_GUDHI_PYTHON_RUNTIME_LIBRARY_DIRS)
@@ -314,7 +320,7 @@ if(PYTHONINTERP_FOUND)
             if(SCIPY_FOUND)
               if(SKLEARN_FOUND)
                 if(OT_FOUND)
-                  if(NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
+                  if(NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
                     set (GUDHI_SPHINX_MESSAGE "Generating API documentation with Sphinx in ${CMAKE_CURRENT_BINARY_DIR}/sphinx/")
                     # User warning - Sphinx is a static pages generator, and configured to work fine with user_version
                     # Images and biblio warnings because not found on developper version
@@ -334,10 +340,10 @@ if(PYTHONINTERP_FOUND)
                              ${SPHINX_PATH} -b doctest ${CMAKE_CURRENT_SOURCE_DIR}/doc ${CMAKE_CURRENT_BINARY_DIR}/doctest)
                     # Set missing or not modules
                     set(GUDHI_MODULES ${GUDHI_MODULES} "python-documentation" CACHE INTERNAL "GUDHI_MODULES")
-                  else(NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
-                    message("++ Python documentation module will not be compiled because it requires a Eigen3 and CGAL version >= 4.11.0")
+                  else(NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
+                    message("++ Python documentation module will not be compiled because it requires a Eigen3 and CGAL version >= 5.1.0")
                     set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} "python-documentation" CACHE INTERNAL "GUDHI_MISSING_MODULES")
-                  endif(NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
+                  endif(NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
                 else(OT_FOUND)
                   message("++ Python documentation module will not be compiled because POT was not found")
                   set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} "python-documentation" CACHE INTERNAL "GUDHI_MISSING_MODULES")
@@ -373,13 +379,15 @@ if(PYTHONINTERP_FOUND)
 
 
     # Test examples
-    if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
+    if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
       # Bottleneck and Alpha
       add_test(NAME alpha_rips_persistence_bottleneck_distance_py_test
                WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                COMMAND ${CMAKE_COMMAND} -E env "${GUDHI_PYTHON_PATH_ENV}"
                ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/alpha_rips_persistence_bottleneck_distance.py"
                -f ${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off -t 0.15 -d 3)
+    endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
+    if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
       # Tangential
       add_test(NAME tangential_complex_plain_homology_from_off_file_example_py_test
                WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
@@ -447,7 +455,7 @@ if(PYTHONINTERP_FOUND)
       add_gudhi_py_test(test_cover_complex)
     endif (NOT CGAL_VERSION VERSION_LESS 4.11.0)
 
-    if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
+    if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
       # Alpha
       add_test(NAME alpha_complex_from_points_example_py_test
                WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
@@ -463,7 +471,7 @@ if(PYTHONINTERP_FOUND)
              ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/example/alpha_complex_diagram_persistence_from_off_file_example.py"
              --no-diagram -f ${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off)
       add_gudhi_py_test(test_alpha_complex)
-    endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
+    endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
 
     if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
       # Euclidean witness
@@ -587,4 +595,4 @@ if(PYTHONINTERP_FOUND)
 else(PYTHONINTERP_FOUND)
   message("++ Python module will not be compiled because no Python interpreter was found")
   set(GUDHI_MISSING_MODULES ${GUDHI_MISSING_MODULES} "python" CACHE INTERNAL "GUDHI_MISSING_MODULES")
-endif(PYTHONINTERP_FOUND)
+endif(PYTHONINTERP_FOUND)
\ No newline at end of file
diff --git a/src/python/doc/alpha_complex_ref.rst b/src/python/doc/alpha_complex_ref.rst
index 7da79543..eaa72551 100644
--- a/src/python/doc/alpha_complex_ref.rst
+++ b/src/python/doc/alpha_complex_ref.rst
@@ -9,6 +9,5 @@ Alpha complex reference manual
 .. autoclass:: gudhi.AlphaComplex
    :members:
    :undoc-members:
-   :show-inheritance:
 
    .. automethod:: gudhi.AlphaComplex.__init__
diff --git a/src/python/doc/alpha_complex_sum.inc b/src/python/doc/alpha_complex_sum.inc
index aeab493f..5c76fd54 100644
--- a/src/python/doc/alpha_complex_sum.inc
+++ b/src/python/doc/alpha_complex_sum.inc
@@ -1,15 +1,15 @@
 .. table::
    :widths: 30 40 30
 
-   +----------------------------------------------------------------+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------+
-   | .. figure::                                                    | Alpha complex is a simplicial complex constructed from the finite       | :Author: Vincent Rouvreau                                                                                                 |
-   |      ../../doc/Alpha_complex/alpha_complex_representation.png  | cells of a Delaunay Triangulation. It has the same persistent homology  |                                                                                                                           |
-   |      :alt: Alpha complex representation                        | as the Čech complex and is significantly smaller.                       | :Since: GUDHI 2.0.0                                                                                                       |
-   |      :figclass: align-center                                   |                                                                         |                                                                                                                           |
-   |                                                                |                                                                         | :License: MIT (`GPL v3 </licensing/>`_)                                                                                   |
-   |                                                                |                                                                         |                                                                                                                           |
-   |                                                                |                                                                         | :Requires: `Eigen <installation.html#eigen>`_ :math:`\geq` 3.1.0 and `CGAL <installation.html#cgal>`_ :math:`\geq` 4.11.0 |
-   |                                                                |                                                                         |                                                                                                                           |
-   +----------------------------------------------------------------+-------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------+
-   | * :doc:`alpha_complex_user`                                    | * :doc:`alpha_complex_ref`                                                                                                                                                                          |
-   +----------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+   +----------------------------------------------------------------+-------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
+   | .. figure::                                                    | Alpha complex is a simplicial complex constructed from the finite       | :Author: Vincent Rouvreau                                                                                              |
+   |      ../../doc/Alpha_complex/alpha_complex_representation.png  | cells of a Delaunay Triangulation. It has the same persistent homology  |                                                                                                                        |
+   |      :alt: Alpha complex representation                        | as the Čech complex and is significantly smaller.                       | :Since: GUDHI 2.0.0                                                                                                    |
+   |      :figclass: align-center                                   |                                                                         |                                                                                                                        |
+   |                                                                |                                                                         | :License: MIT (`GPL v3 </licensing/>`_)                                                                                |
+   |                                                                |                                                                         |                                                                                                                        |
+   |                                                                |                                                                         | :Requires: `Eigen <installation.html#eigen>`_ :math:`\geq` 3.1.0 and `CGAL <installation.html#cgal>`_ :math:`\geq` 5.1 |
+   |                                                                |                                                                         |                                                                                                                        |
+   +----------------------------------------------------------------+-------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
+   | * :doc:`alpha_complex_user`                                    | * :doc:`alpha_complex_ref`                                                                                                                                                                       |
+   +----------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
diff --git a/src/python/doc/alpha_complex_user.rst b/src/python/doc/alpha_complex_user.rst
index 96e267ef..cfd22742 100644
--- a/src/python/doc/alpha_complex_user.rst
+++ b/src/python/doc/alpha_complex_user.rst
@@ -9,7 +9,7 @@ Definition
 
 .. include:: alpha_complex_sum.inc
 
-:doc:`AlphaComplex <alpha_complex_ref>` is constructing a :doc:`SimplexTree <simplex_tree_ref>` using
+:class:`~gudhi.AlphaComplex` is constructing a :doc:`SimplexTree <simplex_tree_ref>` using
 `Delaunay Triangulation  <http://doc.cgal.org/latest/Triangulation/index.html#Chapter_Triangulations>`_
 :cite:`cgal:hdj-t-19b` from the `Computational Geometry Algorithms Library <http://www.cgal.org/>`_
 :cite:`cgal:eb-19b`.
@@ -33,9 +33,6 @@ Remarks
   Using :code:`precision = 'fast'` makes the computations slightly faster, and the combinatorics are still exact, but
   the computation of filtration values can exceptionally be arbitrarily bad. In all cases, we still guarantee that the
   output is a valid filtration (faces have a filtration value no larger than their cofaces).
-* For performances reasons, it is advised to use Alpha_complex with `CGAL <installation.html#cgal>`_ :math:`\geq` 5.0.0.
-* The vertices in the output simplex tree are not guaranteed to match the order of the input points. One can use
-  :func:`~gudhi.AlphaComplex.get_point` to get the initial point back.
 
 Example from points
 -------------------
@@ -44,23 +41,22 @@ This example builds the alpha-complex from the given points:
 
 .. testcode::
 
-    import gudhi
-    alpha_complex = gudhi.AlphaComplex(points=[[1, 1], [7, 0], [4, 6], [9, 6], [0, 14], [2, 19], [9, 17]])
+    from gudhi import AlphaComplex
+    ac = AlphaComplex(points=[[1, 1], [7, 0], [4, 6], [9, 6], [0, 14], [2, 19], [9, 17]])
+
+    stree = ac.create_simplex_tree()
+    print('Alpha complex is of dimension ', stree.dimension(), ' - ',
+      stree.num_simplices(), ' simplices - ', stree.num_vertices(), ' vertices.')
 
-    simplex_tree = alpha_complex.create_simplex_tree()
-    result_str = 'Alpha complex is of dimension ' + repr(simplex_tree.dimension()) + ' - ' + \
-        repr(simplex_tree.num_simplices()) + ' simplices - ' + \
-        repr(simplex_tree.num_vertices()) + ' vertices.'
-    print(result_str)
     fmt = '%s -> %.2f'
-    for filtered_value in simplex_tree.get_filtration():
+    for filtered_value in stree.get_filtration():
         print(fmt % tuple(filtered_value))
 
 The output is:
 
 .. testoutput::
 
-   Alpha complex is of dimension 2 - 25 simplices - 7 vertices.
+   Alpha complex is of dimension  2  -  25  simplices -  7  vertices.
    [0] -> 0.00
    [1] -> 0.00
    [2] -> 0.00
@@ -177,11 +173,75 @@ of speed-up, since we always first build the full filtered complex, so it is rec
 :paramref:`~gudhi.AlphaComplex.create_simplex_tree.max_alpha_square`.
 In the following example, a threshold of :math:`\alpha^2 = 32.0` is used.
 
+Weighted version
+^^^^^^^^^^^^^^^^
+
+A weighted version for Alpha complex is available. It is like a usual Alpha complex, but based on a
+`CGAL regular triangulation <https://doc.cgal.org/latest/Triangulation/index.html#title20>`_.
+
+This example builds the weighted alpha-complex of a small molecule, where atoms have different sizes.
+It is taken from
+`CGAL 3d weighted alpha shapes <https://doc.cgal.org/latest/Alpha_shapes_3/index.html#title13>`_.
+
+Then, it is asked to display information about the alpha complex.
+
+.. testcode::
+
+    from gudhi import AlphaComplex
+    wgt_ac = AlphaComplex(points=[[ 1., -1., -1.],
+                                  [-1.,  1., -1.],
+                                  [-1., -1.,  1.],
+                                  [ 1.,  1.,  1.],
+                                  [ 2.,  2.,  2.]],
+                          weights = [4., 4., 4., 4., 1.])
+
+    stree = wgt_ac.create_simplex_tree()
+    print('Weighted alpha complex is of dimension ', stree.dimension(), ' - ',
+          stree.num_simplices(), ' simplices - ', stree.num_vertices(), ' vertices.')
+    fmt = '%s -> %.2f'
+    for simplex in stree.get_simplices():
+        print(fmt % tuple(simplex))
+
+The output is:
+
+.. testoutput::
+
+   Weighted alpha complex is of dimension  3  -  29  simplices -  5  vertices.
+   [0, 1, 2, 3] -> -1.00
+   [0, 1, 2] -> -1.33
+   [0, 1, 3, 4] -> 95.00
+   [0, 1, 3] -> -1.33
+   [0, 1, 4] -> 95.00
+   [0, 1] -> -2.00
+   [0, 2, 3, 4] -> 95.00
+   [0, 2, 3] -> -1.33
+   [0, 2, 4] -> 95.00
+   [0, 2] -> -2.00
+   [0, 3, 4] -> 23.00
+   [0, 3] -> -2.00
+   [0, 4] -> 23.00
+   [0] -> -4.00
+   [1, 2, 3, 4] -> 95.00
+   [1, 2, 3] -> -1.33
+   [1, 2, 4] -> 95.00
+   [1, 2] -> -2.00
+   [1, 3, 4] -> 23.00
+   [1, 3] -> -2.00
+   [1, 4] -> 23.00
+   [1] -> -4.00
+   [2, 3, 4] -> 23.00
+   [2, 3] -> -2.00
+   [2, 4] -> 23.00
+   [2] -> -4.00
+   [3, 4] -> -1.00
+   [3] -> -4.00
+   [4] -> -1.00
 
 Example from OFF file
 ^^^^^^^^^^^^^^^^^^^^^
 
-This example builds the alpha complex from 300 random points on a 2-torus.
+This example builds the alpha complex from 300 random points on a 2-torus, given by an
+`OFF file <fileformats.html#off-file-format>`_.
 
 Then, it computes the persistence diagram and displays it:
 
@@ -189,14 +249,10 @@ Then, it computes the persistence diagram and displays it:
    :include-source:
 
     import matplotlib.pyplot as plt
-    import gudhi
-    alpha_complex = gudhi.AlphaComplex(off_file=gudhi.__root_source_dir__ + \
-        '/data/points/tore3D_300.off')
-    simplex_tree = alpha_complex.create_simplex_tree()
-    result_str = 'Alpha complex is of dimension ' + repr(simplex_tree.dimension()) + ' - ' + \
-        repr(simplex_tree.num_simplices()) + ' simplices - ' + \
-        repr(simplex_tree.num_vertices()) + ' vertices.'
-    print(result_str)
-    diag = simplex_tree.persistence()
-    gudhi.plot_persistence_diagram(diag)
+    import gudhi as gd
+    off_file = gd.__root_source_dir__ + '/data/points/tore3D_300.off'
+    points = gd.read_points_from_off_file(off_file = off_file)
+    stree = gd.AlphaComplex(points = points).create_simplex_tree()
+    dgm = stree.persistence()
+    gd.plot_persistence_diagram(dgm, legend = True)
     plt.show()
diff --git a/src/python/doc/installation.rst b/src/python/doc/installation.rst
index 873f7870..cff84691 100644
--- a/src/python/doc/installation.rst
+++ b/src/python/doc/installation.rst
@@ -39,7 +39,7 @@ If you are instead using a git checkout, beware that the paths are a bit
 different, and in particular the `python/` subdirectory is actually `src/python/`
 there.
 
-The library uses c++14 and requires `Boost <https://www.boost.org/>`_ :math:`\geq` 1.56.0,
+The library uses c++14 and requires `Boost <https://www.boost.org/>`_ :math:`\geq` 1.66.0,
 `CMake <https://www.cmake.org/>`_ :math:`\geq` 3.5  to generate makefiles,
 Python :math:`\geq` 3.5, `NumPy <http://numpy.org>`_ :math:`\geq` 1.15.0, `Cython <https://www.cython.org/>`_
 :math:`\geq` 0.27 and `pybind11 <https://github.com/pybind/pybind11>`_ to compile the GUDHI Python module.
diff --git a/src/python/example/alpha_complex_diagram_persistence_from_off_file_example.py b/src/python/example/alpha_complex_diagram_persistence_from_off_file_example.py
index fe03be31..c96121a6 100755
--- a/src/python/example/alpha_complex_diagram_persistence_from_off_file_example.py
+++ b/src/python/example/alpha_complex_diagram_persistence_from_off_file_example.py
@@ -1,9 +1,7 @@
 #!/usr/bin/env python
 
 import argparse
-import errno
-import os
-import gudhi
+import gudhi as gd
 
 """ This file is part of the Gudhi Library - https://gudhi.inria.fr/ -
     which is released under MIT.
@@ -41,33 +39,24 @@ parser.add_argument(
 
 args = parser.parse_args()
 
-with open(args.file, "r") as f:
-    first_line = f.readline()
-    if (first_line == "OFF\n") or (first_line == "nOFF\n"):
-        print("##############################################################")
-        print("AlphaComplex creation from points read in a OFF file")
-
-        alpha_complex = gudhi.AlphaComplex(off_file=args.file)
-        if args.max_alpha_square is not None:
-            print("with max_edge_length=", args.max_alpha_square)
-            simplex_tree = alpha_complex.create_simplex_tree(
-                max_alpha_square=args.max_alpha_square
-            )
-        else:
-            simplex_tree = alpha_complex.create_simplex_tree()
-
-        print("Number of simplices=", simplex_tree.num_simplices())
-
-        diag = simplex_tree.persistence()
-
-        print("betti_numbers()=", simplex_tree.betti_numbers())
-
-        if args.no_diagram == False:
-            import matplotlib.pyplot as plot
-            gudhi.plot_persistence_diagram(diag, band=args.band)
-            plot.show()
-    else:
-        raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
-                                args.file)
-
-    f.close()
+print("##############################################################")
+print("AlphaComplex creation from points read in a OFF file")
+
+points = gd.read_points_from_off_file(off_file = args.file)
+alpha_complex = gd.AlphaComplex(points = points)
+if args.max_alpha_square is not None:
+    print("with max_edge_length=", args.max_alpha_square)
+    simplex_tree = alpha_complex.create_simplex_tree(
+        max_alpha_square=args.max_alpha_square
+    )
+else:
+    simplex_tree = alpha_complex.create_simplex_tree()
+
+print("Number of simplices=", simplex_tree.num_simplices())
+
+diag = simplex_tree.persistence()
+print("betti_numbers()=", simplex_tree.betti_numbers())
+if args.no_diagram == False:
+    import matplotlib.pyplot as plot
+    gd.plot_persistence_diagram(diag, band=args.band)
+    plot.show()
diff --git a/src/python/example/alpha_rips_persistence_bottleneck_distance.py b/src/python/example/alpha_rips_persistence_bottleneck_distance.py
index 3e12b0d5..6b97fb3b 100755
--- a/src/python/example/alpha_rips_persistence_bottleneck_distance.py
+++ b/src/python/example/alpha_rips_persistence_bottleneck_distance.py
@@ -1,10 +1,8 @@
 #!/usr/bin/env python
 
-import gudhi
+import gudhi as gd
 import argparse
 import math
-import errno
-import os
 import numpy as np
 
 """ This file is part of the Gudhi Library - https://gudhi.inria.fr/ -
@@ -37,70 +35,60 @@ parser.add_argument("-t", "--threshold", type=float, default=0.5)
 parser.add_argument("-d", "--max_dimension", type=int, default=1)
 
 args = parser.parse_args()
-with open(args.file, "r") as f:
-    first_line = f.readline()
-    if (first_line == "OFF\n") or (first_line == "nOFF\n"):
-        point_cloud = gudhi.read_points_from_off_file(off_file=args.file)
-        print("##############################################################")
-        print("RipsComplex creation from points read in a OFF file")
+point_cloud = gd.read_points_from_off_file(off_file=args.file)
+print("##############################################################")
+print("RipsComplex creation from points read in a OFF file")
 
-        message = "RipsComplex with max_edge_length=" + repr(args.threshold)
-        print(message)
+message = "RipsComplex with max_edge_length=" + repr(args.threshold)
+print(message)
 
-        rips_complex = gudhi.RipsComplex(
-            points=point_cloud, max_edge_length=args.threshold
-        )
-
-        rips_stree = rips_complex.create_simplex_tree(
-            max_dimension=args.max_dimension)
-
-        message = "Number of simplices=" + repr(rips_stree.num_simplices())
-        print(message)
-
-        rips_stree.compute_persistence()
-
-        print("##############################################################")
-        print("AlphaComplex creation from points read in a OFF file")
-
-        message = "AlphaComplex with max_edge_length=" + repr(args.threshold)
-        print(message)
-
-        alpha_complex = gudhi.AlphaComplex(points=point_cloud)
-        alpha_stree = alpha_complex.create_simplex_tree(
-            max_alpha_square=(args.threshold * args.threshold)
-        )
-
-        message = "Number of simplices=" + repr(alpha_stree.num_simplices())
-        print(message)
+rips_complex = gd.RipsComplex(
+    points=point_cloud, max_edge_length=args.threshold
+)
 
-        alpha_stree.compute_persistence()
+rips_stree = rips_complex.create_simplex_tree(
+    max_dimension=args.max_dimension)
 
-        max_b_distance = 0.0
-        for dim in range(args.max_dimension):
-            # Alpha persistence values needs to be transform because filtration
-            # values are alpha square values
-            alpha_intervals = np.sqrt(alpha_stree.persistence_intervals_in_dimension(dim))
+message = "Number of simplices=" + repr(rips_stree.num_simplices())
+print(message)
 
-            rips_intervals = rips_stree.persistence_intervals_in_dimension(dim)
-            bottleneck_distance = gudhi.bottleneck_distance(
-                rips_intervals, alpha_intervals
-            )
-            message = (
-                "In dimension "
-                + repr(dim)
-                + ", bottleneck distance = "
-                + repr(bottleneck_distance)
-            )
-            print(message)
-            max_b_distance = max(bottleneck_distance, max_b_distance)
+rips_stree.compute_persistence()
 
-        print("==============================================================")
-        message = "Bottleneck distance is " + repr(max_b_distance)
-        print(message)
+print("##############################################################")
+print("AlphaComplex creation from points read in a OFF file")
 
-    else:
-        raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
-                                args.file)
+message = "AlphaComplex with max_edge_length=" + repr(args.threshold)
+print(message)
 
+alpha_complex = gd.AlphaComplex(points=point_cloud)
+alpha_stree = alpha_complex.create_simplex_tree(
+    max_alpha_square=(args.threshold * args.threshold)
+)
 
-    f.close()
+message = "Number of simplices=" + repr(alpha_stree.num_simplices())
+print(message)
+
+alpha_stree.compute_persistence()
+
+max_b_distance = 0.0
+for dim in range(args.max_dimension):
+    # Alpha persistence values needs to be transform because filtration
+    # values are alpha square values
+    alpha_intervals = np.sqrt(alpha_stree.persistence_intervals_in_dimension(dim))
+
+    rips_intervals = rips_stree.persistence_intervals_in_dimension(dim)
+    bottleneck_distance = gd.bottleneck_distance(
+        rips_intervals, alpha_intervals
+    )
+    message = (
+        "In dimension "
+        + repr(dim)
+        + ", bottleneck distance = "
+        + repr(bottleneck_distance)
+    )
+    print(message)
+    max_b_distance = max(bottleneck_distance, max_b_distance)
+
+print("==============================================================")
+message = "Bottleneck distance is " + repr(max_b_distance)
+print(message)
diff --git a/src/python/example/plot_alpha_complex.py b/src/python/example/plot_alpha_complex.py
index 99c18a7c..0924619b 100755
--- a/src/python/example/plot_alpha_complex.py
+++ b/src/python/example/plot_alpha_complex.py
@@ -1,8 +1,9 @@
 #!/usr/bin/env python
 
 import numpy as np
-import gudhi
-ac = gudhi.AlphaComplex(off_file='../../data/points/tore3D_1307.off')
+import gudhi as gd
+points = gd.read_points_from_off_file(off_file = '../../data/points/tore3D_1307.off')
+ac = gd.AlphaComplex(points = points)
 st = ac.create_simplex_tree()
 points = np.array([ac.get_point(i) for i in range(st.num_vertices())])
 # We want to plot the alpha-complex with alpha=0.1.
diff --git a/src/python/gudhi/alpha_complex.pyx b/src/python/gudhi/alpha_complex.pyx
index ea128743..a4888914 100644
--- a/src/python/gudhi/alpha_complex.pyx
+++ b/src/python/gudhi/alpha_complex.pyx
@@ -16,7 +16,7 @@ from libcpp.utility cimport pair
 from libcpp.string cimport string
 from libcpp cimport bool
 from libc.stdint cimport intptr_t
-import os
+import warnings
 
 from gudhi.simplex_tree cimport *
 from gudhi.simplex_tree import SimplexTree
@@ -28,66 +28,72 @@ __license__ = "GPL v3"
 
 cdef extern from "Alpha_complex_interface.h" namespace "Gudhi":
     cdef cppclass Alpha_complex_interface "Gudhi::alpha_complex::Alpha_complex_interface":
-        Alpha_complex_interface(vector[vector[double]] points, bool fast_version, bool exact_version) nogil except +
+        Alpha_complex_interface(vector[vector[double]] points, vector[double] weights, bool fast_version, bool exact_version) nogil except +
         vector[double] get_point(int vertex) nogil except +
         void create_simplex_tree(Simplex_tree_interface_full_featured* simplex_tree, double max_alpha_square, bool default_filtration_value) nogil except +
 
 # AlphaComplex python interface
 cdef class AlphaComplex:
-    """AlphaComplex is a simplicial complex constructed from the finite cells
-    of a Delaunay Triangulation.
+    """AlphaComplex is a simplicial complex constructed from the finite cells of a Delaunay Triangulation.
 
-    The filtration value of each simplex is computed as the square of the
-    circumradius of the simplex if the circumsphere is empty (the simplex is
-    then said to be Gabriel), and as the minimum of the filtration values of
-    the codimension 1 cofaces that make it not Gabriel otherwise.
+    The filtration value of each simplex is computed as the square of the circumradius of the simplex if the
+    circumsphere is empty (the simplex is then said to be Gabriel), and as the minimum of the filtration values of the
+    codimension 1 cofaces that make it not Gabriel otherwise.
 
-    All simplices that have a filtration value strictly greater than a given
-    alpha squared value are not inserted into the complex.
+    All simplices that have a filtration value strictly greater than a given alpha squared value are not inserted into
+    the complex.
 
     .. note::
 
-        When Alpha_complex is constructed with an infinite value of alpha, the
-        complex is a Delaunay complex.
-
+        When Alpha_complex is constructed with an infinite value of alpha, the complex is a Delaunay complex.
     """
 
     cdef Alpha_complex_interface * this_ptr
 
     # Fake constructor that does nothing but documenting the constructor
-    def __init__(self, points=None, off_file='', precision='safe'):
+    def __init__(self, points=[], off_file='', weights=None, precision='safe'):
         """AlphaComplex constructor.
 
         :param points: A list of points in d-Dimension.
-        :type points: list of list of double
-
-        Or
+        :type points: Iterable[Iterable[float]]
 
-        :param off_file: An OFF file style name.
+        :param off_file: **[deprecated]** An `OFF file style <fileformats.html#off-file-format>`_ name.
+            If an `off_file` is given with `points` as arguments, only points from the file are taken into account.
         :type off_file: string
 
+        :param weights: A list of weights. If set, the number of weights must correspond to the number of points.
+        :type weights: Iterable[float]
+
         :param precision: Alpha complex precision can be 'fast', 'safe' or 'exact'. Default is 'safe'.
         :type precision: string
+
+        :raises FileNotFoundError: **[deprecated]** If `off_file` is set but not found.
+        :raises ValueError: In case of inconsistency between the number of points and weights.
         """
 
     # The real cython constructor
-    def __cinit__(self, points = None, off_file = '', precision = 'safe'):
+    def __cinit__(self, points = [], off_file = '', weights=None, precision = 'safe'):
         assert precision in ['fast', 'safe', 'exact'], "Alpha complex precision can only be 'fast', 'safe' or 'exact'"
         cdef bool fast = precision == 'fast'
         cdef bool exact = precision == 'exact'
 
-        cdef vector[vector[double]] pts
         if off_file:
-            if os.path.isfile(off_file):
-                points = read_points_from_off_file(off_file = off_file)
-            else:
-                print("file " + off_file + " not found.")
-        if points is None:
-            # Empty Alpha construction
-            points=[]
+            warnings.warn("off_file is a deprecated parameter, please consider using gudhi.read_points_from_off_file",
+                          DeprecationWarning)
+            points = read_points_from_off_file(off_file = off_file)
+
+        # weights are set but is inconsistent with the number of points
+        if weights != None and len(weights) != len(points):
+            raise ValueError("Inconsistency between the number of points and weights")
+
+        # need to copy the points to use them without the gil
+        cdef vector[vector[double]] pts
+        cdef vector[double] wgts
         pts = points
+        if weights != None:
+            wgts = weights
         with nogil:
-            self.this_ptr = new Alpha_complex_interface(pts, fast, exact)
+            self.this_ptr = new Alpha_complex_interface(pts, wgts, fast, exact)
 
     def __dealloc__(self):
         if self.this_ptr != NULL:
diff --git a/src/python/gudhi/simplex_tree.pxd b/src/python/gudhi/simplex_tree.pxd
index 006a24ed..70311ead 100644
--- a/src/python/gudhi/simplex_tree.pxd
+++ b/src/python/gudhi/simplex_tree.pxd
@@ -65,6 +65,7 @@ cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
         vector[vector[pair[int, pair[double, double]]]] compute_extended_persistence_subdiagrams(vector[pair[int, pair[double, double]]] dgm, double min_persistence) nogil
         Simplex_tree_interface_full_featured* collapse_edges(int nb_collapse_iteration) nogil except +
         void reset_filtration(double filtration, int dimension) nogil
+        bint operator==(Simplex_tree_interface_full_featured) nogil
         # Iterators over Simplex tree
         pair[vector[int], double] get_simplex_and_filtration(Simplex_tree_simplex_handle f_simplex) nogil
         Simplex_tree_simplices_iterator get_simplices_iterator_begin() nogil
diff --git a/src/python/gudhi/simplex_tree.pyx b/src/python/gudhi/simplex_tree.pyx
index c3720936..6393343f 100644
--- a/src/python/gudhi/simplex_tree.pyx
+++ b/src/python/gudhi/simplex_tree.pyx
@@ -642,3 +642,10 @@ cdef class SimplexTree:
             self.thisptr = <intptr_t>(ptr.collapse_edges(nb_iter))
             # Delete old pointer
             del ptr
+
+    def __eq__(self, other:SimplexTree):
+        """Test for structural equality
+        :returns: True if the 2 simplex trees are equal, False otherwise.
+        :rtype: bool
+        """
+        return dereference(self.get_ptr()) == dereference(other.get_ptr())
diff --git a/src/python/include/Alpha_complex_factory.h b/src/python/include/Alpha_complex_factory.h
index 3405fdd6..3d20aa8f 100644
--- a/src/python/include/Alpha_complex_factory.h
+++ b/src/python/include/Alpha_complex_factory.h
@@ -31,15 +31,34 @@ namespace Gudhi {
 
 namespace alpha_complex {
 
-template <typename CgalPointType>
-std::vector<double> pt_cgal_to_cython(CgalPointType const& point) {
-  std::vector<double> vd;
-  vd.reserve(point.dimension());
-  for (auto coord = point.cartesian_begin(); coord != point.cartesian_end(); coord++)
-    vd.push_back(CGAL::to_double(*coord));
-  return vd;
-}
+// template Functor that transforms a CGAL point to a vector of double as expected by cython
+template<typename CgalPointType, bool Weighted>
+struct Point_cgal_to_cython;
+
+// Specialized Unweighted Functor
+template<typename CgalPointType>
+struct Point_cgal_to_cython<CgalPointType, false> {
+  std::vector<double> operator()(CgalPointType const& point) const 
+  {
+    std::vector<double> vd;
+    vd.reserve(point.dimension());
+    for (auto coord = point.cartesian_begin(); coord != point.cartesian_end(); coord++)
+      vd.push_back(CGAL::to_double(*coord));
+    return vd;
+  }
+};
 
+// Specialized Weighted Functor
+template<typename CgalPointType>
+struct Point_cgal_to_cython<CgalPointType, true> {
+  std::vector<double> operator()(CgalPointType const& weighted_point) const 
+  {
+    const auto& point = weighted_point.point();
+    return Point_cgal_to_cython<decltype(point), false>()(point);
+  }
+};
+
+// Function that transforms a cython point (aka. a vector of double) to a CGAL point
 template <typename CgalPointType>
 static CgalPointType pt_cython_to_cgal(std::vector<double> const& vec) {
   return CgalPointType(vec.size(), vec.begin(), vec.end());
@@ -51,24 +70,35 @@ class Abstract_alpha_complex {
 
   virtual bool create_simplex_tree(Simplex_tree_interface<>* simplex_tree, double max_alpha_square,
                                    bool default_filtration_value) = 0;
+  
+  virtual std::size_t num_vertices() const = 0;
 
   virtual ~Abstract_alpha_complex() = default;
 };
 
-class Exact_Alphacomplex_dD final : public Abstract_alpha_complex {
+template <bool Weighted = false>
+class Exact_alpha_complex_dD final : public Abstract_alpha_complex {
  private:
   using Kernel = CGAL::Epeck_d<CGAL::Dynamic_dimension_tag>;
-  using Point = typename Kernel::Point_d;
+  using Bare_point = typename Kernel::Point_d;
+  using Point = std::conditional_t<Weighted, typename Kernel::Weighted_point_d,
+                                             typename Kernel::Point_d>;
 
  public:
-  Exact_Alphacomplex_dD(const std::vector<std::vector<double>>& points, bool exact_version)
+  Exact_alpha_complex_dD(const std::vector<std::vector<double>>& points, bool exact_version)
+    : exact_version_(exact_version),
+      alpha_complex_(boost::adaptors::transform(points, pt_cython_to_cgal<Bare_point>)) {
+  }
+
+  Exact_alpha_complex_dD(const std::vector<std::vector<double>>& points,
+                           const std::vector<double>& weights, bool exact_version)
     : exact_version_(exact_version),
-      alpha_complex_(boost::adaptors::transform(points, pt_cython_to_cgal<Point>)) {
+      alpha_complex_(boost::adaptors::transform(points, pt_cython_to_cgal<Bare_point>), weights) {
   }
 
   virtual std::vector<double> get_point(int vh) override {
-    Point const& point = alpha_complex_.get_point(vh);
-    return pt_cgal_to_cython(point);
+    // Can be a Weighted or a Bare point in function of Weighted
+    return Point_cgal_to_cython<Point, Weighted>()(alpha_complex_.get_point(vh));
   }
 
   virtual bool create_simplex_tree(Simplex_tree_interface<>* simplex_tree, double max_alpha_square,
@@ -76,65 +106,49 @@ class Exact_Alphacomplex_dD final : public Abstract_alpha_complex {
     return alpha_complex_.create_complex(*simplex_tree, max_alpha_square, exact_version_, default_filtration_value);
   }
 
+  virtual std::size_t num_vertices() const {
+    return alpha_complex_.num_vertices();
+  }
+
  private:
   bool exact_version_;
-  Alpha_complex<Kernel> alpha_complex_;
+  Alpha_complex<Kernel, Weighted> alpha_complex_;
 };
 
-class Inexact_Alphacomplex_dD final : public Abstract_alpha_complex {
+template <bool Weighted = false>
+class Inexact_alpha_complex_dD final : public Abstract_alpha_complex {
  private:
   using Kernel = CGAL::Epick_d<CGAL::Dynamic_dimension_tag>;
-  using Point = typename Kernel::Point_d;
+  using Bare_point = typename Kernel::Point_d;
+  using Point = std::conditional_t<Weighted, typename Kernel::Weighted_point_d,
+                                             typename Kernel::Point_d>;
 
  public:
-  Inexact_Alphacomplex_dD(const std::vector<std::vector<double>>& points, bool exact_version)
-    : exact_version_(exact_version),
-      alpha_complex_(boost::adaptors::transform(points, pt_cython_to_cgal<Point>)) {
+  Inexact_alpha_complex_dD(const std::vector<std::vector<double>>& points)
+    : alpha_complex_(boost::adaptors::transform(points, pt_cython_to_cgal<Bare_point>)) {
+  }
+
+  Inexact_alpha_complex_dD(const std::vector<std::vector<double>>& points, const std::vector<double>& weights)
+    : alpha_complex_(boost::adaptors::transform(points, pt_cython_to_cgal<Bare_point>), weights) {
   }
 
   virtual std::vector<double> get_point(int vh) override {
-    Point const& point = alpha_complex_.get_point(vh);
-    return pt_cgal_to_cython(point);
+    // Can be a Weighted or a Bare point in function of Weighted
+    return Point_cgal_to_cython<Point, Weighted>()(alpha_complex_.get_point(vh));
   }
   virtual bool create_simplex_tree(Simplex_tree_interface<>* simplex_tree, double max_alpha_square,
                                    bool default_filtration_value) override {
-    return alpha_complex_.create_complex(*simplex_tree, max_alpha_square, exact_version_, default_filtration_value);
+    return alpha_complex_.create_complex(*simplex_tree, max_alpha_square, false, default_filtration_value);
   }
 
- private:
-  bool exact_version_;
-  Alpha_complex<Kernel> alpha_complex_;
-};
-
-template <complexity Complexity>
-class Alphacomplex_3D final : public Abstract_alpha_complex {
- private:
-  using Point = typename Alpha_complex_3d<Complexity, false, false>::Bare_point_3;
-
-  static Point pt_cython_to_cgal_3(std::vector<double> const& vec) {
-    return Point(vec[0], vec[1], vec[2]);
-  }
-
- public:
-  Alphacomplex_3D(const std::vector<std::vector<double>>& points)
-    : alpha_complex_(boost::adaptors::transform(points, pt_cython_to_cgal_3)) {
-  }
-
-  virtual std::vector<double> get_point(int vh) override {
-    Point const& point = alpha_complex_.get_point(vh);
-    return pt_cgal_to_cython(point);
-  }
-
-  virtual bool create_simplex_tree(Simplex_tree_interface<>* simplex_tree, double max_alpha_square,
-                           bool default_filtration_value) override {
-    return alpha_complex_.create_complex(*simplex_tree, max_alpha_square);
+  virtual std::size_t num_vertices() const {
+    return alpha_complex_.num_vertices();
   }
 
  private:
-  Alpha_complex_3d<Complexity, false, false> alpha_complex_;
+  Alpha_complex<Kernel, Weighted> alpha_complex_;
 };
 
-
 }  // namespace alpha_complex
 
 }  // namespace Gudhi
diff --git a/src/python/include/Alpha_complex_interface.h b/src/python/include/Alpha_complex_interface.h
index 23be194d..671af4a4 100644
--- a/src/python/include/Alpha_complex_interface.h
+++ b/src/python/include/Alpha_complex_interface.h
@@ -27,10 +27,23 @@ namespace alpha_complex {
 
 class Alpha_complex_interface {
  public:
-  Alpha_complex_interface(const std::vector<std::vector<double>>& points, bool fast_version, bool exact_version)
-  : points_(points),
-    fast_version_(fast_version),
-    exact_version_(exact_version) {
+  Alpha_complex_interface(const std::vector<std::vector<double>>& points,
+                          const std::vector<double>& weights,
+                          bool fast_version, bool exact_version) {
+    const bool weighted = (weights.size() > 0);
+    if (fast_version) {
+      if (weighted) {
+        alpha_ptr_ = std::make_unique<Inexact_alpha_complex_dD<true>>(points, weights);
+      } else {
+        alpha_ptr_ = std::make_unique<Inexact_alpha_complex_dD<false>>(points);
+      }
+    } else {
+      if (weighted) {
+        alpha_ptr_ = std::make_unique<Exact_alpha_complex_dD<true>>(points, weights, exact_version);
+      } else {
+        alpha_ptr_ = std::make_unique<Exact_alpha_complex_dD<false>>(points, exact_version);
+      }
+    }
   }
 
   std::vector<double> get_point(int vh) {
@@ -39,38 +52,13 @@ class Alpha_complex_interface {
 
   void create_simplex_tree(Simplex_tree_interface<>* simplex_tree, double max_alpha_square,
                            bool default_filtration_value) {
-    if (points_.size() > 0) {
-      std::size_t dimension = points_[0].size();
-      if (dimension == 3 && !default_filtration_value) {
-        if (fast_version_)
-          alpha_ptr_ = std::make_unique<Alphacomplex_3D<Gudhi::alpha_complex::complexity::FAST>>(points_);
-        else if (exact_version_)
-          alpha_ptr_ = std::make_unique<Alphacomplex_3D<Gudhi::alpha_complex::complexity::EXACT>>(points_);
-        else
-          alpha_ptr_ = std::make_unique<Alphacomplex_3D<Gudhi::alpha_complex::complexity::SAFE>>(points_);
-        if (!alpha_ptr_->create_simplex_tree(simplex_tree, max_alpha_square, default_filtration_value)) {
-          // create_simplex_tree will fail if all points are on a plane - Retry with dD by setting dimension to 2
-          dimension--;
-          alpha_ptr_.reset();
-        }
-      }
-      // Not ** else ** because we have to take into account if 3d fails
-      if (dimension != 3 || default_filtration_value) {
-        if (fast_version_) {
-          alpha_ptr_ = std::make_unique<Inexact_Alphacomplex_dD>(points_, exact_version_);
-        } else {
-          alpha_ptr_ = std::make_unique<Exact_Alphacomplex_dD>(points_, exact_version_);
-        }
-        alpha_ptr_->create_simplex_tree(simplex_tree, max_alpha_square, default_filtration_value);
-      }
-    }
+    // Nothing to be done in case of an empty point set
+    if (alpha_ptr_->num_vertices() > 0)
+      alpha_ptr_->create_simplex_tree(simplex_tree, max_alpha_square, default_filtration_value);
   }
 
  private:
   std::unique_ptr<Abstract_alpha_complex> alpha_ptr_;
-  std::vector<std::vector<double>> points_;
-  bool fast_version_;
-  bool exact_version_;
 };
 
 }  // namespace alpha_complex
diff --git a/src/python/test/test_alpha_complex.py b/src/python/test/test_alpha_complex.py
index 814f8289..f15284f3 100755
--- a/src/python/test/test_alpha_complex.py
+++ b/src/python/test/test_alpha_complex.py
@@ -8,10 +8,12 @@
       - YYYY/MM Author: Description of the modification
 """
 
-import gudhi as gd
+from gudhi import AlphaComplex
 import math
 import numpy as np
 import pytest
+import warnings
+
 try:
     # python3
     from itertools import zip_longest
@@ -19,22 +21,24 @@ except ImportError:
     # python2
     from itertools import izip_longest as zip_longest
 
-__author__ = "Vincent Rouvreau"
-__copyright__ = "Copyright (C) 2016 Inria"
-__license__ = "MIT"
 
 
 def _empty_alpha(precision):
-    alpha_complex = gd.AlphaComplex(points=[[0, 0]], precision = precision)
+    alpha_complex = AlphaComplex(precision = precision)
+    assert alpha_complex.__is_defined() == True
+
+def _one_2d_point_alpha(precision):
+    alpha_complex = AlphaComplex(points=[[0, 0]], precision = precision)
     assert alpha_complex.__is_defined() == True
 
 def test_empty_alpha():
     for precision in ['fast', 'safe', 'exact']:
         _empty_alpha(precision)
+        _one_2d_point_alpha(precision)
 
 def _infinite_alpha(precision):
     point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
-    alpha_complex = gd.AlphaComplex(points=point_list, precision = precision)
+    alpha_complex = AlphaComplex(points=point_list, precision = precision)
     assert alpha_complex.__is_defined() == True
 
     simplex_tree = alpha_complex.create_simplex_tree()
@@ -69,18 +73,9 @@ def _infinite_alpha(precision):
     assert point_list[1] == alpha_complex.get_point(1)
     assert point_list[2] == alpha_complex.get_point(2)
     assert point_list[3] == alpha_complex.get_point(3)
-    try:
-        alpha_complex.get_point(4) == []
-    except IndexError:
-        pass
-    else:
-        assert False
-    try:
-        alpha_complex.get_point(125) == []
-    except IndexError:
-        pass
-    else:
-        assert False
+
+    with pytest.raises(IndexError):
+        alpha_complex.get_point(len(point_list))
 
 def test_infinite_alpha():
     for precision in ['fast', 'safe', 'exact']:
@@ -88,7 +83,7 @@ def test_infinite_alpha():
 
 def _filtered_alpha(precision):
     point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
-    filtered_alpha = gd.AlphaComplex(points=point_list, precision = precision)
+    filtered_alpha = AlphaComplex(points=point_list, precision = precision)
 
     simplex_tree = filtered_alpha.create_simplex_tree(max_alpha_square=0.25)
 
@@ -99,18 +94,9 @@ def _filtered_alpha(precision):
     assert point_list[1] == filtered_alpha.get_point(1)
     assert point_list[2] == filtered_alpha.get_point(2)
     assert point_list[3] == filtered_alpha.get_point(3)
-    try:
-        filtered_alpha.get_point(4) == []
-    except IndexError:
-        pass
-    else:
-        assert False
-    try:
-        filtered_alpha.get_point(125) == []
-    except IndexError:
-        pass
-    else:
-        assert False
+
+    with pytest.raises(IndexError):
+        filtered_alpha.get_point(len(point_list))
 
     assert list(simplex_tree.get_filtration()) == [
         ([0], 0.0),
@@ -141,10 +127,10 @@ def _safe_alpha_persistence_comparison(precision):
     embedding2 = [[signal[i], delayed[i]] for i in range(len(time))]
     
     #build alpha complex and simplex tree
-    alpha_complex1 = gd.AlphaComplex(points=embedding1, precision = precision)
+    alpha_complex1 = AlphaComplex(points=embedding1, precision = precision)
     simplex_tree1 = alpha_complex1.create_simplex_tree()
     
-    alpha_complex2 = gd.AlphaComplex(points=embedding2, precision = precision)
+    alpha_complex2 = AlphaComplex(points=embedding2, precision = precision)
     simplex_tree2 = alpha_complex2.create_simplex_tree()
     
     diag1 = simplex_tree1.persistence()
@@ -162,7 +148,7 @@ def test_safe_alpha_persistence_comparison():
 
 def _delaunay_complex(precision):
     point_list = [[0, 0], [1, 0], [0, 1], [1, 1]]
-    filtered_alpha = gd.AlphaComplex(points=point_list, precision = precision)
+    filtered_alpha = AlphaComplex(points=point_list, precision = precision)
 
     simplex_tree = filtered_alpha.create_simplex_tree(default_filtration_value = True)
 
@@ -173,18 +159,11 @@ def _delaunay_complex(precision):
     assert point_list[1] == filtered_alpha.get_point(1)
     assert point_list[2] == filtered_alpha.get_point(2)
     assert point_list[3] == filtered_alpha.get_point(3)
-    try:
-        filtered_alpha.get_point(4) == []
-    except IndexError:
-        pass
-    else:
-        assert False
-    try:
-        filtered_alpha.get_point(125) == []
-    except IndexError:
-        pass
-    else:
-        assert False
+
+    with pytest.raises(IndexError):
+        filtered_alpha.get_point(4)
+    with pytest.raises(IndexError):
+        filtered_alpha.get_point(125)
 
     for filtered_value in simplex_tree.get_filtration():
         assert math.isnan(filtered_value[1])
@@ -198,7 +177,13 @@ def test_delaunay_complex():
         _delaunay_complex(precision)
 
 def _3d_points_on_a_plane(precision, default_filtration_value):
-    alpha = gd.AlphaComplex(off_file='alphacomplexdoc.off', precision = precision)
+    alpha = AlphaComplex(points = [[1.0, 1.0 , 0.0],
+                                      [7.0, 0.0 , 0.0],
+                                      [4.0, 6.0 , 0.0],
+                                      [9.0, 6.0 , 0.0],
+                                      [0.0, 14.0, 0.0],
+                                      [2.0, 19.0, 0.0],
+                                      [9.0, 17.0, 0.0]], precision = precision)
 
     simplex_tree = alpha.create_simplex_tree(default_filtration_value = default_filtration_value)
     assert simplex_tree.dimension() == 2
@@ -206,28 +191,16 @@ def _3d_points_on_a_plane(precision, default_filtration_value):
     assert simplex_tree.num_simplices() == 25
 
 def test_3d_points_on_a_plane():
-    off_file = open("alphacomplexdoc.off", "w")
-    off_file.write("OFF         \n" \
-                   "7 0 0       \n" \
-                   "1.0 1.0  0.0\n" \
-                   "7.0 0.0  0.0\n" \
-                   "4.0 6.0  0.0\n" \
-                   "9.0 6.0  0.0\n" \
-                   "0.0 14.0 0.0\n" \
-                   "2.0 19.0 0.0\n" \
-                   "9.0 17.0 0.0\n"  )
-    off_file.close()
-
     for default_filtration_value in [True, False]:
         for precision in ['fast', 'safe', 'exact']:
             _3d_points_on_a_plane(precision, default_filtration_value)
 
 def _3d_tetrahedrons(precision):
     points = 10*np.random.rand(10, 3)
-    alpha = gd.AlphaComplex(points=points, precision = precision)
+    alpha = AlphaComplex(points = points, precision = precision)
     st_alpha = alpha.create_simplex_tree(default_filtration_value = False)
     # New AlphaComplex for get_point to work
-    delaunay = gd.AlphaComplex(points=points, precision = precision)
+    delaunay = AlphaComplex(points = points, precision = precision)
     st_delaunay = delaunay.create_simplex_tree(default_filtration_value = True)
 
     delaunay_tetra = []
@@ -256,3 +229,60 @@ def _3d_tetrahedrons(precision):
 def test_3d_tetrahedrons():
     for precision in ['fast', 'safe', 'exact']:
         _3d_tetrahedrons(precision)
+
+def test_off_file_deprecation_warning():
+    off_file = open("alphacomplexdoc.off", "w")
+    off_file.write("OFF         \n" \
+                   "7 0 0       \n" \
+                   "1.0 1.0  0.0\n" \
+                   "7.0 0.0  0.0\n" \
+                   "4.0 6.0  0.0\n" \
+                   "9.0 6.0  0.0\n" \
+                   "0.0 14.0 0.0\n" \
+                   "2.0 19.0 0.0\n" \
+                   "9.0 17.0 0.0\n"  )
+    off_file.close()
+
+    with pytest.warns(DeprecationWarning):
+        alpha = AlphaComplex(off_file="alphacomplexdoc.off")
+
+def test_non_existing_off_file():
+    with pytest.warns(DeprecationWarning):
+        with pytest.raises(FileNotFoundError):
+            alpha = AlphaComplex(off_file="pouetpouettralala.toubiloubabdou")
+
+def test_inconsistency_points_and_weights():
+    points = [[1.0, 1.0 , 0.0],
+              [7.0, 0.0 , 0.0],
+              [4.0, 6.0 , 0.0],
+              [9.0, 6.0 , 0.0],
+              [0.0, 14.0, 0.0],
+              [2.0, 19.0, 0.0],
+              [9.0, 17.0, 0.0]]
+    with pytest.raises(ValueError):
+        # 7 points, 8 weights, on purpose
+        alpha = AlphaComplex(points = points,
+                                weights = [1., 2., 3., 4., 5., 6., 7., 8.])
+
+    with pytest.raises(ValueError):
+        # 7 points, 6 weights, on purpose
+        alpha = AlphaComplex(points = points,
+                                weights = [1., 2., 3., 4., 5., 6.])
+
+def _weighted_doc_example(precision):
+    stree = AlphaComplex(points=[[ 1., -1., -1.],
+                                    [-1.,  1., -1.],
+                                    [-1., -1.,  1.],
+                                    [ 1.,  1.,  1.],
+                                    [ 2.,  2.,  2.]],
+                            weights = [4., 4., 4., 4., 1.],
+                            precision = precision).create_simplex_tree()
+
+    assert stree.filtration([0, 1, 2, 3]) == pytest.approx(-1.)
+    assert stree.filtration([0, 1, 3, 4]) == pytest.approx(95.)
+    assert stree.filtration([0, 2, 3, 4]) == pytest.approx(95.)
+    assert stree.filtration([1, 2, 3, 4]) == pytest.approx(95.)
+
+def test_weighted_doc_example():
+    for precision in ['fast', 'safe', 'exact']:
+        _weighted_doc_example(precision)
diff --git a/src/python/test/test_reader_utils.py b/src/python/test/test_reader_utils.py
index e96e0569..fdfddc4b 100755
--- a/src/python/test/test_reader_utils.py
+++ b/src/python/test/test_reader_utils.py
@@ -8,8 +8,9 @@
       - YYYY/MM Author: Description of the modification
 """
 
-import gudhi
+import gudhi as gd
 import numpy as np
+from pytest import raises
 
 __author__ = "Vincent Rouvreau"
 __copyright__ = "Copyright (C) 2017 Inria"
@@ -18,7 +19,7 @@ __license__ = "MIT"
 
 def test_non_existing_csv_file():
     # Try to open a non existing file
-    matrix = gudhi.read_lower_triangular_matrix_from_csv_file(
+    matrix = gd.read_lower_triangular_matrix_from_csv_file(
         csv_file="pouetpouettralala.toubiloubabdou"
     )
     assert matrix == []
@@ -29,7 +30,7 @@ def test_full_square_distance_matrix_csv_file():
     test_file = open("full_square_distance_matrix.csv", "w")
     test_file.write("0;1;2;3;\n1;0;4;5;\n2;4;0;6;\n3;5;6;0;")
     test_file.close()
-    matrix = gudhi.read_lower_triangular_matrix_from_csv_file(
+    matrix = gd.read_lower_triangular_matrix_from_csv_file(
         csv_file="full_square_distance_matrix.csv", separator=";"
     )
     assert matrix == [[], [1.0], [2.0, 4.0], [3.0, 5.0, 6.0]]
@@ -40,7 +41,7 @@ def test_lower_triangular_distance_matrix_csv_file():
     test_file = open("lower_triangular_distance_matrix.csv", "w")
     test_file.write("\n1,\n2,3,\n4,5,6,\n7,8,9,10,")
     test_file.close()
-    matrix = gudhi.read_lower_triangular_matrix_from_csv_file(
+    matrix = gd.read_lower_triangular_matrix_from_csv_file(
         csv_file="lower_triangular_distance_matrix.csv", separator=","
     )
     assert matrix == [[], [1.0], [2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0, 10.0]]
@@ -48,11 +49,11 @@ def test_lower_triangular_distance_matrix_csv_file():
 
 def test_non_existing_persistence_file():
     # Try to open a non existing file
-    persistence = gudhi.read_persistence_intervals_grouped_by_dimension(
+    persistence = gd.read_persistence_intervals_grouped_by_dimension(
         persistence_file="pouetpouettralala.toubiloubabdou"
     )
     assert persistence == []
-    persistence = gudhi.read_persistence_intervals_in_dimension(
+    persistence = gd.read_persistence_intervals_in_dimension(
         persistence_file="pouetpouettralala.toubiloubabdou", only_this_dim=1
     )
     np.testing.assert_array_equal(persistence, [])
@@ -65,21 +66,21 @@ def test_read_persistence_intervals_without_dimension():
         "# Simple persistence diagram without dimension\n2.7 3.7\n9.6 14.\n34.2 34.974\n3. inf"
     )
     test_file.close()
-    persistence = gudhi.read_persistence_intervals_in_dimension(
+    persistence = gd.read_persistence_intervals_in_dimension(
         persistence_file="persistence_intervals_without_dimension.pers"
     )
     np.testing.assert_array_equal(
         persistence, [(2.7, 3.7), (9.6, 14.0), (34.2, 34.974), (3.0, float("Inf"))]
     )
-    persistence = gudhi.read_persistence_intervals_in_dimension(
+    persistence = gd.read_persistence_intervals_in_dimension(
         persistence_file="persistence_intervals_without_dimension.pers", only_this_dim=0
     )
     np.testing.assert_array_equal(persistence, [])
-    persistence = gudhi.read_persistence_intervals_in_dimension(
+    persistence = gd.read_persistence_intervals_in_dimension(
         persistence_file="persistence_intervals_without_dimension.pers", only_this_dim=1
     )
     np.testing.assert_array_equal(persistence, [])
-    persistence = gudhi.read_persistence_intervals_grouped_by_dimension(
+    persistence = gd.read_persistence_intervals_grouped_by_dimension(
         persistence_file="persistence_intervals_without_dimension.pers"
     )
     assert persistence == {
@@ -94,29 +95,29 @@ def test_read_persistence_intervals_with_dimension():
         "# Simple persistence diagram with dimension\n0 2.7 3.7\n1 9.6 14.\n3 34.2 34.974\n1 3. inf"
     )
     test_file.close()
-    persistence = gudhi.read_persistence_intervals_in_dimension(
+    persistence = gd.read_persistence_intervals_in_dimension(
         persistence_file="persistence_intervals_with_dimension.pers"
     )
     np.testing.assert_array_equal(
         persistence, [(2.7, 3.7), (9.6, 14.0), (34.2, 34.974), (3.0, float("Inf"))]
     )
-    persistence = gudhi.read_persistence_intervals_in_dimension(
+    persistence = gd.read_persistence_intervals_in_dimension(
         persistence_file="persistence_intervals_with_dimension.pers", only_this_dim=0
     )
     np.testing.assert_array_equal(persistence, [(2.7, 3.7)])
-    persistence = gudhi.read_persistence_intervals_in_dimension(
+    persistence = gd.read_persistence_intervals_in_dimension(
         persistence_file="persistence_intervals_with_dimension.pers", only_this_dim=1
     )
     np.testing.assert_array_equal(persistence, [(9.6, 14.0), (3.0, float("Inf"))])
-    persistence = gudhi.read_persistence_intervals_in_dimension(
+    persistence = gd.read_persistence_intervals_in_dimension(
         persistence_file="persistence_intervals_with_dimension.pers", only_this_dim=2
     )
     np.testing.assert_array_equal(persistence, [])
-    persistence = gudhi.read_persistence_intervals_in_dimension(
+    persistence = gd.read_persistence_intervals_in_dimension(
         persistence_file="persistence_intervals_with_dimension.pers", only_this_dim=3
     )
     np.testing.assert_array_equal(persistence, [(34.2, 34.974)])
-    persistence = gudhi.read_persistence_intervals_grouped_by_dimension(
+    persistence = gd.read_persistence_intervals_grouped_by_dimension(
         persistence_file="persistence_intervals_with_dimension.pers"
     )
     assert persistence == {
diff --git a/src/python/test/test_simplex_tree.py b/src/python/test/test_simplex_tree.py
index 31c46213..9766ecfe 100755
--- a/src/python/test/test_simplex_tree.py
+++ b/src/python/test/test_simplex_tree.py
@@ -447,4 +447,15 @@ def test_persistence_intervals_in_dimension():
     assert np.array_equal(H2, np.array([[ 0., float("inf")]]))
     # Test empty case
     assert st.persistence_intervals_in_dimension(3).shape == (0, 2)
-    
\ No newline at end of file
+
+def test_equality_operator():
+    st1 = SimplexTree()
+    st2 = SimplexTree()
+
+    assert st1 == st2
+
+    st1.insert([1,2,3], 4.)
+    assert st1 != st2
+
+    st2.insert([1,2,3], 4.)
+    assert st1 == st2