multipers 2.4.0b1__cp312-cp312-macosx_11_0_arm64.whl

multipers/gudhi/gudhi/Simplex_tree/serialization_utils.h

@@ -0,0 +1,60 @@
+/*    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 {
+
+/**
+ * @private
+ * @ingroup 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;
+}
+
+/**
+ * @private
+ * @ingroup simplex_tree
+ * \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);
+}
+
+}  // namespace simplex_tree
+
+}  // namespace Gudhi
+
+#endif  // SIMPLEX_TREE_SERIALIZATION_UTILS_H_

multipers/gudhi/gudhi/Simplex_tree/simplex_tree_options.h

@@ -0,0 +1,105 @@
+/*    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
+
+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;
+};
+
+/** 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;
+};
+
+/** 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;
+};
+
+/** @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;
+};
+
+/** @}*/  // 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; };
+
+
+}  // namespace Gudhi
+
+#endif  // SIMPLEX_TREE_SIMPLEX_TREE_OPTIONS_H_