multipers 2.4.0b1__cp312-cp312-macosx_11_0_arm64.whl

multipers/gudhi/gudhi/multi_simplex_tree_helpers.h

@@ -0,0 +1,147 @@
+/*    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
+ *
+ *    Copyright (C) 2023 Inria
+ *
+ *    Modification(s):
+ *      - 2025/04 Hannah Schreiber: simplifications with new simplex tree constructors + name changes
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+/**
+ * @file multi_simplex_tree_helpers.h
+ * @author David Loiseaux
+ * @brief Contains the @ref Gudhi::multi_persistence::Simplex_tree_options_multidimensional_filtration struct,
+ * as well as the two helper methods @ref Gudhi::multi_persistence::make_multi_dimensional and
+ * @ref Gudhi::multi_persistence::make_one_dimensional.
+ */
+
+#ifndef MP_MULTI_SIMPLEX_TREE_HELPERS_H_
+#define MP_MULTI_SIMPLEX_TREE_HELPERS_H_
+
+#include <cstddef>
+#include <type_traits>
+
+#include <gudhi/Debug_utils.h>
+#include <gudhi/Simplex_tree.h>
+#include <gudhi/Simplex_tree/simplex_tree_options.h>
+
+namespace Gudhi {
+namespace multi_persistence {
+
+/**
+ * @ingroup multi_persistence
+ *
+ * @brief Model of @ref SimplexTreeOptions. Same as @ref Gudhi::Simplex_tree_options_default but with a custom
+ * filtration value type.
+ *
+ * @tparam MultiFiltrationValue Has to respect the @ref FiltrationValue concept.
+ */
+template <typename MultiFiltrationValue>
+struct Simplex_tree_options_multidimensional_filtration : Simplex_tree_options_default {
+  using Filtration_value = MultiFiltrationValue;
+};
+
+/**
+ * @ingroup multi_persistence
+ *
+ * @brief Constructs a multi-dimensional simplex tree from the given one-dimensional simplex tree.
+ *
+ * All simplices are copied from the one-dimensional simplex tree \f$ st \f$ to the multi-dimensional simplex tree
+ * \f$ st_multi \f$. To begin, all filtration values of \f$ st_multi \f$ are initialized to the given default value.
+ * Then, all filtration values of \f$ st \f$ are projected onto \f$ st_multi \f$ at the given dimension index.
+ *
+ * @tparam MultiDimSimplexTreeOptions Options for the multi-dimensional simplex tree. Should follow the
+ * @ref SimplexTreeOptions concept. It has to define a @ref FiltrationValue with the additional methods:
+ * `num_parameters()` which returns the number of parameters, `num_generators()` which returns the number of generators
+ * and `operator(g, p)` which return a (modifiable) reference to the \f$ p^{th} \f$ element of the \f$ g^{th} \f$
+ * generator. It should also define a type `value_type` with the type of an element in the filtration value.
+ * @tparam OneDimSimplexTree Type of the one-dimensional @ref Gudhi::Simplex_tree. The `Filtration_value` type has to
+ * be convertible to the `Filtration_value::value_type` of `MultiDimSimplexTreeOptions`.
+ * @param st Simplex tree to project.
+ * @param default_value Default value of the multi-dimensional filtration values. Has therefore to contain at least
+ * one generator and as many parameters than the final tree should have. One of the elements of the first generator
+ * will take the value of the projected value, so make sure to initialize the default value such that the `operator()`
+ * makes the change of value possible.
+ * @param dimension Dimension index to which the filtration values should be projected onto.
+ */
+template <class MultiDimSimplexTreeOptions, class OneDimSimplexTree>
+Simplex_tree<MultiDimSimplexTreeOptions> make_multi_dimensional(
+    const OneDimSimplexTree &st,
+    const typename MultiDimSimplexTreeOptions::Filtration_value &default_value,
+    const std::size_t dimension = 0)
+{
+  using OneDimF = typename OneDimSimplexTree::Options::Filtration_value;
+  using MultiDimF = typename MultiDimSimplexTreeOptions::Filtration_value;
+
+  static_assert(std::is_convertible_v<OneDimF, typename MultiDimF::value_type>,
+                "A filtration value of the one dimensional tree should be convertible to an element of a filtration "
+                "value of the multi dimensional simplex tree.");
+
+  auto num_param = default_value.num_parameters();
+
+  GUDHI_CHECK(dimension < num_param,
+              "Given dimension is too high, it has to be smaller than the number of parameters.");
+  GUDHI_CHECK(default_value.num_generators() > 0,
+              "The default value for the filtration values should contain at least one generator.");
+
+  auto translate = [&](const OneDimF &f) -> MultiDimF {
+    auto res = default_value;
+    res(0, dimension) = f;
+    return res;
+  };
+
+  Simplex_tree<MultiDimSimplexTreeOptions> multi_st(st, translate);
+  multi_st.set_num_parameters(num_param);
+
+  return multi_st;
+}
+
+/**
+ * @ingroup multi_persistence
+ *
+ * @brief Constructs a one-dimensional simplex tree from the given multi-dimensional simplex tree.
+ *
+ * All simplices are copied from the multi-dimensional simplex tree \f$ st \f$ to the one-dimensional simplex tree
+ * \f$ st_one \f$. All filtration values of \f$ st_one \f$ are initialized with the element value at given dimension
+ * index of the first generator of the corresponding multi-dimensional filtration value in \f$ st \f$.
+ *
+ * @tparam OneDimSimplexTreeOptions Options for the one-dimensional simplex tree. Should follow the
+ * @ref SimplexTreeOptions concept.
+ * @tparam MultiDimSimplexTree Type of the multi-dimensional @ref Gudhi::Simplex_tree. It has to define a
+ * @ref FiltrationValue with the additional methods: `num_parameters()` which returns the number of parameters,
+ * `num_generators()` which returns the number of generators and `operator(g, p)` which returns the value of the
+ * \f$ p^{th} \f$ element of the \f$ g^{th} \f$ generator. It should also define a type `value_type` with the type of
+ * an element in the filtration value, which has to be convertible to `Filtration_value` of `OneDimSimplexTreeOptions`.
+ * @param st Simplex tree to project.
+ * @param dimension Dimension index in the first generator to project.
+ */
+template <class OneDimSimplexTreeOptions, class MultiDimSimplexTree>
+Simplex_tree<OneDimSimplexTreeOptions> make_one_dimensional(const MultiDimSimplexTree &st,
+                                                            const std::size_t dimension = 0)
+{
+  using OneDimF = typename OneDimSimplexTreeOptions::Filtration_value;
+  using MultiDimF = typename MultiDimSimplexTree::Options::Filtration_value;
+
+  static_assert(std::is_convertible_v<typename MultiDimF::value_type, OneDimF>,
+                "An element of a filtration value of the multi dimensional tree should be convertible to a filtration "
+                "value of the one dimensional simplex tree.");
+
+  auto translate = [dimension](const MultiDimF &f) -> OneDimF {
+    GUDHI_CHECK(dimension < f.num_parameters(),
+                "Given dimension is too high, it has to be smaller than the number of parameters.");
+    GUDHI_CHECK(f.num_generators() > 0, "A filtration value of the multi tree should contain at least one generator.");
+    return f(0, dimension);
+  };
+
+  Simplex_tree<OneDimSimplexTreeOptions> one_st(st, translate);
+  one_st.set_num_parameters(1);
+
+  return one_st;
+}
+
+}  // namespace multi_persistence
+}  // namespace Gudhi
+
+#endif  // MP_MULTI_SIMPLEX_TREE_HELPERS_H_

