multipers 2.2.3__cp310-cp310-win_amd64.whl → 2.3.1__cp310-cp310-win_amd64.whl

multipers/gudhi/gudhi/Simplex_tree/hooks_simplex_base.h

@@ -1,62 +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_
+/*    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

@@ -1,27 +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_
+/*    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_

multipers/gudhi/gudhi/Simplex_tree/serialization_utils.h

@@ -1,62 +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):       Vincent Rouvreau
- *
- *    Copyright (C) 2023 Inria
- *
- *    Modification(s):
- *      - YYYY/MM Author: Description of the modification
- */
-
-#ifndef SIMPLEX_TREE_SERIALIZATION_UTILS_H_
-#define SIMPLEX_TREE_SERIALIZATION_UTILS_H_
-
-#include <cstring>  // for memcpy and std::size_t
-
-namespace Gudhi {
-
-namespace simplex_tree {
-
-/** \brief Serialize the given value and insert it at start position.
- * 
- * @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<class ArgumentType>
-char* serialize_trivial(ArgumentType value, char* start) {
-  std::size_t arg_size = sizeof(ArgumentType);
-  memcpy(start, &value, arg_size);
-  return start + arg_size;
-}
-
-/** \brief Deserialize at the start position in an array of char and sets the value with it.
- * 
- * @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<class ArgumentType>
-const char* deserialize_trivial(ArgumentType& value, const char* start) {
-  std::size_t arg_size = sizeof(ArgumentType);
-  memcpy(&value, start, arg_size);
-  return (start + arg_size);
-}
-
-/**
- * @brief Returns the size of the serialization of the given object.
- */
-template<class ArgumentType>
-constexpr std::size_t get_serialization_size_of([[maybe_unused]] ArgumentType value) {
-  return sizeof(ArgumentType);
-}
-
-}  // namespace simplex_tree
-
-}  // namespace Gudhi
-
-#endif  // SIMPLEX_TREE_SERIALIZATION_UTILS_H_
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    Author(s):       Vincent Rouvreau
+ *
+ *    Copyright (C) 2023 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#ifndef SIMPLEX_TREE_SERIALIZATION_UTILS_H_
+#define SIMPLEX_TREE_SERIALIZATION_UTILS_H_
+
+#include <cstring>  // for memcpy and std::size_t
+
+namespace Gudhi {
+
+namespace simplex_tree {
+
+/** \brief Serialize the given value and insert it at start position.
+ * 
+ * @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<class ArgumentType>
+char* serialize_trivial(ArgumentType value, char* start) {
+  std::size_t arg_size = sizeof(ArgumentType);
+  memcpy(start, &value, arg_size);
+  return start + arg_size;
+}
+
+/** \brief Deserialize at the start position in an array of char and sets the value with it.
+ * 
+ * @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<class ArgumentType>
+const char* deserialize_trivial(ArgumentType& value, const char* start) {
+  std::size_t arg_size = sizeof(ArgumentType);
+  memcpy(&value, start, arg_size);
+  return (start + arg_size);
+}
+
+/**
+ * @brief Returns the size of the serialization of the given object.
+ */
+template<class ArgumentType>
+constexpr std::size_t get_serialization_size_of([[maybe_unused]] ArgumentType value) {
+  return sizeof(ArgumentType);
+}
+
+}  // namespace simplex_tree
+
+}  // namespace Gudhi
+
+#endif  // SIMPLEX_TREE_SERIALIZATION_UTILS_H_

multipers/gudhi/gudhi/Simplex_tree/simplex_tree_options.h

