Merge branch 'master' into optimize_silhouettes

12 files changed, 209 insertions, 128 deletions

diff --git a/.github/next_release.md b/.github/next_release.md
index 64bda353..81599b2c 100644
--- a/.github/next_release.md
+++ b/.github/next_release.md
@@ -9,8 +9,8 @@ Below is a list of changes made since GUDHI 3.6.0:
 - [Module](link)
      - ...
 
-- [Module](link)
-     - ...
+- Installation
+     - c++17 is the new minimal standard to compile the library. This implies Visual Studio minimal version is now 2017.
 
 - Miscellaneous
      - The [list of bugs that were solved since GUDHI-3.6.0](https://github.com/GUDHI/gudhi-devel/issues?q=label%3A3.7.0+is%3Aclosed) is available on GitHub.
diff --git a/src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp
new file mode 100644
index 00000000..e7c261f1
--- /dev/null
+++ b/src/Alpha_complex/test/Alpha_complex_dim3_unit_test.cpp
@@ -0,0 +1,117 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    Author(s):       Vincent Rouvreau
+ *
+ *    Copyright (C) 2015 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE "alpha_complex_dim3"
+#include <boost/test/unit_test.hpp>
+#include <boost/mpl/list.hpp>
+
+#include <CGAL/Epick_d.h>
+#include <CGAL/Epeck_d.h>
+
+#include <stdexcept> // std::out_of_range
+#include <string>
+#include <vector>
+
+#include <gudhi/Alpha_complex.h>
+#include <gudhi/Simplex_tree.h>
+
+// Use dynamic_dimension_tag for the user to be able to set dimension
+typedef CGAL::Epeck_d< CGAL::Dynamic_dimension_tag > Exact_kernel_d;
+// Use static dimension_tag for the user not to be able to set dimension
+typedef CGAL::Epeck_d< CGAL::Dimension_tag<3> > Exact_kernel_s;
+// Use dynamic_dimension_tag for the user to be able to set dimension
+typedef CGAL::Epick_d< CGAL::Dynamic_dimension_tag > Inexact_kernel_d;
+// Use static dimension_tag for the user not to be able to set dimension
+typedef CGAL::Epick_d< CGAL::Dimension_tag<3> > Inexact_kernel_s;
+// The triangulation uses the default instantiation of the TriangulationDataStructure template parameter
+
+typedef boost::mpl::list<Exact_kernel_d, Exact_kernel_s, Inexact_kernel_d, Inexact_kernel_s> list_of_kernel_variants;
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_OFF_file, TestedKernel, list_of_kernel_variants) {
+  // ----------------------------------------------------------------------------
+  //
+  // Init of an alpha-complex from a OFF file
+  //
+  // ----------------------------------------------------------------------------
+  std::string off_file_name("alphacomplexdoc.off");
+  double max_alpha_square_value = 60.0;
+  std::clog << "========== OFF FILE NAME = " << off_file_name << " - alpha²=" <<
+      max_alpha_square_value << "==========" << std::endl;
+
+  Gudhi::alpha_complex::Alpha_complex<TestedKernel> alpha_complex_from_file(off_file_name);
+
+  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);
+
+  std::clog << "simplex_tree_60.num_vertices()=" << simplex_tree_60.num_vertices() << std::endl;
+  BOOST_CHECK(simplex_tree_60.num_vertices() == 7);
+
+  std::clog << "simplex_tree_60.num_simplices()=" << simplex_tree_60.num_simplices() << std::endl;
+  BOOST_CHECK(simplex_tree_60.num_simplices() == 25);
+
+  max_alpha_square_value = 59.0;
+  std::clog << "========== OFF FILE NAME = " << off_file_name << " - alpha²=" <<
+      max_alpha_square_value << "==========" << std::endl;
+
+  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);
+
+  std::clog << "simplex_tree_59.num_vertices()=" << simplex_tree_59.num_vertices() << std::endl;
+  BOOST_CHECK(simplex_tree_59.num_vertices() == 7);
+
+  std::clog << "simplex_tree_59.num_simplices()=" << simplex_tree_59.num_simplices() << std::endl;
+  BOOST_CHECK(simplex_tree_59.num_simplices() == 23);
+}
+
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_empty_points, TestedKernel, list_of_kernel_variants) {
+  std::clog << "========== Alpha_complex_from_empty_points ==========" << std::endl;
+
+  // ----------------------------------------------------------------------------
+  // Init of an empty list of points
+  // ----------------------------------------------------------------------------
+  std::vector<typename TestedKernel::Point_d> points;
+
+  // ----------------------------------------------------------------------------
+  // Init of an alpha complex from the list of points
+  // ----------------------------------------------------------------------------
+  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);
+
+  Gudhi::Simplex_tree<> simplex_tree;
+  BOOST_CHECK(!alpha_complex_from_points.create_complex(simplex_tree));
+  
+  std::clog << "simplex_tree.num_simplices()=" << simplex_tree.num_simplices() << std::endl;
+  BOOST_CHECK(simplex_tree.num_simplices() == 0);
+
+  std::clog << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl;
+  BOOST_CHECK(simplex_tree.dimension() == -1);
+  
+  std::clog << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices() << std::endl;
+  BOOST_CHECK(simplex_tree.num_vertices() == points.size());
+}
diff --git a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
index f74ad217..b474917f 100644
--- a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
+++ b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
@@ -13,81 +13,17 @@
 #include <boost/test/unit_test.hpp>
 #include <boost/mpl/list.hpp>
 
