multipers 2.3.3b6__cp312-cp312-macosx_10_13_x86_64.whl

multipers/gudhi/gudhi/Simplex_tree_multi.h

@@ -0,0 +1,152 @@
+/*    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): David
+ * Loiseaux, Hannah Schreiber
+ *
+ *    Copyright (C) 2023 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+#ifndef SIMPLEX_TREE_MULTI_H_
+#define SIMPLEX_TREE_MULTI_H_
+
+#include <algorithm>
+#include <cstdint>
+#include <vector>
+#include <gudhi/Simplex_tree.h>
+
+namespace Gudhi {
+namespace multi_persistence {
+
+/** Model of SimplexTreeOptions, with a multiparameter filtration.
+ * \ingroup multi_persistence
+ * */
+template <typename Filtration>
+struct Simplex_tree_options_multidimensional_filtration {
+ public:
+  typedef linear_indexing_tag Indexing_tag;
+  typedef int Vertex_handle;
+  using Filtration_value = Filtration;
+  typedef typename Filtration::value_type value_type;
+  typedef std::uint32_t Simplex_key;
+  static const bool store_key = true;
+  static const bool store_filtration = true;
+  static const bool contiguous_vertices = false;
+  static const bool link_nodes_by_label = false;
+  static const bool stable_simplex_handles = false;
+  static const bool is_multi_parameter = true;
+};
+
+/**
+ * \brief Turns a 1-parameter simplextree into a multiparameter simplextree,
+ * and keeps the 1-filtration in the 1st axis.
+ * Default values can be specified.
+ * \ingroup multi_persistence
+ * \tparam simplextree_std A non-multi simplextree
+ * \tparam simplextree_multi A multi simplextree
+ * \param st Simplextree to copy
+ * \param st_multi Multiparameter simplextree container to fill.
+ * \param default_values If given, this vector is assume to be of size `num_parameters-1` and contains the default
+ * values of axes `1` to `num_parameters`.
+ * */
+template <class simplextree_std, class simplextree_multi>
+void multify(simplextree_std &st,
+             simplextree_multi &st_multi,
+             const int num_parameters,
+             const typename simplextree_multi::Options::Filtration_value &default_values = {}) {
+  typename simplextree_multi::Options::Filtration_value f(num_parameters);
+  static_assert(!simplextree_std::Options::is_multi_parameter && simplextree_multi::Options::is_multi_parameter,
+                "Can only convert non-multiparameter to multiparameter simplextree.");
+  unsigned int num_default_values = 0;
+  if constexpr (simplextree_multi::Options::Filtration_value::is_multi_critical) {
+    num_default_values = default_values[0].size();
+  } else {
+    num_default_values = default_values.size();
+  }
+  for (auto i = 0u;
+       i < std::min(num_default_values, num_parameters < 1 ? 0u : static_cast<unsigned int>(num_parameters - 1));
+       i++) {
+    if constexpr (simplextree_multi::Options::Filtration_value::is_multi_critical) {
+      f[0][i + 1] = default_values[0][i];
+    } else {
+      f[i + 1] = default_values[i];
+    }
+  }
+
+  std::vector<int> simplex;
+  simplex.reserve(st.dimension() + 1);
+  for (auto &simplex_handle : st.complex_simplex_range()) {
+    simplex.clear();
+    for (auto vertex : st.simplex_vertex_range(simplex_handle)) simplex.push_back(vertex);
+
+    if (num_parameters > 0) {
+      if constexpr (simplextree_multi::Options::Filtration_value::is_multi_critical) {
+        f[0][0] = st.filtration(simplex_handle);
+      } else {
+        f[0] = st.filtration(simplex_handle);
+      }
+    }
+    st_multi.insert_simplex(simplex, f);
+  }
+  st_multi.set_number_of_parameters(num_parameters);
+}
+
+/**
+ * \brief Turns a multiparameter-parameter simplextree into a 1-parameter
+ * simplextree.
+ * \ingroup multi_persistence
+ * \tparam simplextree_std A non-multi simplextree
+ * \tparam simplextree_multi A multi simplextree
+ * \param st Simplextree to fill.
+ * \param st_multi Multiparameter simplextree to convert into a 1 parameter simplex tree.
+ * \param dimension The filtration parameter to put into the 1 parameter simplextree.
+ * */
+template <class simplextree_std, class simplextree_multi>
+void flatten(simplextree_std &st, simplextree_multi &st_multi, const int dimension = 0) {
+  static_assert(!simplextree_std::Options::is_multi_parameter && simplextree_multi::Options::is_multi_parameter,
+                "Can only convert multiparameter to non-multiparameter simplextree.");
+  for (const auto &simplex_handle : st_multi.complex_simplex_range()) {
+    std::vector<int> simplex;
+    typename simplextree_multi::Options::value_type f;
+    for (auto vertex : st_multi.simplex_vertex_range(simplex_handle)) simplex.push_back(vertex);
+    if constexpr (simplextree_multi::Filtration_value::is_multi_critical) {
+      f = dimension >= 0 ? st_multi.filtration(simplex_handle)[0][dimension] : 0;
+    } else {
+      f = dimension >= 0 ? st_multi.filtration(simplex_handle)[dimension] : 0;
+    }
+    st.insert_simplex(simplex, f);
+  }
+}
+
+// TODO: following not in the planned version in Gudhi. So either remove from here, or add there.
+
+/**
+ * \brief Applies a linear form (given by a scalar product, via Riesz
+ * representation) to the filtration values of the multiparameter simplextree to
+ * get a 1 parameter simplextree. \ingroup multiparameter \tparam
+ * simplextree_std A non-multi simplextree \tparam simplextree_multi A multi
+ * simplextree \param st Simplextree, with the same simplicial complex as
+ * st_multi, whose filtration has to be filled. \param st_multi Multiparameter
+ * simplextree to convert into a 1 parameter simplex tree. \param linear_form
+ * the linear form to apply.
+ * */
+template <class simplextree_std, class simplextree_multi>
+void linear_projection(simplextree_std &st, simplextree_multi &st_multi, const std::vector<double> &linear_form) {
+  static_assert(!simplextree_std::Options::is_multi_parameter && simplextree_multi::Options::is_multi_parameter,
+                "Can only convert multiparameter to non-multiparameter simplextree.");
+  auto sh = st.complex_simplex_range().begin();
+  auto sh_multi = st_multi.complex_simplex_range().begin();
+  auto end = st.complex_simplex_range().end();
+  typename simplextree_multi::Options::Filtration_value multi_filtration;
+  for (; sh != end; ++sh, ++sh_multi) {
+    multi_filtration = st_multi.filtration(*sh_multi);
+    auto projected_filtration = compute_linear_projection(multi_filtration, linear_form);
+    st.assign_filtration(*sh, projected_filtration);
+  }
+}
+
+}  // namespace multi_persistence
+}  // namespace Gudhi
+
+#endif  // SIMPLEX_TREE_MULTI_H_