@@ -1,157 +1,157 @@
-/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
- *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
- *    Author(s):       Vincent Rouvreau
- *
- *    Copyright (C) 2023 Inria
- *
- *    Modification(s):
- *      - YYYY/MM Author: Description of the modification
- */
-
-#ifndef SIMPLEX_TREE_SIMPLEX_TREE_OPTIONS_H_
-#define SIMPLEX_TREE_SIMPLEX_TREE_OPTIONS_H_
-
-#include <gudhi/Simplex_tree/indexing_tag.h>
-
-#include <cstdint>
-#include <type_traits>  // void_t
-#include <cmath>        // std::isnan
-
-namespace Gudhi {
-
-/** \addtogroup simplex_tree 
- * Pre-defined options for the Simplex_tree.
- *  @{
- */
-
-/** Model of SimplexTreeOptions.
- * 
- * Default options version of the Simplex_tree.
- * 
- * Maximum number of simplices to compute persistence is <CODE>std::numeric_limits<std::uint32_t>::max()</CODE>
- * (about 4 billions of simplices). */
-struct Simplex_tree_options_default {
-  typedef linear_indexing_tag Indexing_tag;
-  typedef int Vertex_handle;
-  typedef double Filtration_value;
-  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 = false;
-};
-
-/** Model of SimplexTreeOptions.
- * 
- * Maximum number of simplices to compute persistence is <CODE>std::numeric_limits<std::uint32_t>::max()</CODE>
- * (about 4 billions of simplices). */
-struct Simplex_tree_options_full_featured {
-  typedef linear_indexing_tag Indexing_tag;
-  typedef int Vertex_handle;
-  typedef double Filtration_value;
-  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 = true;
-  static const bool stable_simplex_handles = true;
-  static const bool is_multi_parameter = false;
-};
-
-/** Model of SimplexTreeOptions.
- * 
- * Minimal version of the Simplex_tree. No filtration values are stored and it is impossible to compute persistence
- * with these options. */
-struct Simplex_tree_options_minimal {
-  typedef linear_indexing_tag Indexing_tag;
-  typedef int Vertex_handle;
-  typedef double Filtration_value;
-  typedef std::uint32_t Simplex_key;
-  static const bool store_key = false;
-  static const bool store_filtration = false;
-  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 = false;
-};
-
-/** @private @brief Model of SimplexTreeOptions, faster than `Simplex_tree_options_default` but note the unsafe
- * `contiguous_vertices` option.
- * 
- * Maximum number of simplices to compute persistence is <CODE>std::numeric_limits<std::uint32_t>::max()</CODE>
- * (about 4 billions of simplices). */
-struct Simplex_tree_options_fast_persistence {
-  typedef linear_indexing_tag Indexing_tag;
-  typedef int Vertex_handle;
-  typedef float Filtration_value;
-  typedef std::uint32_t Simplex_key;
-  static const bool store_key = true;
-  static const bool store_filtration = true;
-  static const bool contiguous_vertices = true;
-  static const bool link_nodes_by_label = false;
-  static const bool stable_simplex_handles = false;
-  static const bool is_multi_parameter = false;
-};
-
-/** @}*/  // end addtogroup simplex_tree
-
-struct No_simplex_data {};
-
-// Nested `type` is O::Simplex_data if that exists, No_simplex_data otherwise
-template <class, class=void> struct Get_simplex_data_type { typedef No_simplex_data type; };
-template <class O>
-struct Get_simplex_data_type<O, std::void_t<typename O::Simplex_data>> { typedef typename O::Simplex_data type; };
-
-/**
- * @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, Arithmetic_filtration_value f2)
-{
-  if (f2 < f1){
-    f1 = f2;
-    return true;
-  }
-  return false;
-}
-
-/**
- * @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, Arithmetic_filtration_value f2)
-{
-  if constexpr (std::is_floating_point_v<Arithmetic_filtration_value>) {
-    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;
-  }
-}
-
-}  // namespace Gudhi
-
-#endif  // SIMPLEX_TREE_SIMPLEX_TREE_OPTIONS_H_
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    Author(s):       Vincent Rouvreau
+ *
+ *    Copyright (C) 2023 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#ifndef SIMPLEX_TREE_SIMPLEX_TREE_OPTIONS_H_
+#define SIMPLEX_TREE_SIMPLEX_TREE_OPTIONS_H_
+
+#include <gudhi/Simplex_tree/indexing_tag.h>
+
+#include <cstdint>
+#include <type_traits>  // void_t
+#include <cmath>        // std::isnan
+
+namespace Gudhi {
+
+/** \addtogroup simplex_tree 
+ * Pre-defined options for the Simplex_tree.
+ *  @{
+ */
+
+/** Model of SimplexTreeOptions.
+ * 
+ * Default options version of the Simplex_tree.
+ * 
+ * Maximum number of simplices to compute persistence is <CODE>std::numeric_limits<std::uint32_t>::max()</CODE>
+ * (about 4 billions of simplices). */
+struct Simplex_tree_options_default {
+  typedef linear_indexing_tag Indexing_tag;
+  typedef int Vertex_handle;
+  typedef double Filtration_value;
+  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 = false;
+};
+
+/** Model of SimplexTreeOptions.
+ * 
+ * Maximum number of simplices to compute persistence is <CODE>std::numeric_limits<std::uint32_t>::max()</CODE>
+ * (about 4 billions of simplices). */
+struct Simplex_tree_options_full_featured {
+  typedef linear_indexing_tag Indexing_tag;
+  typedef int Vertex_handle;
+  typedef double Filtration_value;
+  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 = true;
+  static const bool stable_simplex_handles = true;
+  static const bool is_multi_parameter = false;
+};
+
+/** Model of SimplexTreeOptions.
+ * 
+ * Minimal version of the Simplex_tree. No filtration values are stored and it is impossible to compute persistence
+ * with these options. */
+struct Simplex_tree_options_minimal {
+  typedef linear_indexing_tag Indexing_tag;
+  typedef int Vertex_handle;
+  typedef double Filtration_value;
+  typedef std::uint32_t Simplex_key;
+  static const bool store_key = false;
+  static const bool store_filtration = false;
+  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 = false;
+};
+
+/** @private @brief Model of SimplexTreeOptions, faster than `Simplex_tree_options_default` but note the unsafe
+ * `contiguous_vertices` option.
+ * 
+ * Maximum number of simplices to compute persistence is <CODE>std::numeric_limits<std::uint32_t>::max()</CODE>
+ * (about 4 billions of simplices). */
+struct Simplex_tree_options_fast_persistence {
+  typedef linear_indexing_tag Indexing_tag;
+  typedef int Vertex_handle;
+  typedef float Filtration_value;
+  typedef std::uint32_t Simplex_key;
+  static const bool store_key = true;
+  static const bool store_filtration = true;
+  static const bool contiguous_vertices = true;
+  static const bool link_nodes_by_label = false;
+  static const bool stable_simplex_handles = false;
+  static const bool is_multi_parameter = false;
+};
+
+/** @}*/  // end addtogroup simplex_tree
+
+struct No_simplex_data {};
+
+// Nested `type` is O::Simplex_data if that exists, No_simplex_data otherwise
+template <class, class=void> struct Get_simplex_data_type { typedef No_simplex_data type; };
+template <class O>
+struct Get_simplex_data_type<O, std::void_t<typename O::Simplex_data>> { typedef typename O::Simplex_data type; };
+
+/**
+ * @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, Arithmetic_filtration_value f2)
+{
+  if (f2 < f1){
+    f1 = f2;
+    return true;
+  }
+  return false;
+}
+
+/**
+ * @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, Arithmetic_filtration_value f2)
+{
+  if constexpr (std::is_floating_point_v<Arithmetic_filtration_value>) {
+    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;
+  }
+}
+
+}  // namespace Gudhi
+
+#endif  // SIMPLEX_TREE_SIMPLEX_TREE_OPTIONS_H_