multipers/gudhi/gudhi/persistence_interval.h

@@ -0,0 +1,263 @@
+/*    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
+   */
+  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 = conditional_t < I<2, Event_value, Dimension>;
+};
+
+/**
+ * @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

multipers/gudhi/gudhi/persistence_matrix_options.h

@@ -0,0 +1,188 @@
+/*    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) 2022-24 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+/**
+ * @file persistence_matrix_options.h
+ * @author Hannah Schreiber
+ * @brief Contains the options for the matrix template.
+ */
+
+#ifndef PM_OPTIONS_INCLUDED
+#define PM_OPTIONS_INCLUDED
+
+#include <cstdint>  // std::uint8_t
+
+#include <gudhi/Fields/Zp_field_operators.h>
+
+namespace Gudhi {
+namespace persistence_matrix {
+
+/**
+ * @ingroup persistence_matrix
+ *
+ * @brief List of column types.
+ */
+enum class Column_types : std::uint8_t {
+  LIST,           /**< @ref List_column "": Underlying container is a std::list<@ref Entry*>. */
+  SET,            /**< @ref Set_column "": Underlying container is a std::set<@ref Entry*>. */
+  HEAP,           /**< @ref Heap_column "": Underlying container is a std::vector<@ref Entry*> ordered as a heap.
+                       Is not compatible with row access and column compression. */
+  VECTOR,         /**< @ref Vector_column "": Underlying container is a std::vector<@ref Entry*>
+                       with a lazy removal method. */
+  NAIVE_VECTOR,   /**< @ref Naive_vector_column "": Underlying container is a std::vector<@ref Entry*>. */
+  SMALL_VECTOR,   /**< @ref Naive_vector_column "": Underlying container is a
+                       boost::container::small_vector<@ref Entry*, 8>. */
+  UNORDERED_SET,  /**< @ref Unordered_set_column "": Underlying container is a std::unordered_set<@ref Entry*>. */
+  INTRUSIVE_LIST, /**< @ref Intrusive_list_column "": Underlying container is a boost::intrusive::list<@ref Entry>. */
+  INTRUSIVE_SET   /**< @ref Intrusive_set_column "": Underlying container is a boost::intrusive::set<@ref Entry>. */
+};
+
+/**
+ * @ingroup persistence_matrix
+ *
+ * @brief List if indexation schemes. See @ref mp_indexation "description of indexation schemes" for more details
+ * about the meaning of the indexation types.
+ */
+enum class Column_indexation_types : std::uint8_t {
+  CONTAINER, /**< Default use of @ref MatIdx indices. */
+  POSITION,  /**< All input and output @ref MatIdx indices are replaced with @ref PosIdx indices. */
+  IDENTIFIER /**< All input and output @ref MatIdx indices are replaced with @ref IDIdx indices. */
+};
+
+/**
+ * @struct Default_options persistence_matrix_options.h gudhi/persistence_matrix_options.h
+ * @ingroup persistence_matrix
+ *
+ * @brief Default option structure for @ref Matrix class.
+ * See the @ref PersistenceMatrixOptions concept for a more detailed description of the fields.
+ * Produces a @ref basematrix "base matrix" with no enabled option.
+ *
+ * To create other matrix types, the easiest is to simply inherit from this structure and overwrite only the options
+ * one is interested in.
+ *
+ * @tparam col_type Column type for the matrix. Default value: @ref Column_types::INTRUSIVE_SET
+ * @tparam is_z2_only Flag indicating if only \f$Z_2\f$ coefficient will be used with the matrix. Set to true if it
+ * is the case, false otherwise. Default value: true.
+ * @tparam FieldOperators Field operators used by the matrix, see FieldOperators concept.
+ * Only necessary if @p is_z2_only is false.
+ * Default value: @ref Gudhi::persistence_fields::Zp_field_operators<>.
+ */
+template <Column_types col_type = Column_types::INTRUSIVE_SET,
+          bool is_z2_only = true,
+          class FieldOperators = persistence_fields::Zp_field_operators<> >
+struct Default_options {
+  using Field_coeff_operators = FieldOperators;
+  using Dimension = int;
+  using Index = unsigned int;
+
+  static const bool is_z2 = is_z2_only;
+  static const Column_types column_type = col_type;
+
+  static const Column_indexation_types column_indexation_type = Column_indexation_types::CONTAINER;
+
+  static const bool has_column_compression = false;
+  static const bool has_column_and_row_swaps = false;
+
+  static const bool has_map_column_container = false;
+  static const bool has_removable_columns = false;
+
+  static const bool has_row_access = false;
+  static const bool has_intrusive_rows = true;
+  static const bool has_removable_rows = false;
+
+  static const bool is_of_boundary_type = true;
+
+  static const bool has_matrix_maximal_dimension_access = false;
+  static const bool has_column_pairings = false;
+  static const bool has_vine_update = false;
+  static const bool can_retrieve_representative_cycles = false;
+};
+
+// TODO: The following structures are the one used by the other modules or debug tests.
+//  They will probably be removed once the module was properly integrated.
+
+/**
+ * @brief Options used for the Zigzag persistence module.
+ *
+ * @tparam column_type Column type for the matrix.
+ */
+template <Column_types column_type = Column_types::INTRUSIVE_LIST>
+struct Zigzag_options : Default_options<column_type, true> {
+  static const bool has_row_access = true;
+  static const bool has_column_pairings = false;
+  static const bool has_vine_update = true;
+  static const bool is_of_boundary_type = false;
+  static const bool has_map_column_container = true;
+  static const bool has_removable_columns = true;
+  static const bool has_removable_rows = true;
+};
+
+/**
+ * @brief Options needed to use the representative cycles.
+ *
+ * @tparam col_type Column type for the matrix.
+ */
+template <Column_types col_type = Column_types::INTRUSIVE_SET>
+struct Representative_cycles_options : Default_options<col_type, true> {
+  static const bool has_column_pairings = true;
+  static const bool can_retrieve_representative_cycles = true;
+};
+
+/**
+ * @brief Options used by the Multipersistence module.
+ *
+ * @tparam column_type Column type for the matrix.
+ */
+template <Column_types column_type = Column_types::INTRUSIVE_SET>
+struct Multi_persistence_options : Default_options<column_type, true> {
+  static const bool has_column_pairings = true;
+  static const bool has_vine_update = true;
+};
+
+/**
+ * @brief Options used by the cohomology module.
+ *
+ * @tparam column_type Column type for the matrix.
+ * @tparam is_z2_only True if Z2.
+ * @tparam FieldOperators Field operator.
+ */
+template <Column_types column_type = Column_types::INTRUSIVE_LIST,
+          bool is_z2_only = true,
+          class FieldOperators = persistence_fields::Zp_field_operators<> >
+struct Cohomology_persistence_options : Default_options<column_type, is_z2_only, FieldOperators> {
+  static const bool has_row_access = true;
+  static const bool has_column_compression = true;
+  static const bool has_removable_rows = true;
+};
+
+/**
+ * @private
+ */
+template <typename T>
+class RangeTraits
+{
+ private:
+  static auto check_begin(...) -> std::false_type;
+  template <typename U>
+  static auto check_begin(const U& x) -> decltype(x.begin(), std::true_type{});
+
+  static auto check_size(...) -> std::false_type;
+  template <typename U>
+  static auto check_size(const U& x) -> decltype(x.size(), std::true_type{});
+
+ public:
+  static constexpr bool has_begin = decltype(check_begin(std::declval<T>()))::value;
+  static constexpr bool has_size = decltype(check_size(std::declval<T>()))::value;
+};
+
+}  // namespace persistence_matrix
+}  // namespace Gudhi
+
+#endif  // PM_OPTIONS_INCLUDED