multipers/gudhi/gudhi/distance_functions.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) 2014 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#ifndef DISTANCE_FUNCTIONS_H_
+#define DISTANCE_FUNCTIONS_H_
+
+#include <gudhi/Debug_utils.h>
+
+#include <boost/range/metafunctions.hpp>
+#include <boost/range/size.hpp>
+
+#include <cmath>  // for std::sqrt
+#include <type_traits>  // for std::decay
+#include <iterator>  // for std::begin, std::end
+#include <utility>
+
+namespace Gudhi {
+
+/** @file
+ * @brief Global distance functions
+ */
+
+/** @brief Compute the Euclidean distance between two Points given by a range of coordinates. The points are assumed to
+ * have the same dimension. */
+class Euclidean_distance {
+ public:
+  // boost::range_value is not SFINAE-friendly so we cannot use it in the return type
+  template< typename Point >
+  typename std::iterator_traits<typename boost::range_iterator<Point>::type>::value_type
+  operator()(const Point& p1, const Point& p2) const {
+    auto it1 = std::begin(p1);
+    auto it2 = std::begin(p2);
+    typedef typename boost::range_value<Point>::type NT;
+    NT dist = 0;
+    for (; it1 != std::end(p1); ++it1, ++it2) {
+      GUDHI_CHECK(it2 != std::end(p2), "inconsistent point dimensions");
+      NT tmp = *it1 - *it2;
+      dist += tmp*tmp;
+    }
+    GUDHI_CHECK(it2 == std::end(p2), "inconsistent point dimensions");
+    using std::sqrt;
+    return sqrt(dist);
+  }
+  template< typename T >
+  T operator() (const std::pair< T, T >& f, const std::pair< T, T >& s) const {
+    T dx = f.first - s.first;
+    T dy = f.second - s.second;
+    using std::sqrt;
+    return sqrt(dx*dx + dy*dy);
+  }
+};
+
+}  // namespace Gudhi
+
+#endif  // DISTANCE_FUNCTIONS_H_