-#include <CGAL/Delaunay_triangulation.h>
 #include <CGAL/Epick_d.h>
 #include <CGAL/Epeck_d.h>
 
-#include <cmath>  // float comparison
-#include <limits>
+#include <stdexcept> // std::out_of_range
 #include <string>
 #include <vector>
 
 #include <gudhi/Alpha_complex.h>
-// to construct a simplex_tree from Delaunay_triangulation
-#include <gudhi/graph_simplicial_complex.h>
 #include <gudhi/Simplex_tree.h>
 #include <gudhi/Unitary_tests_utils.h>
 
-// Use dynamic_dimension_tag for the user to be able to set dimension
-typedef CGAL::Epeck_d< CGAL::Dynamic_dimension_tag > Exact_kernel_d;
-// Use static dimension_tag for the user not to be able to set dimension
-typedef CGAL::Epeck_d< CGAL::Dimension_tag<3> > Exact_kernel_s;
-// Use dynamic_dimension_tag for the user to be able to set dimension
-typedef CGAL::Epick_d< CGAL::Dynamic_dimension_tag > Inexact_kernel_d;
-// Use static dimension_tag for the user not to be able to set dimension
-typedef CGAL::Epick_d< CGAL::Dimension_tag<3> > Inexact_kernel_s;
-// The triangulation uses the default instantiation of the TriangulationDataStructure template parameter
-
-typedef boost::mpl::list<Exact_kernel_d, Exact_kernel_s, Inexact_kernel_d, Inexact_kernel_s> list_of_kernel_variants;
-
-BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_OFF_file, TestedKernel, list_of_kernel_variants) {
-  // ----------------------------------------------------------------------------
-  //
-  // Init of an alpha-complex from a OFF file
-  //
-  // ----------------------------------------------------------------------------
-  std::string off_file_name("alphacomplexdoc.off");
-  double max_alpha_square_value = 60.0;
-  std::clog << "========== OFF FILE NAME = " << off_file_name << " - alpha²=" <<
-      max_alpha_square_value << "==========" << std::endl;
-
-  Gudhi::alpha_complex::Alpha_complex<TestedKernel> alpha_complex_from_file(off_file_name);
-
-  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);
-
-  std::clog << "simplex_tree_60.num_vertices()=" << simplex_tree_60.num_vertices() << std::endl;
-  BOOST_CHECK(simplex_tree_60.num_vertices() == 7);
-
-  std::clog << "simplex_tree_60.num_simplices()=" << simplex_tree_60.num_simplices() << std::endl;
-  BOOST_CHECK(simplex_tree_60.num_simplices() == 25);
-
-  max_alpha_square_value = 59.0;
-  std::clog << "========== OFF FILE NAME = " << off_file_name << " - alpha²=" <<
-      max_alpha_square_value << "==========" << std::endl;
-
-  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);
-
-  std::clog << "simplex_tree_59.num_vertices()=" << simplex_tree_59.num_vertices() << std::endl;
-  BOOST_CHECK(simplex_tree_59.num_vertices() == 7);
-
-  std::clog << "simplex_tree_59.num_simplices()=" << simplex_tree_59.num_simplices() << std::endl;
-  BOOST_CHECK(simplex_tree_59.num_simplices() == 23);
-}
-
 // Use static dimension_tag for the user not to be able to set dimension
 typedef CGAL::Epeck_d< CGAL::Dimension_tag<4> > Kernel_4;
 typedef Kernel_4::Point_d Point_4;
