multipers 2.3.3b6__cp312-cp312-manylinux_2_39_x86_64.whl

multipers/gudhi/gudhi/Persistent_cohomology.h

@@ -0,0 +1,745 @@
+/*    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):       Clément Maria
+ *
+ *    Copyright (C) 2014 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#ifndef PERSISTENT_COHOMOLOGY_H_
+#define PERSISTENT_COHOMOLOGY_H_
+
+#include <gudhi/Persistent_cohomology/Persistent_cohomology_column.h>
+#include <gudhi/Persistent_cohomology/Field_Zp.h>
+#include <gudhi/Simple_object_pool.h>
+
+#include <boost/intrusive/set.hpp>
+#include <boost/pending/disjoint_sets.hpp>
+#include <boost/intrusive/list.hpp>
+
+#include <iostream>
+#include <map>
+#include <unordered_map>
+#include <utility>
+#include <list>
+#include <vector>
+#include <set>
+#include <fstream>  // std::ofstream
+#include <limits>  // for numeric_limits<>
+#include <tuple>
+#include <algorithm>
+#include <string>
+#include <stdexcept>  // for std::out_of_range
+
+namespace Gudhi {
+
+namespace persistent_cohomology {
+
+/** \brief Computes the persistent cohomology of a filtered complex.
+ *
+ * \ingroup persistent_cohomology
+ * 
+ * The computation is implemented with a Compressed Annotation Matrix
+ * (CAM)\cite DBLP:conf/esa/BoissonnatDM13,
+ * and is adapted to the computation of Multi-Field Persistent Homology (MF)
+ * \cite boissonnat:hal-00922572 .
+ *
+ * \implements PersistentHomology
+ *
+ */
+// TODO(CM): Memory allocation policy: classic, use a mempool, etc.
+template<class FilteredComplex, class CoefficientField>
+class Persistent_cohomology {
+ public:
+  // Data attached to each simplex to interface with a Property Map.
+
+  /** \brief Data stored for each simplex. */
+  typedef typename FilteredComplex::Simplex_key Simplex_key;
+  /** \brief Handle to specify a simplex. */
+  typedef typename FilteredComplex::Simplex_handle Simplex_handle;
+  /** \brief Type for the value of the filtration function. */
+  typedef typename FilteredComplex::Filtration_value Filtration_value;
+  /** \brief Type of element of the field. */
+  typedef typename CoefficientField::Element Arith_element;
+  /** \brief Type for birth and death FilteredComplex::Simplex_handle.
+   * The Arith_element field is used for the multi-field framework. */
+  typedef std::tuple<Simplex_handle, Simplex_handle, Arith_element> Persistent_interval;
+
+ private:
+  // Compressed Annotation Matrix types:
+  // Column type
+  typedef Persistent_cohomology_column<Simplex_key, Arith_element> Column;  // contains 1 set_hook
+  // Cell type
+  typedef typename Column::Cell Cell;   // contains 2 list_hooks
+  // Remark: constant_time_size must be false because base_hook_cam_h has auto_unlink link_mode
+  typedef boost::intrusive::list<Cell,
+      boost::intrusive::constant_time_size<false>,
+      boost::intrusive::base_hook<base_hook_cam_h> > Hcell;
+
+  typedef boost::intrusive::set<Column,
+      boost::intrusive::constant_time_size<false> > Cam;
+  // Sparse column type for the annotation of the boundary of an element.
+  typedef std::vector<std::pair<Simplex_key, Arith_element> > A_ds_type;
+
+ public:
+  /** \brief Initializes the Persistent_cohomology class.
+   *
+   * @param[in] cpx Complex for which the persistent homology is computed.
+   * cpx is a model of FilteredComplex
+   *
+   * @param[in] persistence_dim_max if true, the persistent homology for the maximal dimension in the
+   *                                complex is computed. If false, it is ignored. Default is false.
+   *
+   * @exception std::out_of_range In case the number of simplices is more than Simplex_key type numeric limit.
+   */
+  explicit Persistent_cohomology(FilteredComplex& cpx, bool persistence_dim_max = false)
+      : cpx_(&cpx),
+        dim_max_(cpx.dimension()),                       // upper bound on the dimension of the simplices
+        coeff_field_(),                                  // initialize the field coefficient structure.
+        num_simplices_(cpx_->num_simplices()),           // num_simplices save to avoid to call thrice the function
+        ds_rank_(num_simplices_),                        // union-find
+        ds_parent_(num_simplices_),                      // union-find
+        ds_repr_(num_simplices_, NULL),                  // union-find -> annotation vectors
+        dsets_(ds_rank_.data(), ds_parent_.data()),      // union-find
+        cam_(),                                          // collection of annotation vectors
+        zero_cocycles_(),                                // union-find -> Simplex_key of creator for 0-homology
+        transverse_idx_(),                               // key -> row
+        persistent_pairs_(),
+        interval_length_policy(&cpx, 0),
+        column_pool_(),  // memory pools for the CAM
+        cell_pool_() {
+    if (num_simplices_ > std::numeric_limits<Simplex_key>::max()) {
+      // num_simplices must be strictly lower than the limit, because a value is reserved for null_key.
+      throw std::out_of_range("The number of simplices is more than Simplex_key type numeric limit.");
+    }
+    if (persistence_dim_max) {
+      ++dim_max_;
+    }
+  }
+
+  ~Persistent_cohomology() {
+    // Clean the transversal lists
+    for (auto & transverse_ref : transverse_idx_) {
+      // Destruct all the cells
+      transverse_ref.second.row_->clear_and_dispose([&](Cell*p){p->~Cell();});
+      delete transverse_ref.second.row_;
+    }
+  }
+
+ private:
+  struct length_interval {
+    length_interval(FilteredComplex * cpx, Filtration_value min_length)
+        : cpx_(cpx),
+          min_length_(min_length) {
+    }
+
+    bool operator()(Simplex_handle sh1, Simplex_handle sh2) {
+      return cpx_->filtration(sh2) - cpx_->filtration(sh1) > min_length_;
+    }
+
+    void set_length(Filtration_value new_length) {
+      min_length_ = new_length;
+    }
+
+    FilteredComplex * cpx_;
+    Filtration_value min_length_;
+  };
+
+ public:
+  /** \brief Initializes the coefficient field.*/
+  void init_coefficients(int charac) {
+    coeff_field_.init(charac);
+  }
+  /** \brief Initializes the coefficient field for multi-field persistent homology.*/
+  void init_coefficients(int charac_min, int charac_max) {
+    coeff_field_.init(charac_min, charac_max);
+  }
+
+  /** \brief Compute the persistent homology of the filtered simplicial
+   * complex.
+   *
+   * @param[in] min_interval_length the computation discards all intervals of length
+   *                                less or equal than min_interval_length
+   *
+   * Assumes that the filtration provided by the simplicial complex is
+   * valid. Undefined behavior otherwise. */
+  void compute_persistent_cohomology(Filtration_value min_interval_length = 0,
+                                     const bool is_simplicial_and_starting_from_dim_0 = true) {
+    interval_length_policy.set_length(min_interval_length);
+    Simplex_key idx_fil = -1;
+    std::vector<Simplex_key> vertices; // so we can check the connected components at the end
+    // Compute all finite intervals
+    for (auto sh : cpx_->filtration_simplex_range()) {
+      cpx_->assign_key(sh, ++idx_fil);
+      dsets_.make_set(cpx_->key(sh));
+      int dim_simplex = cpx_->dimension(sh);
+      if (is_simplicial_and_starting_from_dim_0){
+        switch (dim_simplex) {
+          case 0:
+            vertices.push_back(idx_fil);
+            break;
+          case 1:
+            update_cohomology_groups_edge(sh);
+            break;
+          default:
+            update_cohomology_groups(sh, dim_simplex);
+            break;
+        }
+      } else {
+        update_cohomology_groups(sh, dim_simplex);
+      }
+    }
+    // Compute infinite intervals of dimension 0
+    for (Simplex_key key : vertices) {  // for all 0-dimensional simplices
+      if (ds_parent_[key] == key  // root of its tree
+      && zero_cocycles_.find(key) == zero_cocycles_.end()) {
+        persistent_pairs_.emplace_back(
+            cpx_->simplex(key), cpx_->null_simplex(), coeff_field_.characteristic());
+      }
+    }
+    for (auto zero_idx : zero_cocycles_) {
+      persistent_pairs_.emplace_back(
+          cpx_->simplex(zero_idx.second), cpx_->null_simplex(), coeff_field_.characteristic());
+    }
+    // Compute infinite interval of dimension > 0
+    for (auto cocycle : transverse_idx_) {
+      persistent_pairs_.emplace_back(
+          cpx_->simplex(cocycle.first), cpx_->null_simplex(), cocycle.second.characteristics_);
+    }
+  }
+
+ private:
+  /** \brief Update the cohomology groups under the insertion of an edge.
+   *
+   * The 0-homology is maintained with a simple Union-Find data structure, which
+   * explains the existence of a specific function of edge insertions. */
+  void update_cohomology_groups_edge(Simplex_handle sigma) {
+    Simplex_handle u, v;
+    boost::tie(u, v) = cpx_->endpoints(sigma);
+
+    Simplex_key ku = dsets_.find_set(cpx_->key(u));
+    Simplex_key kv = dsets_.find_set(cpx_->key(v));
+
+    if (ku != kv) {        // Destroy a connected component
+      dsets_.link(ku, kv);
+      // Keys of the simplices which created the connected components containing
+      // respectively u and v.
+      Simplex_key idx_coc_u, idx_coc_v;
+      auto map_it_u = zero_cocycles_.find(ku);
+      // If the index of the cocycle representing the class is already ku.
+      if (map_it_u == zero_cocycles_.end()) {
+        idx_coc_u = ku;
+      } else {
+        idx_coc_u = map_it_u->second;
+      }
+
+      auto map_it_v = zero_cocycles_.find(kv);
+      // If the index of the cocycle representing the class is already kv.
+      if (map_it_v == zero_cocycles_.end()) {
+        idx_coc_v = kv;
+      } else {
+        idx_coc_v = map_it_v->second;
+      }
+
+      if (cpx_->filtration(cpx_->simplex(idx_coc_u))
+          < cpx_->filtration(cpx_->simplex(idx_coc_v))) {  // Kill cocycle [idx_coc_v], which is younger.
+        if (interval_length_policy(cpx_->simplex(idx_coc_v), sigma)) {
+          persistent_pairs_.emplace_back(
+              cpx_->simplex(idx_coc_v), sigma, coeff_field_.characteristic());
+        }
+        // Maintain the index of the 0-cocycle alive.
+        if (kv != idx_coc_v) {
+          zero_cocycles_.erase(map_it_v);
+        }
+        if (kv == dsets_.find_set(kv)) {
+          if (ku != idx_coc_u) {
+            zero_cocycles_.erase(map_it_u);
+          }
+          zero_cocycles_[kv] = idx_coc_u;
+        }
+      } else {  // Kill cocycle [idx_coc_u], which is younger.
+        if (interval_length_policy(cpx_->simplex(idx_coc_u), sigma)) {
+          persistent_pairs_.emplace_back(
+              cpx_->simplex(idx_coc_u), sigma, coeff_field_.characteristic());
+        }
+        // Maintain the index of the 0-cocycle alive.
+        if (ku != idx_coc_u) {
+          zero_cocycles_.erase(map_it_u);
+        }
+        if (ku == dsets_.find_set(ku)) {
+          if (kv != idx_coc_v) {
+            zero_cocycles_.erase(map_it_v);
+          }
+          zero_cocycles_[ku] = idx_coc_v;
+        }
+      }
+      cpx_->assign_key(sigma, cpx_->null_key());
+    } else if (dim_max_ > 1) {  // If ku == kv, same connected component: create a 1-cocycle class.
+      create_cocycle(sigma, coeff_field_.multiplicative_identity(), coeff_field_.characteristic());
+    }
+  }
+
+  /*
+   * Compute the annotation of the boundary of a simplex.
+   */
+  void annotation_of_the_boundary(
+      std::map<Simplex_key, Arith_element> & map_a_ds, Simplex_handle sigma,
+      int dim_sigma) {
+    // traverses the boundary of sigma, keeps track of the annotation vectors,
+    // with multiplicity. We used to sum the coefficients directly in
+    // annotations_in_boundary by using a map, we now do it later.
+    typedef std::pair<Column *, int> annotation_t;
+    thread_local std::vector<annotation_t> annotations_in_boundary;
+    annotations_in_boundary.clear();
+    int sign = 1 - 2 * (dim_sigma % 2);  // \in {-1,1} provides the sign in the
+                                         // alternate sum in the boundary.
+    Simplex_key key;
+    Column * curr_col;
+
+    for (auto sh : cpx_->boundary_simplex_range(sigma)) {
+      key = cpx_->key(sh);
+      if (key != cpx_->null_key()) {  // A simplex with null_key is a killer, and have null annotation
+        // Find its annotation vector
+        curr_col = ds_repr_[dsets_.find_set(key)];
+        if (curr_col != NULL) {  // and insert it in annotations_in_boundary with multyiplicative factor "sign".
+          annotations_in_boundary.emplace_back(curr_col, sign);
+        }
+      }
+      sign = -sign;
+    }
+    // Place identical annotations consecutively so we can easily sum their multiplicities.
+    std::sort(annotations_in_boundary.begin(), annotations_in_boundary.end(),
+              [](annotation_t const& a, annotation_t const& b) { return a.first < b.first; });
+
+    // Sum the annotations with multiplicity, using a map<key,coeff>
+    // to represent a sparse vector.
+    std::pair<typename std::map<Simplex_key, Arith_element>::iterator, bool> result_insert_a_ds;
+
+    for (auto ann_it = annotations_in_boundary.begin(); ann_it != annotations_in_boundary.end(); /**/) {
+      Column* col = ann_it->first;
+      int mult = ann_it->second;
+      while (++ann_it != annotations_in_boundary.end() && ann_it->first == col) {
+        mult += ann_it->second;
+      }
+      // The following test is just a heuristic, it is not required, and it is fine that is misses p == 0.
+      if (mult != coeff_field_.additive_identity()) {  // For all columns in the boundary,
+        for (auto cell_ref : col->col_) {  // insert every cell in map_a_ds with multiplicity
+          Arith_element w_y = coeff_field_.times(cell_ref.coefficient_, mult);  // coefficient * multiplicity
+
+          if (w_y != coeff_field_.additive_identity()) {  // if != 0
+            result_insert_a_ds = map_a_ds.insert(std::pair<Simplex_key, Arith_element>(cell_ref.key_, w_y));
+            if (!(result_insert_a_ds.second)) {  // if cell_ref.key_ already a Key in map_a_ds
+              result_insert_a_ds.first->second = coeff_field_.plus_equal(result_insert_a_ds.first->second, w_y);
+              if (result_insert_a_ds.first->second == coeff_field_.additive_identity()) {
+                map_a_ds.erase(result_insert_a_ds.first);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /*
+   * Update the cohomology groups under the insertion of a simplex.
+   */
+  void update_cohomology_groups(Simplex_handle sigma, int dim_sigma) {
+// Compute the annotation of the boundary of sigma:
+    std::map<Simplex_key, Arith_element> map_a_ds;
+    annotation_of_the_boundary(map_a_ds, sigma, dim_sigma);
+// Update the cohomology groups:
+    if (map_a_ds.empty()) {  // sigma is a creator in all fields represented in coeff_field_
+      if (dim_sigma < dim_max_) {
+        create_cocycle(sigma, coeff_field_.multiplicative_identity(),
+                       coeff_field_.characteristic());
+      }
+    } else {        // sigma is a destructor in at least a field in coeff_field_
+      // Convert map_a_ds to a vector
+      A_ds_type a_ds;  // admits reverse iterators
+      for (auto map_a_ds_ref : map_a_ds) {
+        a_ds.push_back(
+            std::pair<Simplex_key, Arith_element>(map_a_ds_ref.first,
+                                                  map_a_ds_ref.second));
+      }
+
+      Arith_element inv_x, charac;
+      Arith_element prod = coeff_field_.characteristic();  // Product of characteristic of the fields
+      for (auto a_ds_rit = a_ds.rbegin();
+          (a_ds_rit != a_ds.rend())
+              && (prod != coeff_field_.multiplicative_identity()); ++a_ds_rit) {
+        std::tie(inv_x, charac) = coeff_field_.inverse(a_ds_rit->second, prod);
+
+        if (inv_x != coeff_field_.additive_identity()) {
+          destroy_cocycle(sigma, a_ds, a_ds_rit->first, inv_x, charac);
+          prod /= charac;
+        }
+      }
+      if (prod != coeff_field_.multiplicative_identity()
+          && dim_sigma < dim_max_) {
+        create_cocycle(sigma, coeff_field_.multiplicative_identity(prod), prod);
+      }
+    }
+  }
+
+  /*  \brief Create a new cocycle class.
+   *
+   * The class is created by the insertion of the simplex sigma.
+   * The methods adds a cocycle, representing the new cocycle class,
+   * to the matrix representing the cohomology groups.
+   * The new cocycle has value 0 on every simplex except on sigma
+   * where it worths 1.*/
+  void create_cocycle(Simplex_handle sigma, Arith_element x,
+                      Arith_element charac) {
+    Simplex_key key = cpx_->key(sigma);
+    // Create a column containing only one cell,
+    Column * new_col = column_pool_.construct(key);
+    Cell * new_cell = cell_pool_.construct(key, x, new_col);
+    new_col->col_.push_back(*new_cell);
+    // and insert it in the matrix, in constant time thanks to the hint cam_.end().
+    // Indeed *new_col has the biggest lexicographic value because key is the
+    // biggest key used so far.
+    cam_.insert(cam_.end(), *new_col);
+    // Update the disjoint sets data structure.
+    Hcell * new_hcell = new Hcell;
+    new_hcell->push_back(*new_cell);
+    transverse_idx_[key] = cocycle(charac, new_hcell);  // insert the new row
+    ds_repr_[key] = new_col;
+  }
+
+  /*  \brief Destroy a cocycle class.
+   *
+   * The cocycle class is destroyed by the insertion of sigma.
+   * The methods proceeds to a reduction of the matrix representing
+   * the cohomology groups using Gauss pivoting. The reduction zeros-out
+   * the row containing the cell with highest key in
+   * a_ds, the annotation of the boundary of simplex sigma. This key
+   * is "death_key".*/
+  void destroy_cocycle(Simplex_handle sigma, A_ds_type const& a_ds,
+                       Simplex_key death_key, Arith_element inv_x,
+                       Arith_element charac) {
+    // Create a finite persistent interval for which the interval exists
+    if (interval_length_policy(cpx_->simplex(death_key), sigma)) {
+      persistent_pairs_.emplace_back(cpx_->simplex(death_key)  // creator
+          , sigma                                              // destructor
+          , charac);                                           // fields
+    }
+
+    auto death_key_row = transverse_idx_.find(death_key);  // Find the beginning of the row.
+    std::pair<typename Cam::iterator, bool> result_insert_cam;
+
+    auto row_cell_it = death_key_row->second.row_->begin();
+
+    while (row_cell_it != death_key_row->second.row_->end()) {  // Traverse all cells in
+      // the row at index death_key.
+      Arith_element w = coeff_field_.times_minus(inv_x, row_cell_it->coefficient_);
+
+      if (w != coeff_field_.additive_identity()) {
+        Column * curr_col = row_cell_it->self_col_;
+        ++row_cell_it;
+        // Disconnect the column from the rows in the CAM.
+        for (auto& col_cell : curr_col->col_) {
+          col_cell.base_hook_cam_h::unlink();
+        }
+
+        // Remove the column from the CAM before modifying its value
+        cam_.erase(cam_.iterator_to(*curr_col));
+        // Proceed to the reduction of the column
+        plus_equal_column(*curr_col, a_ds, w);
+
+        if (curr_col->col_.empty()) {  // If the column is null
+          ds_repr_[curr_col->class_key_] = NULL;
+          column_pool_.destroy(curr_col);  // delete curr_col;
+        } else {
+          // Find whether the column obtained is already in the CAM
+          result_insert_cam = cam_.insert(*curr_col);
+          if (result_insert_cam.second) {  // If it was not in the CAM before: insertion has succeeded
+            for (auto& col_cell : curr_col->col_) {
+              // re-establish the row links
+              transverse_idx_[col_cell.key_].row_->push_front(col_cell);
+            }
+          } else {  // There is already an identical column in the CAM:
+            // merge two disjoint sets.
+            dsets_.link(curr_col->class_key_,
+                        result_insert_cam.first->class_key_);
+
+            Simplex_key key_tmp = dsets_.find_set(curr_col->class_key_);
+            ds_repr_[key_tmp] = &(*(result_insert_cam.first));
+            result_insert_cam.first->class_key_ = key_tmp;
+            // intrusive containers don't own their elements, we have to release them manually
+            curr_col->col_.clear_and_dispose([&](Cell*p){cell_pool_.destroy(p);});
+            column_pool_.destroy(curr_col);  // delete curr_col;
+          }
+        }
+      } else {
+        ++row_cell_it;
+      }  // If w == 0, pass.
+    }
+
+    // Because it is a killer simplex, set the data of sigma to null_key().
+    if (charac == coeff_field_.characteristic()) {
+      cpx_->assign_key(sigma, cpx_->null_key());
+    }
+    if (death_key_row->second.characteristics_ == charac) {
+      delete death_key_row->second.row_;
+      transverse_idx_.erase(death_key_row);
+    } else {
+      death_key_row->second.characteristics_ /= charac;
+    }
+  }
+
+  /*
+   * Assign:    target <- target + w * other.
+   */
+  void plus_equal_column(Column & target, A_ds_type const& other  // value_type is pair<Simplex_key,Arith_element>
+                         , Arith_element w) {
+    auto target_it = target.col_.begin();
+    auto other_it = other.begin();
+    while (target_it != target.col_.end() && other_it != other.end()) {
+      if (target_it->key_ < other_it->first) {
+        ++target_it;
+      } else {
+        if (target_it->key_ > other_it->first) {
+          Cell * cell_tmp = cell_pool_.construct(Cell(other_it->first   // key
+              , coeff_field_.additive_identity(), &target));
+
+          cell_tmp->coefficient_ = coeff_field_.plus_times_equal(cell_tmp->coefficient_, other_it->second, w);
+
+          target.col_.insert(target_it, *cell_tmp);
+
+          ++other_it;
+        } else {  // it1->key == it2->key
+          // target_it->coefficient_ <- target_it->coefficient_ + other_it->second * w
+          target_it->coefficient_ = coeff_field_.plus_times_equal(target_it->coefficient_, other_it->second, w);
+          if (target_it->coefficient_ == coeff_field_.additive_identity()) {
+            auto tmp_it = target_it;
+            ++target_it;
+            ++other_it;   // iterators remain valid
+            Cell * tmp_cell_ptr = &(*tmp_it);
+            target.col_.erase(tmp_it);  // removed from column
+
+            cell_pool_.destroy(tmp_cell_ptr);  // delete from memory
+          } else {
+            ++target_it;
+            ++other_it;
+          }
+        }
+      }
+    }
+    while (other_it != other.end()) {
+      Cell * cell_tmp = cell_pool_.construct(Cell(other_it->first, coeff_field_.additive_identity(), &target));
+      cell_tmp->coefficient_ = coeff_field_.plus_times_equal(cell_tmp->coefficient_, other_it->second, w);
+      target.col_.insert(target.col_.end(), *cell_tmp);
+
+      ++other_it;
+    }
+  }
+
+  /*
+   * Compare two intervals by length.
+   */
+  struct cmp_intervals_by_length {
+    explicit cmp_intervals_by_length(FilteredComplex * sc)
+        : sc_(sc) {
+    }
+    bool operator()(const Persistent_interval & p1, const Persistent_interval & p2) {
+      return (sc_->filtration(get < 1 > (p1)) - sc_->filtration(get < 0 > (p1))
+          > sc_->filtration(get < 1 > (p2)) - sc_->filtration(get < 0 > (p2)));
+    }
+    FilteredComplex * sc_;
+  };
+
+ public:
+  /** \brief Output the persistence diagram in ostream.
+   *
+   * The file format is the following:
+   *    p1*...*pr   dim b d
+   *
+   * where "dim" is the dimension of the homological feature,
+   * b and d are respectively the birth and death of the feature and
+   * p1*...*pr is the product of prime numbers pi such that the homology
+   * feature exists in homology with Z/piZ coefficients.
+   */
+  void output_diagram(std::ostream& ostream = std::cout) {
+    cmp_intervals_by_length cmp(cpx_);
+    std::sort(std::begin(persistent_pairs_), std::end(persistent_pairs_), cmp);
+    for (auto pair : persistent_pairs_) {
+      ostream << get<2>(pair) << "  " << cpx_->dimension(get<0>(pair)) << " "
+        << cpx_->filtration(get<0>(pair)) << " "
+        << cpx_->filtration(get<1>(pair)) << " " << std::endl;
+    }
+  }
+
+  void write_output_diagram(std::string diagram_name) {
+    std::ofstream diagram_out(diagram_name.c_str());
+    diagram_out.exceptions(diagram_out.failbit);
+    cmp_intervals_by_length cmp(cpx_);
+    std::sort(std::begin(persistent_pairs_), std::end(persistent_pairs_), cmp);
+    for (auto pair : persistent_pairs_) {
+      diagram_out << cpx_->dimension(get<0>(pair)) << " "
+            << cpx_->filtration(get<0>(pair)) << " "
+            << cpx_->filtration(get<1>(pair)) << std::endl;
+    }
+  }
+
+  /** @brief Returns Betti numbers.
+   * @return A vector of Betti numbers.
+   */
+  std::vector<int> betti_numbers() const {
+    // Init Betti numbers vector with zeros until Simplicial complex dimension and don't allocate a vector of negative
+    // size for an empty complex
+    std::vector<int> betti_numbers(std::max(dim_max_, 0));
+
+    for (auto pair : persistent_pairs_) {
+      // Count never ended persistence intervals
+      if (cpx_->null_simplex() == get<1>(pair)) {
+        // Increment corresponding betti number
+        betti_numbers[cpx_->dimension(get<0>(pair))] += 1;
+      }
+    }
+    return betti_numbers;
+  }
+
+  /** @brief Returns the Betti number of the dimension passed by parameter.
+   * @param[in] dimension The Betti number dimension to get.
+   * @return Betti number of the given dimension
+   *
+   */
+  int betti_number(int dimension) const {
+    int betti_number = 0;
+
+    for (auto pair : persistent_pairs_) {
+      // Count never ended persistence intervals
+      if (cpx_->null_simplex() == get<1>(pair)) {
+        if (cpx_->dimension(get<0>(pair)) == dimension) {
+          // Increment betti number found
+          ++betti_number;
+        }
+      }
+    }
+    return betti_number;
+  }
+
+  /** @brief Returns the persistent Betti numbers.
+   * @param[in] from The persistence birth limit to be added in the number \f$(persistent birth \leq from)\f$.
+   * @param[in] to The persistence death limit to be added in the number  \f$(persistent death > to)\f$.
+   * @return A vector of persistent Betti numbers.
+   */
+  std::vector<int> persistent_betti_numbers(Filtration_value from, Filtration_value to) const {
+    // Init Betti numbers vector with zeros until Simplicial complex dimension and don't allocate a vector of negative
+    // size for an empty complex
+    std::vector<int> betti_numbers(std::max(dim_max_, 0));
+    for (auto pair : persistent_pairs_) {
+      // Count persistence intervals that covers the given interval
+      // null_simplex test : if the function is called with to=+infinity, we still get something useful. And it will
+      // still work if we change the complex filtration function to reject null simplices.
+      if (cpx_->filtration(get<0>(pair)) <= from &&
+          (get<1>(pair) == cpx_->null_simplex() || cpx_->filtration(get<1>(pair)) > to)) {
+        // Increment corresponding betti number
+        betti_numbers[cpx_->dimension(get<0>(pair))] += 1;
+      }
+    }
+    return betti_numbers;
+  }
+
+  /** @brief Returns the persistent Betti number of the dimension passed by parameter.
+   * @param[in] dimension The Betti number dimension to get.
+   * @param[in] from The persistence birth limit to be added in the number \f$(persistent birth \leq from)\f$.
+   * @param[in] to The persistence death limit to be added in the number  \f$(persistent death > to)\f$.
+   * @return Persistent Betti number of the given dimension
+   */
+  int persistent_betti_number(int dimension, Filtration_value from, Filtration_value to) const {
+    int betti_number = 0;
+
+    for (auto pair : persistent_pairs_) {
+      // Count persistence intervals that covers the given interval
+      // null_simplex test : if the function is called with to=+infinity, we still get something useful. And it will
+      // still work if we change the complex filtration function to reject null simplices.
+      if (cpx_->filtration(get<0>(pair)) <= from &&
+          (get<1>(pair) == cpx_->null_simplex() || cpx_->filtration(get<1>(pair)) > to)) {
+        if (cpx_->dimension(get<0>(pair)) == dimension) {
+          // Increment betti number found
+          ++betti_number;
+        }
+      }
+    }
+    return betti_number;
+  }
+
+  /** @brief Returns a list of persistence birth and death FilteredComplex::Simplex_handle pairs.
+   * @return A list of Persistent_cohomology::Persistent_interval
+   */
+  const std::vector<Persistent_interval>& get_persistent_pairs() const {
+    return persistent_pairs_;
+  }
+
+  /** @brief Returns persistence intervals for a given dimension.
+   * @param[in] dimension Dimension to get the birth and death pairs from.
+   * @return A vector of persistence intervals (birth and death) on a fixed dimension.
+   */
+  std::vector< std::pair< Filtration_value , Filtration_value > >
+  intervals_in_dimension(int dimension) {
+    std::vector< std::pair< Filtration_value , Filtration_value > > result;
+    // auto && pair, to avoid unnecessary copying
+    for (auto && pair : persistent_pairs_) {
+      if (cpx_->dimension(get<0>(pair)) == dimension) {
+        result.emplace_back(cpx_->filtration(get<0>(pair)), cpx_->filtration(get<1>(pair)));
+      }
+    }
+    return result;
+  }
+
+ private:
+  /*
+   * Structure representing a cocycle.
+   */
+  struct cocycle {
+    cocycle()
+        : row_(nullptr),
+          characteristics_() {
+    }
+    cocycle(Arith_element characteristics, Hcell * row)
+        : row_(row),
+          characteristics_(characteristics) {
+    }
+
+    Hcell * row_;                    // points to the corresponding row in the CAM
+    Arith_element characteristics_;  // product of field characteristics for which the cocycle exist
+  };
+
+ public:
+  FilteredComplex * cpx_;
+  int dim_max_;
+  CoefficientField coeff_field_;
+  size_t num_simplices_;
+
+  /*  Disjoint sets data structure to link the model of FilteredComplex
+   * with the compressed annotation matrix.
+   * ds_rank_ is a property map Simplex_key -> int, ds_parent_ is a property map
+   * Simplex_key -> simplex_key_t */
+  std::vector<int> ds_rank_;
+  std::vector<Simplex_key> ds_parent_;
+  std::vector<Column *> ds_repr_;
+  boost::disjoint_sets<int *, Simplex_key *> dsets_;
+  /* The compressed annotation matrix fields.*/
+  Cam cam_;
+  /*  Dictionary establishing the correspondence between the Simplex_key of
+   * the root vertex in the union-find ds and the Simplex_key of the vertex which
+   * created the connected component as a 0-dimension homology feature.*/
+  std::unordered_map<Simplex_key, Simplex_key> zero_cocycles_;
+  /*  Key -> row. */
+  std::map<Simplex_key, cocycle> transverse_idx_;
+  /* Persistent intervals. */
+  std::vector<Persistent_interval> persistent_pairs_;
+  length_interval interval_length_policy;
+
+  Simple_object_pool<Column> column_pool_;
+  Simple_object_pool<Cell> cell_pool_;
+};
+
+}  // namespace persistent_cohomology
+
+}  // namespace Gudhi
+
+#endif  // PERSISTENT_COHOMOLOGY_H_