Remove cech_complex_step_by_step example and Miniball

8 files changed, 1 insertions, 719 deletions

diff --git a/src/Cech_complex/doc/Intro_cech_complex.h b/src/Cech_complex/doc/Intro_cech_complex.h
index 644fd6cc..595fb64b 100644
--- a/src/Cech_complex/doc/Intro_cech_complex.h
+++ b/src/Cech_complex/doc/Intro_cech_complex.h
@@ -62,10 +62,6 @@ namespace cech_complex {
  * This radius computation is the reason why the Cech_complex is taking much more time to be computed than the
  * \ref rips_complex but it offers more topological guarantees.
  *
- * If the Cech_complex interfaces are not detailed enough for your need, please refer to
- * <a href="cech_complex_step_by_step_8cpp-example.html">
- * cech_complex_step_by_step.cpp</a> example, where the graph construction over the Simplex_tree is more detailed.
- *
  * \subsection cechpointscloudexample Example from a point cloud
  * 
  * This example builds the proximity graph from the given points, and maximal radius values.
diff --git a/src/Cech_complex/example/CMakeLists.txt b/src/Cech_complex/example/CMakeLists.txt
index 4d11ace2..7d52ed5e 100644
--- a/src/Cech_complex/example/CMakeLists.txt
+++ b/src/Cech_complex/example/CMakeLists.txt
@@ -1,16 +1,6 @@
 project(Cech_complex_examples)
 
 if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.0.1)
-  if (TARGET Boost::program_options)
-    add_executable ( Cech_complex_example_step_by_step cech_complex_step_by_step.cpp )
-    target_link_libraries(Cech_complex_example_step_by_step Boost::program_options)
-    if (TBB_FOUND)
-      target_link_libraries(Cech_complex_example_step_by_step ${TBB_LIBRARIES})
-    endif()
-    add_test(NAME Cech_complex_utility_from_rips_on_tore_3D COMMAND $<TARGET_FILE:Cech_complex_example_step_by_step>
-        "${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off" "-r" "0.25" "-d" "3")
-  endif()
-
   add_executable ( Cech_complex_example_from_points cech_complex_example_from_points.cpp)
   if (TBB_FOUND)
     target_link_libraries(Cech_complex_example_from_points ${TBB_LIBRARIES})
diff --git a/src/Cech_complex/example/cech_complex_step_by_step.cpp b/src/Cech_complex/example/cech_complex_step_by_step.cpp
deleted file mode 100644
index 4401f6af..00000000
--- a/src/Cech_complex/example/cech_complex_step_by_step.cpp
+++ /dev/null
@@ -1,150 +0,0 @@
-/*    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) 2018 Inria
- *
- *    Modification(s):
- *      - YYYY/MM Author: Description of the modification
- */
-
-#include <gudhi/graph_simplicial_complex.h>
-#include <gudhi/sphere_circumradius.h>
-#include <gudhi/Simplex_tree.h>
-#include <gudhi/Points_off_io.h>
-
-#include <CGAL/Epeck_d.h>
-
-#include <boost/program_options.hpp>
-
-#include <string>
-#include <vector>
-#include <limits>   // infinity
-#include <utility>  // for pair
-#include <map>
-
-// ----------------------------------------------------------------------------
-// cech_complex_step_by_step is an example of each step that is required to
-// build a Cech over a Simplex_tree. Please refer to cech_complex_example_from_points to see
-// how to do the same thing with the Cech complex wrapper for less detailed
-// steps.
-// ----------------------------------------------------------------------------
-
-// Types definition
-using Simplex_tree = Gudhi::Simplex_tree<>;
-using Simplex_handle = Simplex_tree::Simplex_handle;
-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 Proximity_graph = Gudhi::Proximity_graph<Simplex_tree>;
-
-class Cech_blocker {
- private:
-  using Point_cloud = std::vector<Point>;
-
- public:
-  bool operator()(Simplex_handle sh) {
-    std::vector<Point> points;
-    for (auto vertex : simplex_tree_.simplex_vertex_range(sh)) {
-      points.push_back(point_cloud_[vertex]);
-#ifdef DEBUG_TRACES
-      std::clog << "#(" << vertex << ")#";
-#endif  // DEBUG_TRACES
-    }
-    Filtration_value radius = Gudhi::cech_complex::Sphere_circumradius<Kernel>()(points);
-#ifdef DEBUG_TRACES
-    std::clog << "radius = " << radius << " - " << (radius > max_radius_) << std::endl;
-#endif  // DEBUG_TRACES
-    simplex_tree_.assign_filtration(sh, radius);
-    return (radius > max_radius_);
-  }
-  Cech_blocker(Simplex_tree& simplex_tree, Filtration_value max_radius, const std::vector<Point>& point_cloud)
-      : simplex_tree_(simplex_tree), max_radius_(max_radius), point_cloud_(point_cloud) {
-  }
-
- private:
-  Simplex_tree simplex_tree_;
-  Filtration_value max_radius_;
-  std::vector<Point> point_cloud_;
-};
-
-void program_options(int argc, char* argv[], std::string& off_file_points, Filtration_value& max_radius, int& dim_max);
-
-int main(int argc, char* argv[]) {
-  std::string off_file_points;
-  Filtration_value max_radius;
-  int dim_max;
-
-  program_options(argc, argv, off_file_points, max_radius, dim_max);
-
-  // Extract the points from the file filepoints
-  Points_off_reader off_reader(off_file_points);
-
-  // Compute the proximity graph of the points
-  Proximity_graph prox_graph = Gudhi::compute_proximity_graph<Simplex_tree>(off_reader.get_point_cloud(), max_radius,
-                                                                            Gudhi::cech_complex::Sphere_circumradius<Kernel>());
-
-  // Construct the Cech complex in a Simplex Tree
-  Simplex_tree st;
-  // insert the proximity graph in the simplex tree
-  st.insert_graph(prox_graph);
-  // expand the graph until dimension dim_max
-  st.expansion_with_blockers(dim_max, Cech_blocker(st, max_radius, off_reader.get_point_cloud()));
-
-  std::clog << "The complex contains " << st.num_simplices() << " simplices \n";
-  std::clog << "   and has dimension " << st.dimension() << " \n";
-
-  // Sort the simplices in the order of the filtration
-  st.initialize_filtration();
-
-#if DEBUG_TRACES
-  std::clog << "********************************************************************\n";
-  std::clog << "* The complex contains " << st.num_simplices() << " simplices - dimension=" << st.dimension() << "\n";
-  std::clog << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
-  for (auto f_simplex : st.filtration_simplex_range()) {
-    std::clog << "   "
-              << "[" << st.filtration(f_simplex) << "] ";
-    for (auto vertex : st.simplex_vertex_range(f_simplex)) {
-      std::clog << static_cast<int>(vertex) << " ";
-    }
-    std::clog << std::endl;
-  }
-#endif  // DEBUG_TRACES
-
-  return 0;
-}
-
-void program_options(int argc, char* argv[], std::string& off_file_points, Filtration_value& max_radius, int& dim_max) {
-  namespace po = boost::program_options;
-  po::options_description hidden("Hidden options");
-  hidden.add_options()("input-file", po::value<std::string>(&off_file_points),
-                       "Name of an OFF file containing a point set.\n");
-
-  po::options_description visible("Allowed options", 100);
-  visible.add_options()("help,h", "produce help message")(
-      "max-radius,r",
-      po::value<Filtration_value>(&max_radius)->default_value(std::numeric_limits<Filtration_value>::infinity()),
-      "Maximal length of an edge for the Cech complex construction.")(
-      "cpx-dimension,d", po::value<int>(&dim_max)->default_value(1),
-      "Maximal dimension of the Cech complex we want to compute.");
-
-  po::positional_options_description pos;
-  pos.add("input-file", 1);
-
-  po::options_description all;
-  all.add(visible).add(hidden);
-
-  po::variables_map vm;
-  po::store(po::command_line_parser(argc, argv).options(all).positional(pos).run(), vm);
-  po::notify(vm);
-
-  if (vm.count("help") || !vm.count("input-file")) {
-    std::clog << std::endl;
-    std::clog << "Construct a Cech complex defined on a set of input points.\n \n";
-
-    std::clog << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
-    std::clog << visible << std::endl;
-    exit(-1);
-  }
-}
diff --git a/src/Cech_complex/include/gudhi/Miniball.COPYRIGHT b/src/Cech_complex/include/gudhi/Miniball.COPYRIGHT
deleted file mode 100644
index dbe4c553..00000000
--- a/src/Cech_complex/include/gudhi/Miniball.COPYRIGHT
+++ /dev/null
@@ -1,4 +0,0 @@
-The miniball software is available under the GNU General Public License (GPLv3 - https://www.gnu.org/copyleft/gpl.html).
-If your intended use is not compliant with this license, please buy a commercial license (EUR 500 - https://people.inf.ethz.ch/gaertner/subdir/software/miniball/license.html).
-You need a license if the software that you develop using Miniball V3.0 is not open source.
-
diff --git a/src/Cech_complex/include/gudhi/Miniball.README b/src/Cech_complex/include/gudhi/Miniball.README
deleted file mode 100644
index 033d8953..00000000
--- a/src/Cech_complex/include/gudhi/Miniball.README
+++ /dev/null
@@ -1,26 +0,0 @@
-https://people.inf.ethz.ch/gaertner/subdir/software/miniball.html
-
-Smallest Enclosing Balls of Points - Fast and Robust in C++.
-(high-quality software for smallest enclosing balls of balls is available in the computational geometry algorithms library CGAL)
-
-
-This is the miniball software (V3.0) for computing smallest enclosing balls of points in arbitrary dimensions. It consists of a C++ header file Miniball.hpp (around 500 lines of code) and two example programs miniball_example.cpp and miniball_example_containers.cpp that demonstrate the usage. The first example stores the coordinates of the input points in a two-dimensional array, the second example uses a list of vectors to show how generic containers can be used.
-
-Credits: Aditya Gupta and Alexandros Konstantinakis-Karmis have significantly contributed to this version of the software.
-
-Changes - https://people.inf.ethz.ch/gaertner/subdir/software/miniball/changes.txt - from previous versions.
-
-The theory - https://people.inf.ethz.ch/gaertner/subdir/texts/own_work/esa99_final.pdf -  behind the miniball software (Proc. 7th Annual European Symposium on Algorithms (ESA), Lecture Notes in Computer Science 1643, Springer-Verlag, pp.325-338, 1999).
-
-Main Features:
-
-    Very fast in low dimensions. 1 million points in 5-space are processed within 0.05 seconds on any recent machine.
-
-    High numerical stability. Almost all input degeneracies (cospherical points, multiple points, points very close together) are routinely handled.
-
-    Easily integrates into your code. You can freely choose the coordinate type of your points and the container to store the points. If you still need to adapt the code, the header is small and readable and contains documentation for all major methods. 
-
-
-Changes done for the GUDHI version of MiniBall:
-  - Add include guard
-  - Move Miniball namespace inside a new Gudhi namespace
diff --git a/src/Cech_complex/include/gudhi/Miniball.hpp b/src/Cech_complex/include/gudhi/Miniball.hpp
deleted file mode 100644
index ce6cbb5b..00000000
--- a/src/Cech_complex/include/gudhi/Miniball.hpp
+++ /dev/null
@@ -1,523 +0,0 @@
-//    Copright (C) 1999-2013, Bernd Gaertner
-//    $Rev: 3581 $
-//
-//    This program is free software: you can redistribute it and/or modify
-//    it under the terms of the GNU General Public License as published by
-//    the Free Software Foundation, either version 3 of the License, or
-//    (at your option) any later version.
-
-//    This program is distributed in the hope that it will be useful,
-//    but WITHOUT ANY WARRANTY; without even the implied warranty of
-//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//    GNU General Public License for more details.
-
-//    You should have received a copy of the GNU General Public License
-//    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-//    Contact:
-//    --------
-//    Bernd Gaertner
-//    Institute of Theoretical Computer Science 
-//    ETH Zuerich
-//    CAB G31.1
-//    CH-8092 Zuerich, Switzerland
-//    http://www.inf.ethz.ch/personal/gaertner
-
-#ifndef MINIBALL_HPP_
-#define MINIBALL_HPP_
-
-#include <cassert>
-#include <algorithm>
-#include <list>
-#include <ctime>
-#include <limits>
-
-namespace Gudhi {
-
-namespace Miniball {
-
-  // Global Functions
-  // ================
-  template <typename NT>
-  inline NT mb_sqr (NT r) {return r*r;}
-
-  // Functors
-  // ========
-
-  // functor to map a point iterator to the corresponding coordinate iterator;
-  // generic version for points whose coordinate containers have begin()
-  template < typename Pit_, typename Cit_ >
-  struct CoordAccessor {
-    typedef Pit_                                  Pit;
-    typedef Cit_                                  Cit;
-    inline  Cit operator() (Pit it) const { return (*it).begin(); }
-  };
-
-  // partial specialization for points whose coordinate containers are arrays
-  template < typename Pit_, typename Cit_ >
-  struct CoordAccessor<Pit_, Cit_*> {
-    typedef Pit_                                  Pit;      
-    typedef Cit_*                                 Cit;
-    inline  Cit operator() (Pit it) const { return *it; }
-  };
-
-  // Class Declaration
-  // =================
-
-  template <typename CoordAccessor>
-  class Miniball {
-  private:
-    // types
-    // The iterator type to go through the input points
-    typedef typename CoordAccessor::Pit                         Pit; 
-    // The iterator type to go through the coordinates of a single point. 
-    typedef typename CoordAccessor::Cit                         Cit; 
-    // The coordinate type
-    typedef typename std::iterator_traits<Cit>::value_type      NT;  
-    // The iterator to go through the support points
-    typedef typename std::list<Pit>::iterator                   Sit;
-
-    // data members...
-    const int d; // dimension
-    Pit points_begin;        
-    Pit points_end;          
-    CoordAccessor coord_accessor;  
-    double time;  
-    const NT nt0; // NT(0)                         
-
-    //...for the algorithms
-    std::list<Pit> L;                       
-    Sit support_end;                        
-    int fsize;   // number of forced points                                   
-    int ssize;   // number of support points                               
-
-    // ...for the ball updates
-    NT* current_c;                         
-    NT  current_sqr_r;                      
-    NT** c;                                    
-    NT* sqr_r;                    
- 
-    // helper arrays
-    NT* q0;
-    NT* z;
-    NT* f;
-    NT** v;
-    NT** a;
-
-  public:
-    // The iterator type to go through the support points
-    typedef typename std::list<Pit>::const_iterator SupportPointIterator;
-  
-    // PRE:  [begin, end) is a nonempty range
-    // POST: computes the smallest enclosing ball of the points in the range
-    //       [begin, end); the functor a maps a point iterator to an iterator 
-    //       through the d coordinates of the point  
-    Miniball (int d_, Pit begin, Pit end, CoordAccessor ca = CoordAccessor());
-
-    // POST: returns a pointer to the first element of an array that holds
-    //       the d coordinates of the center of the computed ball  
-    const NT* center () const;
-
-    // POST: returns the squared radius of the computed ball  
-    NT squared_radius () const;
- 
-    // POST: returns the number of support points of the computed ball;
-    //       the support points form a minimal set with the same smallest
-    //       enclosing ball as the input set; in particular, the support
-    //       points are on the boundary of the computed ball, and their
-    //       number is at most d+1 
-    int nr_support_points () const;
- 
-    // POST: returns an iterator to the first support point 
-    SupportPointIterator support_points_begin () const;
-
-    // POST: returns a past-the-end iterator for the range of support points  
-    SupportPointIterator support_points_end () const;
-
-    // POST: returns the maximum excess of any input point w.r.t. the computed 
-    //       ball, divided by the squared radius of the computed ball. The 
-    //       excess of a point is the difference between its squared distance
-    //       from the center and the squared radius; Ideally, the return value 
-    //       is 0. subopt is set to the absolute value of the most negative 
-    //       coefficient in the affine combination of the support points that 
-    //       yields the center. Ideally, this is a convex combination, and there 
-    //       is no negative coefficient in which case subopt is set to 0.  
-    NT relative_error (NT& subopt) const;
-  
-    // POST: return true if the relative error is at most tol, and the
-    //       suboptimality is 0; the default tolerance is 10 times the
-    //       coordinate type's machine epsilon  
-    bool is_valid (NT tol = NT(10) * std::numeric_limits<NT>::epsilon()) const;
-
-    // POST: returns the time in seconds taken by the constructor call for 
-    //       computing the smallest enclosing ball  
-    double get_time() const;
-
-    // POST: deletes dynamically allocated arrays
-    ~Miniball();
-
-  private:  
-    void mtf_mb (Sit n);
-    void mtf_move_to_front (Sit j);
-    void pivot_mb (Pit n);
-    void pivot_move_to_front (Pit j);
-    NT excess (Pit pit) const;
-    void pop ();
-    bool push (Pit pit);
-    NT suboptimality () const;
-    void create_arrays();
-    void delete_arrays();
-  };
-
-  // Class Definition
-  // ================
-  template <typename CoordAccessor>
-  Miniball<CoordAccessor>::Miniball (int d_, Pit begin, Pit end, 
-				     CoordAccessor ca) 
-    : d (d_), 
-      points_begin (begin), 
-      points_end (end), 
-      coord_accessor (ca), 
-      time (clock()), 
-      nt0 (NT(0)), 
-      L(), 
-      support_end (L.begin()), 
-      fsize(0), 
-      ssize(0), 
-      current_c (NULL), 
-      current_sqr_r (NT(-1)),
-      c (NULL),
-      sqr_r (NULL),
-      q0 (NULL),
-      z (NULL),
-      f (NULL),
-      v (NULL),
-      a (NULL)
-  {	
-    assert (points_begin != points_end);
-    create_arrays();
-
-    // set initial center
-    for (int j=0; j<d; ++j) c[0][j] = nt0;
-    current_c = c[0];
-
-    // compute miniball
-    pivot_mb (points_end);
-
-    // update time
-    time = (clock() - time) / CLOCKS_PER_SEC;
-  }
-  
-  template <typename CoordAccessor>
-  Miniball<CoordAccessor>::~Miniball()
-  {
-    delete_arrays();
-  }
-
-  template <typename CoordAccessor>
-  void Miniball<CoordAccessor>::create_arrays() 
-  {
-    c = new NT*[d+1]; 
-    v = new NT*[d+1]; 
-    a = new NT*[d+1];
-    for (int i=0; i<d+1; ++i) {
-      c[i] = new NT[d];
-      v[i] = new NT[d];
-      a[i] = new NT[d];
-    }
-    sqr_r = new NT[d+1];
-    q0 = new NT[d];
-    z = new NT[d+1];
-    f = new NT[d+1];
-  } 
-
-  template <typename CoordAccessor>
-  void Miniball<CoordAccessor>::delete_arrays() 
-  {
-    delete[] f;
-    delete[] z;
-    delete[] q0;
-    delete[] sqr_r;
-    for (int i=0; i<d+1; ++i) {
-      delete[] a[i];
-      delete[] v[i];
-      delete[] c[i];
-    }
-    delete[] a;
-    delete[] v;
-    delete[] c;
-  }
-
-  template <typename CoordAccessor>
-  const typename Miniball<CoordAccessor>::NT* 
-  Miniball<CoordAccessor>::center () const 
-  {
-    return current_c;
-  }
- 
-  template <typename CoordAccessor>
-  typename Miniball<CoordAccessor>::NT 
-  Miniball<CoordAccessor>::squared_radius () const 
-  {
-    return current_sqr_r;
-  }
-
-  template <typename CoordAccessor>
-  int Miniball<CoordAccessor>::nr_support_points () const 
-  {
-    assert (ssize < d+2);
-    return ssize;
-  } 
-
-  template <typename CoordAccessor>  
-  typename Miniball<CoordAccessor>::SupportPointIterator 
-  Miniball<CoordAccessor>::support_points_begin () const 
-  {
-    return L.begin();
-  }
-
-  template <typename CoordAccessor>  
-  typename Miniball<CoordAccessor>::SupportPointIterator 
-  Miniball<CoordAccessor>::support_points_end () const  
-  {
-    return support_end;
-  }
-
-  template <typename CoordAccessor>  
-  typename Miniball<CoordAccessor>::NT 
-  Miniball<CoordAccessor>::relative_error (NT& subopt) const 
-  {
-    NT e, max_e = nt0;
-    // compute maximum absolute excess of support points
-    for (SupportPointIterator it = support_points_begin(); 
-	 it != support_points_end(); ++it) {
-      e = excess (*it);
-      if (e < nt0) e = -e;
-      if (e > max_e) {
-	max_e = e; 
-      }
-    }
-    // compute maximum excess of any point
-    for (Pit i = points_begin; i != points_end; ++i)
-      if ((e = excess (i)) > max_e)
-	max_e = e;
-   
-    subopt = suboptimality();
-    assert (current_sqr_r > nt0 || max_e == nt0);
-    return (current_sqr_r == nt0 ? nt0 : max_e / current_sqr_r);
-  }
-
-  template <typename CoordAccessor>  
-  bool Miniball<CoordAccessor>::is_valid (NT tol) const
-  {
-    NT suboptimality;
-    return ( (relative_error (suboptimality) <= tol) && (suboptimality == 0) );
-  }
-
-  template <typename CoordAccessor>  
-  double Miniball<CoordAccessor>::get_time() const 
-  {
-    return time;
-  }
-
-  template <typename CoordAccessor>  
-  void Miniball<CoordAccessor>::mtf_mb (Sit n)
-  {
-    // Algorithm 1: mtf_mb (L_{n-1}, B), where L_{n-1} = [L.begin, n)  
-    // B: the set of forced points, defining the current ball
-    // S: the superset of support points computed by the algorithm
-    // --------------------------------------------------------------
-    // from B. Gaertner, Fast and Robust Smallest Enclosing Balls, ESA 1999,
-    // http://www.inf.ethz.ch/personal/gaertner/texts/own_work/esa99_final.pdf  
-  
-    //   PRE: B = S  
-    assert (fsize == ssize);
-   
-    support_end = L.begin();
-    if ((fsize) == d+1) return;  
-  
-    // incremental construction
-    for (Sit i = L.begin(); i != n;) 
-      {
-	// INV: (support_end - L.begin() == |S|-|B|)
-	assert (std::distance (L.begin(), support_end) == ssize - fsize);
-       
-	Sit j = i++; 
-	if (excess(*j) > nt0) 
-	  if (push(*j)) {          // B := B + p_i
-	    mtf_mb (j);            // mtf_mb (L_{i-1}, B + p_i)
-	    pop();                 // B := B - p_i
-	    mtf_move_to_front(j);  
-	  }
-      }
-    // POST: the range [L.begin(), support_end) stores the set S\B
-  }
-
-  template <typename CoordAccessor>  
-  void Miniball<CoordAccessor>::mtf_move_to_front (Sit j) 
-  {
-    if (support_end == j)
-      support_end++;
-    L.splice (L.begin(), L, j);
-  }
-
-  template <typename CoordAccessor>  
-  void Miniball<CoordAccessor>::pivot_mb (Pit n) 
-  {
-    // Algorithm 2: pivot_mb (L_{n-1}), where L_{n-1} = [L.begin, n)  
-    // --------------------------------------------------------------
-    // from B. Gaertner, Fast and Robust Smallest Enclosing Balls, ESA 1999,
-    // http://www.inf.ethz.ch/personal/gaertner/texts/own_work/esa99_final.pdf  
-    NT          old_sqr_r;
-    const NT*   c;
-    Pit         pivot, k;
-    NT          e, max_e, sqr_r;
-    Cit p;
-    do {
-      old_sqr_r = current_sqr_r;
-      sqr_r = current_sqr_r;
-
-      pivot = points_begin;
-      max_e = nt0;
-      for (k = points_begin; k != n; ++k) {
-	p = coord_accessor(k);
-	e = -sqr_r;
-	c = current_c;
-	for (int j=0; j<d; ++j)
-	  e += mb_sqr<NT>(*p++-*c++);
-	if (e > max_e) {
-	  max_e = e;
-	  pivot = k;
-	}
-      }
-
-      if (max_e > nt0) {
-	// check if the pivot is already contained in the support set
-	if (std::find(L.begin(), support_end, pivot) == support_end) {
-	  assert (fsize == 0);
-	  if (push (pivot)) {
-	    mtf_mb(support_end);
-	    pop();
-	    pivot_move_to_front(pivot);
-	  }
-	}
-      }
-    } while (old_sqr_r < current_sqr_r);
-  }
-
-  template <typename CoordAccessor>  
-  void Miniball<CoordAccessor>::pivot_move_to_front (Pit j) 
-  {
-    L.push_front(j);
-    if (std::distance(L.begin(), support_end) == d+2)
-      support_end--;
-  }
-
-  template <typename CoordAccessor>  
-  inline typename Miniball<CoordAccessor>::NT 
-  Miniball<CoordAccessor>::excess (Pit pit) const 
-  {
-    Cit p = coord_accessor(pit);
-    NT e = -current_sqr_r;
-    NT* c = current_c;
-    for (int k=0; k<d; ++k){
-      e += mb_sqr<NT>(*p++-*c++);
-    }
-    return e;
-  }
-
-  template <typename CoordAccessor>  
-  void Miniball<CoordAccessor>::pop ()  
-  {
-    --fsize;
-  }
-
-  template <typename CoordAccessor>  
-  bool Miniball<CoordAccessor>::push (Pit pit) 
-  {
-    int i, j;
-    NT eps = mb_sqr<NT>(std::numeric_limits<NT>::epsilon());
-   
-    Cit cit = coord_accessor(pit);
-    Cit p = cit;
- 
-    if (fsize==0) {
-      for (i=0; i<d; ++i)
-	q0[i] = *p++;
-      for (i=0; i<d; ++i)
-	c[0][i] = q0[i];
-      sqr_r[0] = nt0;
-    } 
-    else {
-      // set v_fsize to Q_fsize
-      for (i=0; i<d; ++i)
-	//v[fsize][i] = p[i]-q0[i];
-	v[fsize][i] = *p++-q0[i];
-      
-      // compute the a_{fsize,i}, i< fsize
-      for (i=1; i<fsize; ++i) {
-	a[fsize][i] = nt0;
-	for (j=0; j<d; ++j)
-	  a[fsize][i] += v[i][j] * v[fsize][j];
-	a[fsize][i]*=(2/z[i]);
-      }
-      
-      // update v_fsize to Q_fsize-\bar{Q}_fsize
-      for (i=1; i<fsize; ++i) {
-	for (j=0; j<d; ++j)
-	  v[fsize][j] -= a[fsize][i]*v[i][j];
-      }
-      
-      // compute z_fsize
-      z[fsize]=nt0;
-      for (j=0; j<d; ++j)
-	z[fsize] += mb_sqr<NT>(v[fsize][j]);
-      z[fsize]*=2;
-      
-      // reject push if z_fsize too small
-      if (z[fsize]<eps*current_sqr_r) {
-	return false;
-      }
-      
-      // update c, sqr_r
-      p=cit;
-      NT e = -sqr_r[fsize-1];
-      for (i=0; i<d; ++i)
-	e += mb_sqr<NT>(*p++-c[fsize-1][i]);
-      f[fsize]=e/z[fsize];
-      
-      for (i=0; i<d; ++i)
-	c[fsize][i] = c[fsize-1][i]+f[fsize]*v[fsize][i];
-      sqr_r[fsize] = sqr_r[fsize-1] + e*f[fsize]/2;
-    }
-    current_c = c[fsize];
-    current_sqr_r = sqr_r[fsize];
-    ssize = ++fsize;
-    return true;
-  }
- 
-  template <typename CoordAccessor>  
-  typename Miniball<CoordAccessor>::NT 
-  Miniball<CoordAccessor>::suboptimality () const
-  {
-    NT* l = new NT[d+1];
-    NT min_l = nt0;
-    l[0] = NT(1);
-    for (int i=ssize-1; i>0; --i) {
-      l[i] = f[i];
-      for (int k=ssize-1; k>i; --k)
-	l[i]-=a[k][i]*l[k];
-      if (l[i] < min_l) min_l = l[i];
-      l[0] -= l[i];
-    }
-    if (l[0] < min_l) min_l = l[0];
-    delete[] l;
-    if (min_l < nt0)
-      return -min_l;
-    return nt0;
-  }
-}  // namespace Miniball
-
-}  // namespace Gudhi
-
-#endif  // MINIBALL_HPP_
diff --git a/src/common/doc/examples.h b/src/common/doc/examples.h
index 879fb96a..0c4320f6 100644
--- a/src/common/doc/examples.h
+++ b/src/common/doc/examples.h
@@ -40,7 +40,6 @@
  * @example edge_collapse_basic_example.cpp
  * \section Cech_complex_example_section Cech_complex
  * @example cech_persistence.cpp
- * @example cech_complex_step_by_step.cpp
  * @example cech_complex_example_from_points.cpp
  * \section Bitmap_cubical_complex_example_section Bitmap_cubical_complex
  * @example periodic_cubical_complex_persistence.cpp
diff --git a/src/common/doc/main_page.md b/src/common/doc/main_page.md
index 17354179..6f995fee 100644
--- a/src/common/doc/main_page.md
+++ b/src/common/doc/main_page.md
@@ -181,7 +181,7 @@
       <b>Author:</b> Vincent Rouvreau<br>
       <b>Introduced in:</b> GUDHI 2.2.0<br>
       <b>Copyright:</b> MIT [(GPL v3)](../../licensing/)<br>
-      <b>Includes:</b> [Miniball](https://people.inf.ethz.ch/gaertner/subdir/software/miniball.html)<br>
+      <b>Requires:</b> \ref cgal
     </td>
  </tr>
  <tr>