@@ -236,37 +172,6 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) {
 
 }
 
-BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_empty_points, TestedKernel, list_of_kernel_variants) {
-  std::clog << "========== Alpha_complex_from_empty_points ==========" << std::endl;
-
-  // ----------------------------------------------------------------------------
-  // Init of an empty list of points
-  // ----------------------------------------------------------------------------
-  std::vector<typename TestedKernel::Point_d> points;
-
-  // ----------------------------------------------------------------------------
-  // Init of an alpha complex from the list of points
-  // ----------------------------------------------------------------------------
-  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);
-
-  Gudhi::Simplex_tree<> simplex_tree;
-  BOOST_CHECK(!alpha_complex_from_points.create_complex(simplex_tree));
-  
-  std::clog << "simplex_tree.num_simplices()=" << simplex_tree.num_simplices() << std::endl;
-  BOOST_CHECK(simplex_tree.num_simplices() == 0);
-
-  std::clog << "simplex_tree.dimension()=" << simplex_tree.dimension() << std::endl;
-  BOOST_CHECK(simplex_tree.dimension() == -1);
-  
-  std::clog << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices() << std::endl;
-  BOOST_CHECK(simplex_tree.num_vertices() == points.size());
-}
 
 using Inexact_kernel_2 = CGAL::Epick_d< CGAL::Dimension_tag<2> >;
 using Exact_kernel_2 = CGAL::Epeck_d< CGAL::Dimension_tag<2> >;
diff --git a/src/Alpha_complex/test/CMakeLists.txt b/src/Alpha_complex/test/CMakeLists.txt
index 0595ca92..dd2c235f 100644
--- a/src/Alpha_complex/test/CMakeLists.txt
+++ b/src/Alpha_complex/test/CMakeLists.txt
@@ -8,14 +8,18 @@ if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
 
   add_executable ( Alpha_complex_test_unit Alpha_complex_unit_test.cpp )
   target_link_libraries(Alpha_complex_test_unit ${CGAL_LIBRARY})
+  add_executable ( Alpha_complex_dim3_test_unit Alpha_complex_dim3_unit_test.cpp )
+  target_link_libraries(Alpha_complex_dim3_test_unit ${CGAL_LIBRARY})
   add_executable ( Delaunay_complex_test_unit Delaunay_complex_unit_test.cpp )
   target_link_libraries(Delaunay_complex_test_unit ${CGAL_LIBRARY})
   if (TBB_FOUND)
     target_link_libraries(Alpha_complex_test_unit ${TBB_LIBRARIES})
+    target_link_libraries(Alpha_complex_dim3_test_unit ${TBB_LIBRARIES})
     target_link_libraries(Delaunay_complex_test_unit ${TBB_LIBRARIES})
   endif()
 
   gudhi_add_boost_test(Alpha_complex_test_unit)
+  gudhi_add_boost_test(Alpha_complex_dim3_test_unit)
   gudhi_add_boost_test(Delaunay_complex_test_unit)
 
 endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
@@ -73,4 +77,4 @@ if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
   endif()
   gudhi_add_boost_test(Zero_weighted_alpha_complex_test_unit)
 
-endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
\ No newline at end of file
+endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
diff --git a/src/Cech_complex/utilities/CMakeLists.txt b/src/Cech_complex/utilities/CMakeLists.txt
index e80a698e..64557cee 100644
--- a/src/Cech_complex/utilities/CMakeLists.txt
+++ b/src/Cech_complex/utilities/CMakeLists.txt
@@ -9,8 +9,24 @@ if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.0.1)
       target_link_libraries(cech_persistence ${TBB_LIBRARIES})
     endif()
 