multipers/gudhi/gudhi/graph_simplicial_complex.h

@@ -0,0 +1,104 @@
+/*    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 GRAPH_SIMPLICIAL_COMPLEX_H_
+#define GRAPH_SIMPLICIAL_COMPLEX_H_
+
+#include <boost/graph/adjacency_list.hpp>
+
+#include <utility>  // for pair<>
+#include <vector>
+#include <map>
+#include <tuple>  // for std::tie
+
+namespace Gudhi {
+/** @file
+ * @brief Graph simplicial complex methods
+ */
+
+/* Edge tag for Boost PropertyGraph. */
+struct edge_filtration_t {
+  typedef boost::edge_property_tag kind;
+};
+
+/* Vertex tag for Boost PropertyGraph. */
+struct vertex_filtration_t {
+  typedef boost::vertex_property_tag kind;
+};
+
+/** \brief Proximity_graph contains the vertices and edges with their filtration values in order to store the result
+ * of `Gudhi::compute_proximity_graph` function.
+ *
+ * \tparam SimplicialComplexForProximityGraph furnishes `Filtration_value` type definition.
+ *
+ */
+template <typename SimplicialComplexForProximityGraph>
+using Proximity_graph = typename boost::adjacency_list < boost::vecS, boost::vecS, boost::directedS
+, boost::property < vertex_filtration_t, typename SimplicialComplexForProximityGraph::Filtration_value >
+, boost::property < edge_filtration_t, typename SimplicialComplexForProximityGraph::Filtration_value >>;
+
+/** \brief Computes the proximity graph of the points.
+ *
+ * If points contains n elements, the proximity graph is the graph with n vertices, and an edge [u,v] iff the
+ * distance function between points u and v is smaller than threshold.
+ *
+ * \tparam SimplicialComplexForProximityGraph furnishes `Filtration_value` and `Vertex_handle` type definitions.
+ *
+ * \tparam ForwardPointRange furnishes `.begin()` and `.end()` methods.
+ *
+ * \tparam Distance furnishes `operator()(const Point& p1, const Point& p2)`, where
+ * `Point` is a point from the `ForwardPointRange`, and that returns a `Filtration_value`.
+ */
+template< typename SimplicialComplexForProximityGraph
+          , typename ForwardPointRange
+          , typename Distance >
+Proximity_graph<SimplicialComplexForProximityGraph> compute_proximity_graph(
+    const ForwardPointRange& points,
+    typename SimplicialComplexForProximityGraph::Filtration_value threshold,
+    Distance distance) {
+  using Vertex_handle = typename SimplicialComplexForProximityGraph::Vertex_handle;
+  using Filtration_value = typename SimplicialComplexForProximityGraph::Filtration_value;
+
+  std::vector<std::pair< Vertex_handle, Vertex_handle >> edges;
+  std::vector< Filtration_value > edges_fil;
+  std::map< Vertex_handle, Filtration_value > vertices;
+
+  Vertex_handle idx_u, idx_v;
+  Filtration_value fil;
+  idx_u = 0;
+  for (auto it_u = points.begin(); it_u != points.end(); ++it_u) {
+    idx_v = idx_u + 1;
+    for (auto it_v = it_u + 1; it_v != points.end(); ++it_v, ++idx_v) {
+      fil = distance(*it_u, *it_v);
+      if (fil <= threshold) {
+        edges.emplace_back(idx_u, idx_v);
+        edges_fil.push_back(fil);
+      }
+    }
+    ++idx_u;
+  }
+
+  // Points are labeled from 0 to idx_u-1
+  Proximity_graph<SimplicialComplexForProximityGraph> skel_graph(edges.begin(), edges.end(), edges_fil.begin(), idx_u);
+
+  auto vertex_prop = boost::get(vertex_filtration_t(), skel_graph);
+
+  typename boost::graph_traits<Proximity_graph<SimplicialComplexForProximityGraph>>::vertex_iterator vi, vi_end;
+  for (std::tie(vi, vi_end) = boost::vertices(skel_graph);
+       vi != vi_end; ++vi) {
+    boost::put(vertex_prop, *vi, 0.);
+  }
+
+  return skel_graph;
+}
+
+}  // namespace Gudhi
+
+#endif  // GRAPH_SIMPLICIAL_COMPLEX_H_

multipers/gudhi/gudhi/persistence_interval.h

@@ -0,0 +1,253 @@
+/*    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) 2024 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+/**
+ * @file persistence_interval.h
+ * @author Hannah Schreiber
+ * @brief Contains @ref Gudhi::persistence_matrix::Persistence_interval class.
+ */
+
+#ifndef PM_INTERVAL_INCLUDED
+#define PM_INTERVAL_INCLUDED
+
+#include <ostream>  //std::ostream
+#include <limits>   //std::numeric_limits
+#include <tuple>
+#include <utility>  //std::move
+
+namespace Gudhi {
+namespace persistence_matrix {
+
+/**
+ * @class Persistence_interval persistence_interval.h gudhi/persistence_interval.h
+ * @ingroup persistence_matrix
+ *
+ * @brief Type for an interval in a persistent diagram or barcode. Stores the birth, death and dimension of the
+ * interval. It can be used as a tuple with `get`/`std::get` (birth, death and dimension in this order),
+ * `std::tuple_element` and `std::tuple_size`, as well as structured binding.
+ *
+ * @tparam Dimension Type of the dimension value.
+ * @tparam Event_value Type of the birth and death value.
+ */
+template <typename Dimension, typename Event_value>
+struct Persistence_interval {
+  /**
+   * @brief Stores the infinity value for birth and death events. Its value depends on the template parameter
+   * `Event_value`:
+   * - if `Event_value` has a native infinity value, it takes this value,
+   * - otherwise, if `Event_value` is a signed type, it takes value -1,
+   * - otherwise, if `Event_value` is a unsigned type, it takes the maximal possible value.
+   *
+   * Is also used as default value for birth and death attributes when not initialized.
+   */
+  static constexpr Event_value inf = std::numeric_limits<Event_value>::has_infinity
+                                         ? std::numeric_limits<Event_value>::infinity()
+                                         : static_cast<Event_value>(-1);
+
+  /**
+   * @brief Constructor.
+   *
+   * @param birth Birth value of the cycle. Default value: @ref inf.
+   * @param death Death value of the cycle. Default value: @ref inf.
+   * @param dim Dimension of the cycle. Default value: -1.
+   */
+  Persistence_interval(Event_value birth = inf, Event_value death = inf, Dimension dim = -1)
+      : dim(dim), birth(birth), death(death) {}
+
+  Dimension dim;     /**< Dimension of the cycle.*/
+  Event_value birth; /**< Birth value of the cycle. */
+  Event_value death; /**< Death value of the cycle. */
+
+  /**
+   * @brief operator<<
+   *
+   * @param stream outstream
+   * @param interval interval to stream
+   */
+  inline friend std::ostream& operator<<(std::ostream& stream, const Persistence_interval& interval) {
+    stream << "[" << interval.dim << "] ";
+    if constexpr (std::numeric_limits<Event_value>::has_infinity) {
+      stream << interval.birth << " - " << interval.death;
+    } else {
+      if (interval.birth == inf)
+        stream << "inf";
+      else
+        stream << interval.birth;
+      stream << " - ";
+      if (interval.death == inf)
+        stream << "inf";
+      else
+        stream << interval.death;
+    }
+    return stream;
+  }
+
+  /**
+   * @brief Specialization of `get` for @ref Gudhi::persistence_matrix::Persistence_interval.
+   *
+   * @tparam I Index of the value to return: 0 for the birth value, 1 for the death value and 2 for the dimension.
+   * @return Either the birth value if @p I == 0, the death value if @p I == 1 or the dimension if @p I == 2.
+   */
+  template <std::size_t I>
+  constexpr auto& get() & noexcept {
+    static_assert(I < 3, "Value mismatch at argument 1 in template parameter list. Maximal possible value is 2.");
+
+    if constexpr (I == 0) return birth;
+    if constexpr (I == 1) return death;
+    if constexpr (I == 2) return dim;
+  }
+
+  /**
+   * @brief Specialization of `get` for @ref Gudhi::persistence_matrix::Persistence_interval.
+   *
+   * @tparam I Index of the value to return: 0 for the birth value, 1 for the death value and 2 for the dimension.
+   * @return Either the birth value if @p I == 0, the death value if @p I == 1 or the dimension if @p I == 2.
+   */
+  template <std::size_t I>
+  constexpr const auto& get() const& noexcept {
+    static_assert(I < 3, "Value mismatch at argument 1 in template parameter list. Maximal possible value is 2.");
+
+    if constexpr (I == 0) return birth;
+    if constexpr (I == 1) return death;
+    if constexpr (I == 2) return dim;
+  }
+
+  /**
+   * @brief Specialization of `get` for @ref Gudhi::persistence_matrix::Persistence_interval.
+   *
+   * @tparam I Index of the value to return: 0 for the birth value, 1 for the death value and 2 for the dimension.
+   * @return Either the birth value if @p I == 0, the death value if @p I == 1 or the dimension if @p I == 2.
+   */
+  template <std::size_t I>
+  constexpr auto&& get() && noexcept {
+    static_assert(I < 3, "Value mismatch at argument 1 in template parameter list. Maximal possible value is 2.");
+
+    if constexpr (I == 0) return std::move(birth);
+    if constexpr (I == 1) return std::move(death);
+    if constexpr (I == 2) return std::move(dim);
+  }
+
+  /**
+   * @brief Specialization of `get` for @ref Gudhi::persistence_matrix::Persistence_interval.
+   *
+   * @tparam I Index of the value to return: 0 for the birth value, 1 for the death value and 2 for the dimension.
+   * @return Either the birth value if @p I == 0, the death value if @p I == 1 or the dimension if @p I == 2.
+   */
+  template <std::size_t I>
+  constexpr const auto&& get() const&& noexcept {
+    static_assert(I < 3, "Value mismatch at argument 1 in template parameter list. Maximal possible value is 2.");
+
+    if constexpr (I == 0) return std::move(birth);
+    if constexpr (I == 1) return std::move(death);
+    if constexpr (I == 2) return std::move(dim);
+  }
+};
+
+}  // namespace persistence_matrix
+}  // namespace Gudhi
+
+namespace std {
+
+/**
+ * @ingroup persistence_matrix
+ *
+ * @brief Partial specialization of `std::tuple_size` for @ref Gudhi::persistence_matrix::Persistence_interval.
+ *
+ * @tparam Dimension First template parameter of @ref Gudhi::persistence_matrix::Persistence_interval.
+ * @tparam Event_value Second template parameter of @ref Gudhi::persistence_matrix::Persistence_interval.
+ */
+template <typename Dimension, typename Event_value>
+struct tuple_size<Gudhi::persistence_matrix::Persistence_interval<Dimension, Event_value> >
+    : integral_constant<size_t, 3> {};
+
+/**
+ * @ingroup persistence_matrix
+ *
+ * @brief Partial specialization of `std::tuple_element` for @ref Gudhi::persistence_matrix::Persistence_interval.
+ *
+ * @tparam I Index of the type to store: 0 for the birth value type, 1 for the death value type and 2 for the
+ * dimension value type.
+ * @tparam Dimension First template parameter of @ref Gudhi::persistence_matrix::Persistence_interval.
+ * @tparam Event_value Second template parameter of @ref Gudhi::persistence_matrix::Persistence_interval.
+ */
+template <size_t I, typename Dimension, typename Event_value>
+struct tuple_element<I, Gudhi::persistence_matrix::Persistence_interval<Dimension, Event_value> > {
+  static_assert(I < 3, "Value mismatch at argument 1 in template parameter list. Maximal possible value is 2.");
+
+  using type = typename conditional <I < 2, Event_value, Dimension>::type;
+};
+
+/**
+ * @ingroup persistence_matrix
+ *
+ * @brief Partial specialization of `get` for @ref Gudhi::persistence_matrix::Persistence_interval.
+ * 
+ * @tparam I Index of the value to return: 0 for the birth value, 1 for the death value and 2 for the dimension.
+ * @tparam Dimension First template parameter of @ref Gudhi::persistence_matrix::Persistence_interval.
+ * @tparam Event_value Second template parameter of @ref Gudhi::persistence_matrix::Persistence_interval.
+ * @param i Interval from which the value should be returned.
+ * @return Either the birth value if @p I == 0, the death value if @p I == 1 or the dimension if @p I == 2.
+ */
+template <size_t I, typename Dimension, typename Event_value>
+constexpr auto& get(Gudhi::persistence_matrix::Persistence_interval<Dimension, Event_value>& i) noexcept {
+  return i.template get<I>();
+}
+
+/**
+ * @ingroup persistence_matrix
+ *
+ * @brief Partial specialization of `get` for @ref Gudhi::persistence_matrix::Persistence_interval.
+ * 
+ * @tparam I Index of the value to return: 0 for the birth value, 1 for the death value and 2 for the dimension.
+ * @tparam Dimension First template parameter of @ref Gudhi::persistence_matrix::Persistence_interval.
+ * @tparam Event_value Second template parameter of @ref Gudhi::persistence_matrix::Persistence_interval.
+ * @param i Interval from which the value should be returned.
+ * @return Either the birth value if @p I == 0, the death value if @p I == 1 or the dimension if @p I == 2.
+ */
+template <size_t I, typename Dimension, typename Event_value>
+constexpr const auto& get(const Gudhi::persistence_matrix::Persistence_interval<Dimension, Event_value>& i) noexcept {
+  return i.template get<I>();
+}
+
+/**
+ * @ingroup persistence_matrix
+ *
+ * @brief Partial specialization of `get` for @ref Gudhi::persistence_matrix::Persistence_interval.
+ * 
+ * @tparam I Index of the value to return: 0 for the birth value, 1 for the death value and 2 for the dimension.
+ * @tparam Dimension First template parameter of @ref Gudhi::persistence_matrix::Persistence_interval.
+ * @tparam Event_value Second template parameter of @ref Gudhi::persistence_matrix::Persistence_interval.
+ * @param i Interval from which the value should be returned.
+ * @return Either the birth value if @p I == 0, the death value if @p I == 1 or the dimension if @p I == 2.
+ */
+template <size_t I, typename Dimension, typename Event_value>
+constexpr auto&& get(Gudhi::persistence_matrix::Persistence_interval<Dimension, Event_value>&& i) noexcept {
+  return std::move(i).template get<I>();
+}
+
+/**
+ * @ingroup persistence_matrix
+ *
+ * @brief Partial specialization of `get` for @ref Gudhi::persistence_matrix::Persistence_interval.
+ * 
+ * @tparam I Index of the value to return: 0 for the birth value, 1 for the death value and 2 for the dimension.
+ * @tparam Dimension First template parameter of @ref Gudhi::persistence_matrix::Persistence_interval.
+ * @tparam Event_value Second template parameter of @ref Gudhi::persistence_matrix::Persistence_interval.
+ * @param i Interval from which the value should be returned.
+ * @return Either the birth value if @p I == 0, the death value if @p I == 1 or the dimension if @p I == 2.
+ */
+template <size_t I, typename Dimension, typename Event_value>
+constexpr const auto&& get(const Gudhi::persistence_matrix::Persistence_interval<Dimension, Event_value>&& i) noexcept {
+  return std::move(i).template get<I>();
+}
+
+}  // namespace std
+
+#endif  // PM_INTERVAL_INCLUDED