multipers 2.4.0b1__cp312-cp312-macosx_11_0_arm64.whl

multipers/gudhi/gudhi/Simplex_tree/Simplex_tree_siblings.h

@@ -0,0 +1,121 @@
+/*    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 SIMPLEX_TREE_SIMPLEX_TREE_SIBLINGS_H_
+#define SIMPLEX_TREE_SIMPLEX_TREE_SIBLINGS_H_
+
+#include <gudhi/Simplex_tree/simplex_tree_options.h>
+#include <gudhi/Simplex_tree/Simplex_tree_node_explicit_storage.h>
+
+#include <boost/container/flat_map.hpp>
+
+namespace Gudhi {
+
+/** \addtogroup simplex_tree
+ * Represents a set of node of a Simplex_tree that share the same parent.
+ * @{
+ */
+
+/** \brief Data structure to store a set of nodes in a SimplexTree sharing
+ * the same parent node.*/
+template<class SimplexTree, class MapContainer>
+class Simplex_tree_siblings {
+// private:
+//  friend SimplexTree;
+ public:
+  template<class T> friend class Simplex_tree_simplex_vertex_iterator;
+  template<class T> friend class Simplex_tree_boundary_simplex_iterator;
+  template<class T> friend class Simplex_tree_complex_simplex_iterator;
+  template<class T> friend class Simplex_tree_skeleton_simplex_iterator;
+  template<class T> friend class Simplex_tree_boundary_opposite_vertex_simplex_iterator;
+
+  typedef typename SimplexTree::Vertex_handle Vertex_handle;
+  typedef typename SimplexTree::Filtration_value Filtration_value;
+  typedef typename SimplexTree::Node Node;
+  typedef MapContainer Dictionary;
+  typedef typename MapContainer::iterator Dictionary_it;
+  typedef typename MapContainer::const_iterator Dictionary_const_it;
+
+  /* Default constructor.*/
+  Simplex_tree_siblings()
+      : oncles_(nullptr),
+        parent_(-1),
+        members_() {
+  }
+
+  /* Constructor with values.*/
+  Simplex_tree_siblings(Simplex_tree_siblings * oncles, Vertex_handle parent)
+      : oncles_(oncles),
+        parent_(parent),
+        members_() {
+  }
+
+  /** \brief Constructor with initialized set of members.
+   *
+   * 'members' must be sorted and unique.*/
+  template<typename RandomAccessVertexRange>
+  Simplex_tree_siblings(Simplex_tree_siblings * oncles, Vertex_handle parent, const RandomAccessVertexRange & members)
+      : oncles_(oncles),
+        parent_(parent),
+        members_(boost::container::ordered_unique_range, members.begin(),
+                 members.end()) {
+    for (auto& map_el : members_) {
+      map_el.second.assign_children(this);
+    }
+  }
+
+  Dictionary_it find(Vertex_handle v) {
+    return members_.find(v);
+  }
+  Dictionary_const_it find(Vertex_handle v) const {
+    return members_.find(v);
+  }
+
+  Simplex_tree_siblings * oncles() {
+    return oncles_;
+  }
+  const Simplex_tree_siblings * oncles() const {
+    return oncles_;
+  }
+
+  Vertex_handle parent() const {
+    return parent_;
+  }
+
+  Dictionary & members() {
+    return members_;
+  }
+
+  const Dictionary & members() const {
+    return members_;
+  }
+
+  size_t size() const {
+    return members_.size();
+  }
+
+  void erase(const Dictionary_it iterator) {
+    members_.erase(iterator);
+  }
+
+  Dictionary_it to_non_const_it(Dictionary_const_it it) {
+    return members_.erase(it, it);
+  }
+
+  Simplex_tree_siblings * oncles_;
+  Vertex_handle parent_;
+  Dictionary members_;
+};
+
+/** @}*/  // end addtogroup simplex_tree
+
+}  // namespace Gudhi
+
+#endif  // SIMPLEX_TREE_SIMPLEX_TREE_SIBLINGS_H_

multipers/gudhi/gudhi/Simplex_tree/Simplex_tree_star_simplex_iterators.h

@@ -0,0 +1,277 @@
+/*    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) 2020 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#ifndef SIMPLEX_TREE_SIMPLEX_TREE_STAR_SIMPLEX_ITERATORS_H_
+#define SIMPLEX_TREE_SIMPLEX_TREE_STAR_SIMPLEX_ITERATORS_H_
+
+#include <gudhi/Debug_utils.h>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/version.hpp>
+#include <boost/iterator/filter_iterator.hpp>
+
+#include <vector>
+#include <stdexcept>
+#include <utility>  // for std::move
+#include <functional>  // for std::greater
+#include <algorithm>  // for std::includes
+
+namespace Gudhi {
+
+/** \private
+ * \brief Iterator over all the roots of subtrees containing cofaces of all
+ * dimension of a given simplex.
+ *
+ * Specifically, consider a simplex \f$\sigma\f$ whose vertices have maximal label
+ * u. A maximal subtree of cofaces for \f$\sigma\f$ is a subtree of the simplex tree
+ * rooted at a Node of label u, for which the root represents itself a coface of
+ * \f$\sigma\f$.
+ *
+ * \details All Nodes of the simplex must store intrusive list hooks (option
+ * link_nodes_by_label == true) in order to connect all nodes with a fixed label u
+ * into a list.
+ *
+ * Forward iterator, value_type is SimplexTree::Simplex_handle.
+ *
+ * The implementation uses a filter iterator on all Nodes of label u, checking
+ * whether they represent a coface of \f$\sigma\f$ or not.
+ */
+template <class SimplexTree>
+class Simplex_tree_optimized_cofaces_rooted_subtrees_simplex_iterator
+    : public boost::iterator_facade<Simplex_tree_optimized_cofaces_rooted_subtrees_simplex_iterator<SimplexTree>,
+                                    typename SimplexTree::Simplex_handle const, boost::forward_traversal_tag> {
+ public:
+  using Simplex_handle = typename SimplexTree::Simplex_handle;
+  using Siblings = typename SimplexTree::Siblings;
+  using Vertex_handle = typename SimplexTree::Vertex_handle;
+  using Node = typename SimplexTree::Node;
+  using Static_vertex_vector = typename SimplexTree::Static_vertex_vector;
+
+  /** \brief Predicate to check whether an input SimplexTree::Node represents a
+   * coface of a simplex simp_, stored as a std::vector of
+   * SimplexTree::Vertex_handle sorted in decreasing Vertex_handle order.
+   *
+   * \details Given a SimplexHandle in a simplex tree cpx_, traverses the tree
+   * upwards
+   * to find the sequence of Vertex_handle of simp_ as a subsequence of labels
+   * encountered.
+   * Does not test sh itself.
+   * Used for filter_iterator in the optimized algorithm for
+   * star_simplex_range.
+   */
+  class is_coface {
+   public:
+    is_coface() : cpx_(nullptr) {}
+    is_coface(SimplexTree const* cpx, Static_vertex_vector&& simp) : cpx_(cpx), simp_(simp) {}
+
+    // Return true iff traversing the Node upwards to the root reads a
+    // coface of simp_
+    bool operator()(const typename SimplexTree::Hooks_simplex_base& curr_hooks) {
+      const Node& curr_node = static_cast<const Node&>(curr_hooks);
+      Simplex_handle sh = cpx_->simplex_handle_from_node(curr_node);
+      // first Node must always have label simp_.begin(); we assume it is true
+      auto&& rng = cpx_->simplex_vertex_range(sh);
+      auto rng_it = rng.begin();
+      GUDHI_CHECK(*rng_it == simp_.front(), std::invalid_argument("first Node must always have label simp_.begin()"));
+      auto simp_it = simp_.begin();
+      // is simp_ a face of the simplex defined by sh ?
+      return std::includes(++rng_it, rng.end(), ++simp_it, simp_.end(), std::greater<Vertex_handle>());
+    }
+
+   private:
+    SimplexTree const* cpx_;
+    Static_vertex_vector simp_;  // vertices of simplex, in reverse order
+  };
+
+  typedef boost::filter_iterator<is_coface, typename SimplexTree::List_max_vertex::const_iterator>
+      Filtered_cofaces_simplex_iterator;
+  // any end() iterator
+  Simplex_tree_optimized_cofaces_rooted_subtrees_simplex_iterator() : predicate_(), st_(nullptr) {}
+
+  Simplex_tree_optimized_cofaces_rooted_subtrees_simplex_iterator(SimplexTree const* cpx,
+                                                                  Static_vertex_vector&& simp)
+      : predicate_(cpx, std::move(simp)), st_(cpx) {
+    GUDHI_CHECK(!simp.empty(), std::invalid_argument("cannot call for cofaces of an empty simplex"));
+    const auto list_ptr = st_->nodes_by_label(simp.front());
+    GUDHI_CHECK(list_ptr != nullptr, std::runtime_error("invalid call to cofaces forest"));
+
+    it_ = boost::make_filter_iterator(predicate_, list_ptr->begin(), list_ptr->end());
+    end_ = boost::make_filter_iterator(predicate_, list_ptr->end(), list_ptr->end());
+    const Node& curr_node = static_cast<const Node&>(*it_);
+    sh_ = st_->simplex_handle_from_node(curr_node);
+  }
+
+ private:
+  friend class boost::iterator_core_access;
+
+  // valid when iterating along the SAME list of max vertex.
+  bool equal(Simplex_tree_optimized_cofaces_rooted_subtrees_simplex_iterator const& other) const {
+    if (other.st_ == nullptr) {
+      return (st_ == nullptr);
+    }
+    if (st_ == nullptr) {
+      return false;
+    }
+    return (it_ == other.it_);
+  }
+
+  Simplex_handle const& dereference() const { return sh_; }
+
+  void increment() {
+    if (++it_ == end_) {
+      st_ = nullptr;
+    }       //== end
+    else {  // update sh_
+      const Node& curr_node = static_cast<const Node&>(*it_);
+      sh_ = st_->simplex_handle_from_node(curr_node);
+    }
+  }
+
+  // given a Node of label max_v, returns true if the associated simplex is a coface of the simplex {..., max_v}. The
+  // predicate stores the vertices of the simplex whose star we compute.
+  is_coface predicate_;
+  SimplexTree const* st_;
+  // filtered iterators over Nodes, filtered with predicate_
+  Filtered_cofaces_simplex_iterator it_;
+  Filtered_cofaces_simplex_iterator end_;
+  // current Simplex_handle corresponding to Node pointed at by it_
+  Simplex_handle sh_;
+};
+
+/** \brief Iterator over the simplices of the star of a simplex.
+ *
+ * \details All Nodes of the simplex must store intrusive list hooks (option
+ * link_nodes_by_label == true) in order to connect all nodes with a fixed label u
+ * into a list.
+ *
+ * Forward iterator, value_type is SimplexTree::Simplex_handle.
+ *
+ * The implementation uses a
+ * Simplex_tree_optimized_cofaces_rooted_subtrees_simplex_iterator to iterate through all
+ * roots of cofaces Nodes, and traverses each such subtree of the simplex tree.
+ */
+template <class SimplexTree>
+class Simplex_tree_optimized_star_simplex_iterator
+    : public boost::iterator_facade<Simplex_tree_optimized_star_simplex_iterator<SimplexTree>,
+                                    typename SimplexTree::Simplex_handle const, boost::forward_traversal_tag> {
+ public:
+  using Simplex_handle = typename SimplexTree::Simplex_handle;
+  using Siblings = typename SimplexTree::Siblings;
+  using Vertex_handle = typename SimplexTree::Vertex_handle;
+  using Node = typename SimplexTree::Node;
+  using Static_vertex_vector = typename SimplexTree::Static_vertex_vector;
+
+  // any end() iterator
+  Simplex_tree_optimized_star_simplex_iterator() : st_(nullptr) {}
+
+  Simplex_tree_optimized_star_simplex_iterator(SimplexTree const* cpx, Static_vertex_vector&& simp)
+      : st_(cpx), it_(cpx, std::move(simp)), end_(), sh_(*it_), sib_(st_->self_siblings(sh_)), children_stack_() {
+    if (it_ == end_) {
+      st_ = nullptr;
+      return;
+    }  // no coface subtree => end()
+    is_root_ = true;
+    sh_ = *it_;                      // sh_ is the root
+    sib_ = st_->self_siblings(sh_);  // Siblings containing sh_
+    if (st_->has_children(sh_)) {
+      children_stack_.push_back(st_->children(sh_));
+    }
+    return;  // first root of coface subtree
+  }
+
+ private:
+  friend class boost::iterator_core_access;
+
+  // valid when iterating along the SAME list of max vertex.
+  bool equal(Simplex_tree_optimized_star_simplex_iterator const& other) const {
+    if (other.st_ == nullptr) {
+      return (st_ == nullptr);
+    }
+    if (st_ == nullptr) {
+      return false;
+    }
+    return (&(sh_->second) == &(other.sh_->second));
+  }
+
+  Simplex_handle const& dereference() const { return sh_; }
+
+  /* Go to the next valid Simplex_handle for a coface, using a breadth first
+   * search approach.
+   *
+   * Invariant:
+   *
+   * sh_ is a coface,
+   * sib_ the Siblings containing sh_,
+   * it_ the root of a coface subtree, such that dim_root_ <= exact_dim_cofaces_.
+   * bfs_queue contains Siblings inside the coface subtree.
+   *
+   * Additionally,
+   *
+   *  - computing all cofaces: sh_ points to a coface of any dimension. bfs_queue
+   * contains a collection of Siblings* that must be considered (as well as there
+   * children). These are all sets of children of simplices in
+   * [ sib_->members().begin(), sh_ ]
+   */
+  void increment_all_cofaces() {
+    ++sh_;  // next sibling
+    // if no more sibling or root of coface tree, go down or to next subtree
+    if (is_root_ || sh_ == sib_->members().end()) {
+      is_root_ = false;
+      if (!children_stack_.empty()) {
+        sib_ = children_stack_.back();
+        children_stack_.pop_back();
+        sh_ = sib_->members().begin();  // don't track dimensions
+        if (st_->has_children(sh_)) {
+          children_stack_.push_back(st_->children(sh_));
+        }
+      } else {  // bfs_queue == empty, go to root of next coface subtree
+        if (++it_ == end_) {
+          st_ = nullptr;
+          return;
+        }  // no more subtree => end()
+        is_root_ = true;
+        sh_ = *it_;                      // sh_ is the root
+        sib_ = st_->self_siblings(sh_);  // Siblings containing sh_
+        if (st_->has_children(sh_)) {
+          children_stack_.push_back(st_->children(sh_));
+        }
+        return;  // next root of coface
+      }
+    } else {  // sh_ is valid, simply add its children to the queue
+      if (st_->has_children(sh_)) {
+        children_stack_.push_back(st_->children(sh_));
+      }
+    }
+  }
+
+  // For cofaces, enumerating all the star and testing which simplices have the right dimension is suboptimal.
+  // This could be optimized later.
+  void increment() { increment_all_cofaces(); }
+
+  // Let s be the simplex in a complex C whose star is
+  // iterated through. Let max_v denote the maximal label of vertices in s.
+  SimplexTree const* st_;  // Simplex tree for complex C
+  // The cofaces of s form a subforest of the simplex tree. The roots of trees in this
+  // forest have label max_v.
+  //[it_,end_) == range of Simplex_handles of the roots of the cofaces trees (any dim)
+  Simplex_tree_optimized_cofaces_rooted_subtrees_simplex_iterator<SimplexTree> it_;
+  Simplex_tree_optimized_cofaces_rooted_subtrees_simplex_iterator<SimplexTree> end_;
+  // curr Simplex_handle, returned by operator*, pointing to a coface of s
+  Simplex_handle sh_;
+  // set of siblings containing sh_ in the Simplex_tree
+  Siblings const* sib_;  //
+  // Save children in a list to avoid calling sib_->members().find(.)
+  std::vector<Siblings const*> children_stack_;
+  // true iff sh_ points to the root of a coface subtree
+  bool is_root_;
+};
+
+}  // namespace Gudhi
+
+#endif  // SIMPLEX_TREE_SIMPLEX_TREE_STAR_SIMPLEX_ITERATORS_H_

multipers/gudhi/gudhi/Simplex_tree/filtration_value_utils.h

@@ -0,0 +1,155 @@
+/*    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):       Hannah Schreiber
+ *
+ *    Copyright (C) 2025 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#ifndef SIMPLEX_TREE_FILTRATION_VALUE_UTILS_H_
+#define SIMPLEX_TREE_FILTRATION_VALUE_UTILS_H_
+
+#include <cstddef>  // std::size_t
+#include <limits>   // std::numeric_limits
+#include <cmath>    // std::isnan
+
+#include <gudhi/Simplex_tree/serialization_utils.h>
+
+namespace Gudhi {
+
+namespace simplex_tree {
+
+/**
+ * @ingroup simplex_tree
+ * @brief Returns `Filtration_value(0)` when converted to `Filtration_value`.
+ */
+inline struct empty_filtration_value_t {
+  template <class T> explicit operator T() const { return T(0); }
+} empty_filtration_value;
+
+}  // namespace simplex_tree
+
+/**
+ * @ingroup simplex_tree
+ * @brief Returns true if and only if the given filtration value is at infinity.
+ * This is the overload for when @ref FiltrationValue is an arithmetic type, like double, int etc. It simply
+ * tests equality with `std::numeric_limits<FiltrationValue>::infinity()` if defined or with
+ * `std::numeric_limits<FiltrationValue>::max()` otherwise. Can therefore be also used with other classes
+ * as long as infinity is defined that way.
+ */
+template <typename Arithmetic_filtration_value>
+bool is_positive_infinity(const Arithmetic_filtration_value& f)
+{
+  if constexpr (std::numeric_limits<Arithmetic_filtration_value>::has_infinity) {
+    return f == std::numeric_limits<Arithmetic_filtration_value>::infinity();
+  } else {
+    return f == std::numeric_limits<Arithmetic_filtration_value>::max();
+  }
+}
+
+/**
+ * @ingroup simplex_tree
+ * @brief Given two filtration values at which a simplex exists, stores in the first value the minimal union of births
+ * generating a lifetime including those two values.
+ * This is the overload for when @ref FiltrationValue is an arithmetic type, like double, int etc.
+ * Because the filtration values are totally ordered then, the union is simply the minimum of the two values.
+ *
+ * NaN values are not supported.
+ */
+template <typename Arithmetic_filtration_value>
+bool unify_lifetimes(Arithmetic_filtration_value& f1, const Arithmetic_filtration_value& f2)
+{
+  if (f2 < f1){
+    f1 = f2;
+    return true;
+  }
+  return false;
+}
+
+/**
+ * @ingroup simplex_tree
+ * @brief Given two filtration values, stores in the first value the lowest common upper bound of the two values.
+ * If a filtration value has value `NaN`, it should be considered as the lowest value possible.
+ * This is the overload for when @ref FiltrationValue is an arithmetic type, like double, float, int etc.
+ * Because the filtration values are totally ordered then, the upper bound is always the maximum of the two values.
+ */
+template <typename Arithmetic_filtration_value>
+bool intersect_lifetimes(Arithmetic_filtration_value& f1, const Arithmetic_filtration_value& f2)
+{
+  if constexpr (std::numeric_limits<Arithmetic_filtration_value>::has_quiet_NaN) {
+    if (std::isnan(f1)) {
+      f1 = f2;
+      return !std::isnan(f2);
+    }
+
+    // Computes the max while handling NaN as lowest value.
+    if (!(f1 < f2)) return false;
+
+    f1 = f2;
+    return true;
+  } else {
+    // NaN not possible.
+    if (f1 < f2){
+      f1 = f2;
+      return true;
+    }
+    return false;
+  }
+}
+
+/**
+ * @private
+ * @ingroup simplex_tree
+ * @brief Serialize the given value and insert it at start position using
+ * @ref Gudhi::simplex_tree::serialize_trivial "".
+ * 
+ * @tparam Trivial_filtration_value Type which can trivially be serialized with byte to byte copy of the content
+ * of the holding variable. E.g., native arithmetic types.
+ * @param[in] value The value to serialize.
+ * @param[in] start Start position where the value is serialized.
+ * @return The new position in the array of char for the next serialization.
+ * 
+ * @warning It is the user's responsibility to provide a pointer to a buffer with enough memory space.
+ */
+template <typename Trivial_filtration_value>
+char* serialize_value_to_char_buffer(Trivial_filtration_value value, char* start) {
+  return Gudhi::simplex_tree::serialize_trivial(value, start);
+}
+
+/**
+ * @private
+ * @ingroup simplex_tree
+ * @brief Deserialize at the start position in an array of char and sets the value with it using
+ * @ref Gudhi::simplex_tree::deserialize_trivial "".
+ * 
+ * @tparam Trivial_filtration_value Type which can trivially be serialized with byte to byte copy of the content
+ * of the holding variable. E.g., native arithmetic types.
+ * @param[in] value The value where to deserialize based on its type.
+ * @param[in] start Start position where the value is serialized.
+ * @return The new position in the array of char for the next deserialization.
+ * 
+ * @warning It is the user's responsibility to ensure that the pointer will not go out of bounds.
+ */
+template <typename Trivial_filtration_value>
+const char* deserialize_value_from_char_buffer(Trivial_filtration_value& value, const char* start) {
+  return Gudhi::simplex_tree::deserialize_trivial(value, start);
+}
+
+/**
+ * @private
+ * @ingroup simplex_tree
+ * @brief Returns the size of the template type `Trivial_filtration_value`.
+ * 
+ * @tparam Trivial_filtration_value Type which can trivially be serialized with byte to byte copy of the content
+ * of the holding variable. E.g., native arithmetic types.
+ */
+template<typename Trivial_filtration_value>
+constexpr std::size_t get_serialization_size_of([[maybe_unused]] Trivial_filtration_value value) {
+  return sizeof(Trivial_filtration_value);
+}
+
+}  // namespace Gudhi
+
+#endif  // SIMPLEX_TREE_FILTRATION_VALUE_UTILS_H_

multipers/gudhi/gudhi/Simplex_tree/hooks_simplex_base.h

@@ -0,0 +1,62 @@
+/*    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) 2020 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#ifndef SIMPLEX_TREE_HOOKS_SIMPLEX_BASE_H_
+#define SIMPLEX_TREE_HOOKS_SIMPLEX_BASE_H_
+
+#include <boost/intrusive/list.hpp>
+#include <stdexcept>
+
+namespace Gudhi {
+  /** \brief No hook when SimplexTreeOptions::link_nodes_by_label is false.
+   */
+  struct Hooks_simplex_base_dummy {};
+
+  /** \brief Data structure to put all simplex tree nodes with same label into a list.
+   *
+   * Allows one to access all subtrees of the simplex tree rooted at a node with a given label.
+   * Used in particular for fast cofaces location, and fast insertion and deletion of edges in a flag complex.
+   *
+   * Only if SimplexTreeOptions::link_nodes_by_label is true.
+   */
+  struct Hooks_simplex_base_link_nodes {
+   public:
+    Hooks_simplex_base_link_nodes() {}
+    // The following 2 functions are conceptually wrong, but when copying a Simplex_tree it is more convenient to have
+    // them (and fix things asap after they are called).
+    // copy constructor, inherited by the Node class, requires to copy hooks
+    Hooks_simplex_base_link_nodes(const Hooks_simplex_base_link_nodes&)
+    : list_max_vertex_hook_() { }
+    // copy assignment
+    Hooks_simplex_base_link_nodes& operator=(const Hooks_simplex_base_link_nodes&) {
+      throw std::logic_error("Should not happen");
+    }
+    // move constructor
+    Hooks_simplex_base_link_nodes(Hooks_simplex_base_link_nodes&& other) {
+      list_max_vertex_hook_.swap_nodes(other.list_max_vertex_hook_);
+    }
+    // move assignment
+    Hooks_simplex_base_link_nodes& operator=(Hooks_simplex_base_link_nodes&& other) {
+      list_max_vertex_hook_.swap_nodes(other.list_max_vertex_hook_);
+      return *this;
+    }
+    void unlink_hooks() { list_max_vertex_hook_.unlink(); }
+    ~Hooks_simplex_base_link_nodes() {}  // unlink_hooks(); }
+
+    typedef boost::intrusive::list_member_hook<  // allows .unlink()
+        boost::intrusive::link_mode<boost::intrusive::auto_unlink>>
+        Member_hook_t;
+
+    Member_hook_t list_max_vertex_hook_;
+  };
+
+}  // namespace Gudhi
+
+#endif  // SIMPLEX_TREE_HOOKS_SIMPLEX_BASE_H_

multipers/gudhi/gudhi/Simplex_tree/indexing_tag.h

@@ -0,0 +1,27 @@
+/*    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 SIMPLEX_TREE_INDEXING_TAG_H_
+#define SIMPLEX_TREE_INDEXING_TAG_H_
+
+namespace Gudhi {
+
+/** \brief Tag for a linear ordering of simplices. 
+ *
+ * \implements IndexingTag
+ */
+struct linear_indexing_tag {
+};
+
+/** \brief Tag for a zigzag ordering of simplices. */
+//  struct zigzag_indexing_tag {};
+}  // namespace Gudhi
+
+#endif  // SIMPLEX_TREE_INDEXING_TAG_H_