-    add_test(NAME Cech_complex_utility_from_rips_on_tore_3D COMMAND $<TARGET_FILE:cech_persistence>
-        "${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off" "-r" "0.25" "-m" "0.5" "-d" "3" "-p" "3")
+    add_test(NAME Cech_complex_utility_from_rips_on_tore_3D_safe COMMAND $<TARGET_FILE:cech_persistence>
+        "${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off" "-r" "0.25" "-m" "0.5" "-d" "3" "-p" "3" "-o" "safe.pers")
+    add_test(NAME Cech_complex_utility_from_rips_on_tore_3D_fast COMMAND $<TARGET_FILE:cech_persistence>
+        "${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off" "-r" "0.25" "-m" "0.5" "-d" "3" "-p" "3" "-o" "fast.pers" "-f")
+    add_test(NAME Cech_complex_utility_from_rips_on_tore_3D_exact COMMAND $<TARGET_FILE:cech_persistence>
+        "${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off" "-r" "0.25" "-m" "0.5" "-d" "3" "-p" "3" "-o" "exact.pers" "-e")
+
+    if (DIFF_PATH)
+      add_test(Cech_complex_utilities_diff_exact ${DIFF_PATH}
+               "exact.pers" "safe.pers")
+      set_tests_properties(Cech_complex_utilities_diff_exact PROPERTIES DEPENDS
+               "Cech_complex_utility_from_rips_on_tore_3D_safe;Cech_complex_utility_from_rips_on_tore_3D_exact")
+
+      add_test(Cech_complex_utilities_diff_fast ${DIFF_PATH}
+               "fast.pers" "safe.pers")
+      set_tests_properties(Cech_complex_utilities_diff_fast PROPERTIES DEPENDS
+               "Cech_complex_utility_from_rips_on_tore_3D_safe;Cech_complex_utility_from_rips_on_tore_3D_fast")
+    endif()
 
     install(TARGETS cech_persistence DESTINATION bin)
   endif()
diff --git a/src/Cech_complex/utilities/cech_persistence.cpp b/src/Cech_complex/utilities/cech_persistence.cpp
index 75d10c0f..a07ba212 100644
--- a/src/Cech_complex/utilities/cech_persistence.cpp
+++ b/src/Cech_complex/utilities/cech_persistence.cpp
@@ -16,6 +16,7 @@
 #include <boost/program_options.hpp>
 
 #include <CGAL/Epeck_d.h>  // For EXACT or SAFE version
+#include <CGAL/Epick_d.h>  // For FAST version
 
 #include <string>
 #include <vector>
@@ -25,41 +26,66 @@
 using Simplex_tree = Gudhi::Simplex_tree<Gudhi::Simplex_tree_options_fast_persistence>;
 using Filtration_value = Simplex_tree::Filtration_value;
 
-using Kernel = CGAL::Epeck_d<CGAL::Dynamic_dimension_tag>;
-using Point = typename Kernel::Point_d;
-using Points_off_reader = Gudhi::Points_off_reader<Point>;
-using Cech_complex = Gudhi::cech_complex::Cech_complex<Kernel, Simplex_tree>;
 using Field_Zp = Gudhi::persistent_cohomology::Field_Zp;
 using Persistent_cohomology = Gudhi::persistent_cohomology::Persistent_cohomology<Simplex_tree, Field_Zp>;
 
-void program_options(int argc, char* argv[], std::string& off_file_points, std::string& filediag,
-                     Filtration_value& max_radius, int& dim_max, int& p, Filtration_value& min_persistence);
+void program_options(int argc, char* argv[], std::string& off_file_points, bool& exact, bool& fast,
+                     std::string& filediag, Filtration_value& max_radius, int& dim_max, int& p,
+                     Filtration_value& min_persistence);
+
+template<class Kernel>
+Simplex_tree create_simplex_tree(const std::string &off_file_points, bool exact_version,
+                                 Filtration_value max_radius, int dim_max) {
+  using Point = typename Kernel::Point_d;
+  using Points_off_reader = Gudhi::Points_off_reader<Point>;
+  using Cech_complex = Gudhi::cech_complex::Cech_complex<Kernel, Simplex_tree>;
+
+  Simplex_tree stree;
+
+  Points_off_reader off_reader(off_file_points);
+  Cech_complex cech_complex_from_file(off_reader.get_point_cloud(), max_radius, exact_version);
+  cech_complex_from_file.create_complex(stree, dim_max);
+
+  return stree;
+}
 
 int main(int argc, char* argv[]) {
   std::string off_file_points;
   std::string filediag;
+  bool exact_version = false;
+  bool fast_version = false;
   Filtration_value max_radius;
   int dim_max;
   int p;
   Filtration_value min_persistence;
 
-  program_options(argc, argv, off_file_points, filediag, max_radius, dim_max, p, min_persistence);
+  program_options(argc, argv, off_file_points, exact_version, fast_version, filediag, max_radius, dim_max, p,
+                  min_persistence);
 
-  Points_off_reader off_reader(off_file_points);
-  Cech_complex cech_complex_from_file(off_reader.get_point_cloud(), max_radius);
+  if ((exact_version) && (fast_version)) {
+    std::cerr << "You cannot set the exact and the fast version." << std::endl;
+    exit(-1);
+  }
 
-  // Construct the Cech complex in a Simplex Tree
-  Simplex_tree simplex_tree;
+  Simplex_tree stree;
+  if (fast_version) {
+    // WARNING : CGAL::Epick_d is fast but not safe (unlike CGAL::Epeck_d)
+    // (i.e. when the points are on a grid)
+    using Fast_kernel = CGAL::Epick_d<CGAL::Dynamic_dimension_tag>;
+    stree = create_simplex_tree<Fast_kernel>(off_file_points, exact_version, max_radius, dim_max);
+  } else {
+    using Kernel = CGAL::Epeck_d<CGAL::Dynamic_dimension_tag>;
+    stree = create_simplex_tree<Kernel>(off_file_points, exact_version, max_radius, dim_max);
+  }
 
-  cech_complex_from_file.create_complex(simplex_tree, dim_max);
-  std::clog << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
-  std::clog << "   and has dimension " << simplex_tree.dimension() << " \n";
+  std::clog << "The complex contains " << stree.num_simplices() << " simplices \n";
+  std::clog << "   and has dimension " << stree.dimension() << " \n";
 
   // Sort the simplices in the order of the filtration
-  simplex_tree.initialize_filtration();
+  stree.initialize_filtration();
 
   // Compute the persistence diagram of the complex
-  Persistent_cohomology pcoh(simplex_tree);
+  Persistent_cohomology pcoh(stree);
   // initializes the coefficient field for homology
   pcoh.init_coefficients(p);
 
@@ -77,8 +103,9 @@ int main(int argc, char* argv[]) {
   return 0;
 }
 
-void program_options(int argc, char* argv[], std::string& off_file_points, std::string& filediag,
-                     Filtration_value& max_radius, int& dim_max, int& p, Filtration_value& min_persistence) {
+void program_options(int argc, char* argv[], std::string& off_file_points, bool& exact, bool& fast,
+                     std::string& filediag, Filtration_value& max_radius, int& dim_max, int& p,
+                     Filtration_value& min_persistence) {
   namespace po = boost::program_options;
   po::options_description hidden("Hidden options");
   hidden.add_options()("input-file", po::value<std::string>(&off_file_points),
@@ -86,6 +113,10 @@ void program_options(int argc, char* argv[], std::string& off_file_points, std::
 
   po::options_description visible("Allowed options", 100);
   visible.add_options()("help,h", "produce help message")(
+      "exact,e", po::bool_switch(&exact),
+      "To activate exact version of Cech complex (default is false, not available if fast is set)")(
+      "fast,f", po::bool_switch(&fast),
+      "To activate fast version of Cech complex (default is false, not available if exact is set)")(
       "output-file,o", po::value<std::string>(&filediag)->default_value(std::string()),
       "Name of file in which the persistence diagram is written. Default print in std::clog")(
       "max-radius,r",
diff --git a/src/Cech_complex/utilities/cechcomplex.md b/src/Cech_complex/utilities/cechcomplex.md
index 821e4dad..0e82674d 100644
--- a/src/Cech_complex/utilities/cechcomplex.md
+++ b/src/Cech_complex/utilities/cechcomplex.md
@@ -26,7 +26,11 @@ a prime number).
 
 **Usage**
 
-`cech_persistence [options] <OFF input file>`
+`cech_persistence [options] <input OFF file>`
+
+where
+`<input OFF file>` is the path to the input point cloud in
+[nOFF ASCII format]({{ site.officialurl }}/doc/latest/fileformats.html#FileFormatsOFF).
 
 **Allowed options**
 
@@ -36,6 +40,8 @@ a prime number).
 * `-d [ --cpx-dimension ]` (default = 1) Maximal dimension of the Čech complex we want to compute.
 * `-p [ --field-charac ]` (default = 11) Characteristic p of the coefficient field Z/pZ for computing homology.
 * `-m [ --min-persistence ]` (default = 0) Minimal lifetime of homology feature to be recorded. Enter a negative value to see zero length intervals.
+* `-e [ --exact ]` for the exact computation version.
+* `-f [ --fast ]` for the fast computation version.
 
 Beware: this program may use a lot of RAM and take a lot of time if `max-edge-length` is set to a large value.
 
diff --git a/src/Tangential_complex/benchmark/XML_exporter.h b/src/Tangential_complex/benchmark/XML_exporter.h
index 16b62eb6..38fe049f 100644
--- a/src/Tangential_complex/benchmark/XML_exporter.h
+++ b/src/Tangential_complex/benchmark/XML_exporter.h
@@ -157,7 +157,7 @@ class Streaming_XML_exporter {
       m_xml_fstream << "  </" << m_element_name << ">" << std::endl;
 
       // Save current pointer position
-      std::ofstream::streampos pos = m_xml_fstream.tellp();
+      auto pos = m_xml_fstream.tellp();
       // Close the XML file (temporarily) so that the XML file is always correct
       m_xml_fstream << "</" << m_list_name << ">" << std::endl;
       // Restore the pointer position so that the next "add_element" will overwrite
diff --git a/src/cmake/modules/GUDHI_compilation_flags.cmake b/src/cmake/modules/GUDHI_compilation_flags.cmake
index 567fbc40..e2d3d872 100644
--- a/src/cmake/modules/GUDHI_compilation_flags.cmake
+++ b/src/cmake/modules/GUDHI_compilation_flags.cmake
@@ -11,7 +11,7 @@ macro(add_cxx_compiler_flag _flag)
   endif()
 endmacro()
 
-set (CMAKE_CXX_STANDARD 14)
+set (CMAKE_CXX_STANDARD 17)
 
 enable_testing()
 
diff --git a/src/common/doc/installation.h b/src/common/doc/installation.h
index 63a37a25..f2f8a476 100644
--- a/src/common/doc/installation.h
+++ b/src/common/doc/installation.h
@@ -5,9 +5,9 @@
  * 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="https://www.boost.org/">Boost</a>  &ge; 1.66.0
+ * The library uses c++17 and requires <a target="_blank" href="https://www.boost.org/">Boost</a>  &ge; 1.66.0
  * and <a target="_blank" href="https://cmake.org/">CMake</a> &ge; 3.5.
- * It is a multi-platform library and compiles on Linux, Mac OSX and Visual Studio 2015.
+ * It is a multi-platform library and compiles on Linux, Mac OSX and Visual Studio 2017.
  * 
  * \subsection utilities Utilities and examples
  * To build the utilities, run the following commands in a terminal:
diff --git a/src/python/doc/installation.rst b/src/python/doc/installation.rst
index 4eefd415..b704f778 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.66.0,
+The library uses c++17 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/gudhi/persistence_graphical_tools.py b/src/python/gudhi/persistence_graphical_tools.py
index 21275cdd..e438aa66 100644
--- a/src/python/gudhi/persistence_graphical_tools.py
+++ b/src/python/gudhi/persistence_graphical_tools.py
@@ -194,19 +194,21 @@ def plot_persistence_barcode(
         y=[(death - birth) if death != float("inf") else (infinity - birth) for (dim,(birth,death)) in persistence]
         c=[colormap[dim] for (dim,(birth,death)) in persistence]
 
-        axes.barh(list(reversed(range(len(x)))), y, height=0.8, left=x, alpha=alpha, color=c, linewidth=0)
+        axes.barh(range(len(x)), y, left=x, alpha=alpha, color=c, linewidth=0)
 
         if legend:
-            dimensions = list(set(item[0] for item in persistence))
+            dimensions = set(item[0] for item in persistence)
             axes.legend(
                 handles=[mpatches.Patch(color=colormap[dim], label=str(dim)) for dim in dimensions], loc="lower right",
             )
 
         axes.set_title("Persistence barcode", fontsize=fontsize)
+        axes.set_yticks([])
+        axes.invert_yaxis()
 
         # Ends plot on infinity value and starts a little bit before min_birth
         if len(x) != 0:
-            axes.axis([axis_start, infinity, 0, len(x)])
+            axes.set_xlim((axis_start, infinity))
         return axes
 
     except ImportError as import_error: