multipers 2.4.0b1__cp312-cp312-macosx_11_0_arm64.whl

multipers/gudhi/gudhi/Multi_filtration/multi_filtration_conversions.h

@@ -0,0 +1,237 @@
+/*    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
+ */
+
+/**
+ * @file multi_filtration_conversions.h
+ * @author Hannah Schreiber
+ */
+
+#ifndef MF_CONVERSIONS_H_
+#define MF_CONVERSIONS_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <numeric>
+#include <stdexcept>
+#include <type_traits>
+#include <vector>
+
+#include <gudhi/Multi_parameter_filtration.h>
+#include <gudhi/Dynamic_multi_parameter_filtration.h>
+#include <gudhi/Degree_rips_bifiltration.h>
+
+namespace Gudhi {
+
+namespace multi_filtration {
+
+/**
+ * @brief Converts the given multi filtration value into the type given as template argument. It is assumed that the
+ * given value is simplified (i.e. minimal and ordered lexicographically). If the new type is
+ * @ref Gudhi::multi_filtration::Degree_rips_bifiltration it is additionally assumed that the given value is compatible
+ *  with the type, that is,the number of parameters is 2 and the second parameter is an index (positive and convertible
+ * to an integer without loss).
+ *
+ * @tparam Out_multi_filtration New filtration value type. Has to be either
+ * @ref Gudhi::multi_filtration::Multi_parameter_filtration,
+ * @ref Gudhi::multi_filtration::Dynamic_multi_parameter_filtration or
+ * @ref Gudhi::multi_filtration::Degree_rips_bifiltration with desired template arguments.
+ * @tparam T First template argument of the initial filtration value type.
+ * @tparam Co Second template argument of the initial filtration value type.
+ * @tparam Ensure1Criticality Third template argument of the initial filtration value type.
+ * @param f Filtration value to convert.
+ */
+template <class Out_multi_filtration, typename T, bool Co, bool Ensure1Criticality>
+Out_multi_filtration as_type(const Multi_parameter_filtration<T, Co, Ensure1Criticality>& f)
+{
+  using U = typename Out_multi_filtration::value_type;
+  constexpr bool co = Out_multi_filtration::has_negative_cones();
+  constexpr bool one_crit = Out_multi_filtration::ensures_1_criticality();
+
+  if constexpr (std::is_same_v<Out_multi_filtration, Multi_parameter_filtration<U, co, one_crit> >) {
+    return f.template as_type<U, co, one_crit>();
+  } else if constexpr (std::is_same_v<Out_multi_filtration, Dynamic_multi_parameter_filtration<U, co, one_crit> >) {
+    return Out_multi_filtration(f.begin(), f.end(), f.num_parameters());
+  } else if constexpr (std::is_same_v<Out_multi_filtration, Degree_rips_bifiltration<U, co, one_crit> >) {
+    if (f.num_parameters() != 2) throw std::invalid_argument("Cannot convert a non-bifiltration to a bifiltration.");
+    U inf = co ? Out_multi_filtration::T_m_inf : Out_multi_filtration::T_inf;
+
+    T maxIndex = 0;
+    for (std::size_t g = 0; g < f.num_generators(); ++g) {
+      maxIndex = maxIndex < f(g, 1) ? f(g, 1) : maxIndex;
+    }
+
+    std::vector<U> values(maxIndex + 1, inf);
+    for (std::size_t g = 0; g < f.num_generators(); ++g) {
+      values[f(g, 1)] = f(g, 0);
+    }
+    return Out_multi_filtration(std::move(values), 2);
+  } else {
+    throw std::invalid_argument("Given out multi filtration value is not available.");
+  }
+}
+
+/**
+ * @brief Converts the given multi filtration value into the type given as template argument. It is assumed that the
+ * given value is simplified (i.e. minimal and ordered lexicographically). If the new type is
+ * @ref Gudhi::multi_filtration::Degree_rips_bifiltration it is additionally assumed that the given value is compatible
+ * with the type, that is,the number of parameters is 2 and the second parameter is an index (positive and convertible
+ * to an integer without loss).
+ *
+ * @tparam Out_multi_filtration New filtration value type. Has to be either
+ * @ref Gudhi::multi_filtration::Multi_parameter_filtration,
+ * @ref Gudhi::multi_filtration::Dynamic_multi_parameter_filtration or
+ * @ref Gudhi::multi_filtration::Degree_rips_bifiltration with desired template arguments.
+ * @tparam T First template argument of the initial filtration value type.
+ * @tparam Co Second template argument of the initial filtration value type.
+ * @tparam Ensure1Criticality Third template argument of the initial filtration value type.
+ * @param f Filtration value to convert.
+ */
+template <class Out_multi_filtration, typename T, bool Co, bool Ensure1Criticality>
+Out_multi_filtration as_type(const Dynamic_multi_parameter_filtration<T, Co, Ensure1Criticality>& f)
+{
+  using U = typename Out_multi_filtration::value_type;
+  constexpr bool co = Out_multi_filtration::has_negative_cones();
+  constexpr bool one_crit = Out_multi_filtration::ensures_1_criticality();
+
+  if constexpr (std::is_same_v<Out_multi_filtration, Multi_parameter_filtration<U, co, one_crit> >) {
+    std::vector<U> values(f.num_entries());
+    std::size_t i = 0;
+    for (std::size_t g = 0; g < f.num_generators(); ++g) {
+      for (std::size_t p = 0; p < f.num_parameters(); ++p) {
+        values[i] = f(g, p);
+        ++i;
+      }
+    }
+    return Out_multi_filtration(std::move(values), f.num_parameters());
+  } else if constexpr (std::is_same_v<Out_multi_filtration, Dynamic_multi_parameter_filtration<U, co, one_crit> >) {
+    return f.template as_type<U, co, one_crit>();
+  } else if constexpr (std::is_same_v<Out_multi_filtration, Degree_rips_bifiltration<U, co, one_crit> >) {
+    if (f.num_parameters() != 2) throw std::invalid_argument("Cannot convert a non-bifiltration to a bifiltration.");
+    U inf = co ? Out_multi_filtration::T_m_inf : Out_multi_filtration::T_inf;
+
+    T maxIndex = 0;
+    for (std::size_t g = 0; g < f.num_generators(); ++g) {
+      maxIndex = maxIndex < f(g, 1) ? f(g, 1) : maxIndex;
+    }
+
+    std::vector<U> values(maxIndex + 1, inf);
+    for (std::size_t g = 0; g < f.num_generators(); ++g) {
+      values[f(g, 1)] = f(g, 0);
+    }
+    return Out_multi_filtration(std::move(values), 2);
+  } else {
+    throw std::invalid_argument("Given out multi filtration value is not available.");
+  }
+}
+
+/**
+ * @brief Converts the given multi filtration value into the type given as template argument.
+ *
+ * @tparam Out_multi_filtration New filtration value type. Has to be either
+ * @ref Gudhi::multi_filtration::Multi_parameter_filtration,
+ * @ref Gudhi::multi_filtration::Dynamic_multi_parameter_filtration or
+ * @ref Gudhi::multi_filtration::Degree_rips_bifiltration with desired template arguments.
+ * @tparam T First template argument of the initial filtration value type.
+ * @tparam Co Second template argument of the initial filtration value type.
+ * @tparam Ensure1Criticality Third template argument of the initial filtration value type.
+ * @param f Filtration value to convert.
+ */
+template <class Out_multi_filtration, typename T, bool Co, bool Ensure1Criticality>
+Out_multi_filtration as_type(const Degree_rips_bifiltration<T, Co, Ensure1Criticality>& f)
+{
+  using U = typename Out_multi_filtration::value_type;
+  constexpr bool co = Out_multi_filtration::has_negative_cones();
+  constexpr bool one_crit = Out_multi_filtration::ensures_1_criticality();
+
+  if constexpr (std::is_same_v<Out_multi_filtration, Degree_rips_bifiltration<U, co, one_crit> >) {
+    return f.template as_type<U, co, one_crit>();
+  } else {
+    auto gen_index = [&f](std::size_t i) {
+      if constexpr (Out_multi_filtration::has_negative_cones()) {
+        return f.num_generators() - 1 - i;
+      } else {
+        return i;
+      }
+    };
+
+    auto strictly_dominates = [](T a, T b) {
+      if constexpr (Out_multi_filtration::has_negative_cones()) {
+        return a < b;
+      } else {
+        return a > b;
+      }
+    };
+
+    if (f.size() == 0) return Out_multi_filtration(0);
+
+    std::vector<std::size_t> order(f.num_generators());
+    std::iota(order.begin(), order.end(), 0);
+    // lexicographical order
+    std::sort(order.begin(), order.end(), [&](std::size_t i, std::size_t j){
+      if (f(i, 0) == f(j, 0)) return f(i, 1) < f(j, 1); // f(i, 1) and f(j, 1) cannot be equal for i != j
+      return f(i, 0) < f(j, 0);
+    });
+
+    if constexpr (std::is_same_v<Out_multi_filtration, Multi_parameter_filtration<U, co, one_crit> >) {
+      std::vector<U> values;
+      values.reserve(f.num_generators() * 2);
+      std::size_t g = order[gen_index(0)];
+      T threshold = g;
+      values.push_back(f(g, 0));
+      values.push_back(threshold);
+      for (std::size_t i = 1; i < f.num_generators(); ++i) {
+        g = order[gen_index(i)];
+        if (strictly_dominates(threshold, g)) {
+          threshold = g;
+          values.push_back(f(g, 0));
+          values.push_back(threshold);
+        }
+      }
+      if constexpr (co) {
+        // lexicographical order
+        const std::size_t max_idx = values.size() - 1;
+        for (std::size_t i = 0; i < values.size() / 2; i += 2) {
+          std::swap(values[i], values[max_idx - 1 - i]);
+          std::swap(values[i + 1], values[max_idx - i]);
+        }
+      }
+
+      return Out_multi_filtration(std::move(values), 2);
+    } else if constexpr (std::is_same_v<Out_multi_filtration, Dynamic_multi_parameter_filtration<U, co, one_crit> >) {
+      std::vector<Multi_parameter_generator<U> > values;
+      values.reserve(f.num_generators());
+      std::size_t g = order[gen_index(0)];
+      T threshold = g;
+      values.emplace_back(std::vector<T>{static_cast<T>(f(g, 0)), threshold});
+      for (std::size_t i = 1; i < f.num_generators(); ++i) {
+        g = order[gen_index(i)];
+        if (strictly_dominates(threshold, g)) {
+          threshold = g;
+          std::vector<T> v = {static_cast<T>(f(g, 0)), threshold};
+          values.emplace_back(std::move(v));
+        }
+      }
+      if constexpr (co) {
+        // lexicographical order
+        std::reverse(values.begin(), values.end());
+      }
+
+      return Out_multi_filtration(std::move(values), 2);
+    } else {
+      throw std::invalid_argument("Given out multi filtration value is not available.");
+    }
+  }
+}
+
+}  // namespace multi_filtration
+
+}  // namespace Gudhi
+
+#endif  // MF_CONVERSIONS_H_

multipers/gudhi/gudhi/Multi_filtration/multi_filtration_utils.h

@@ -0,0 +1,225 @@
+/*    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
+ */
+
+/**
+ * @private
+ * @file multi_filtration_utils.h
+ * @author Hannah Schreiber
+ */
+
+#ifndef MF_UTILS_H_
+#define MF_UTILS_H_
+
+#include <cstddef>
+#include <istream>
+#include <stdexcept>
+#include <type_traits>
+#include <limits>
+#include <cmath>
+
+namespace Gudhi {
+
+namespace multi_filtration {
+
+/**
+ * @private
+ */
+template <typename T>
+class RangeTraits
+{
+ private:
+  static auto check_begin(...) -> std::false_type;
+  template <typename U>
+  static auto check_begin(U x) -> decltype(x.begin(), std::true_type{});
+
+  static auto check_dynamic_filtration(...) -> std::false_type;
+  template <typename U>
+  static auto check_dynamic_filtration(U x) -> decltype(x.operator[](std::size_t{}), std::true_type{});
+
+  static auto check_filtration(...) -> std::false_type;
+  template <typename U>
+  static auto check_filtration(U x) -> decltype(x.ensures_1_criticality(), std::true_type{});
+
+ public:
+  static constexpr bool has_begin = decltype(check_begin(std::declval<T>()))::value;
+  static constexpr bool is_multi_filtration = decltype(check_filtration(std::declval<T>()))::value;
+  static constexpr bool is_dynamic_multi_filtration =
+      is_multi_filtration && decltype(check_dynamic_filtration(std::declval<T>()))::value;
+};
+
+/**
+ * @private
+ */
+template <typename T>
+constexpr bool _is_nan(T val)
+{
+  if constexpr (std::is_integral_v<T>) {
+    // to avoid Windows issue which don't know how to cast integers for cmath methods
+    return false;
+  } else {
+    return std::isnan(val);
+  }
+};
+
+/**
+ * @private
+ * @brief Infinity value of an entry of the filtration value.
+ */
+template <typename T>
+constexpr const T MF_T_inf =
+    std::numeric_limits<T>::has_infinity ? std::numeric_limits<T>::infinity() : std::numeric_limits<T>::max();
+
+/**
+ * @private
+ * @brief Minus infinity value of an entry of the filtration value.
+ */
+template <typename T>
+constexpr const T MF_T_m_inf =
+    std::numeric_limits<T>::has_infinity ? -std::numeric_limits<T>::infinity() : std::numeric_limits<T>::lowest();
+
+/**
+ * @private
+ * @brief Adds v1 and v2, stores the result in v1 and returns true if and only if v1 was modified.
+ */
+template <typename T>
+constexpr bool _add(T &v1, T v2)
+{
+  if (_is_nan(v1) || _is_nan(v2) || (v1 == MF_T_inf<T> && v2 == MF_T_m_inf<T>) ||
+      (v1 == MF_T_m_inf<T> && v2 == MF_T_inf<T>)) {
+    v1 = std::numeric_limits<T>::quiet_NaN();
+    return false;
+  }
+  if (v1 == MF_T_inf<T> || v1 == MF_T_m_inf<T>) {
+    return true;
+  }
+  if (v2 == MF_T_inf<T> || v2 == MF_T_m_inf<T>) {
+    v1 = v2;
+    return true;
+  }
+
+  v1 += v2;
+  return true;
+};
+
+/**
+ * @private
+ * @brief Subtracts v1 and v2, stores the result in v1 and returns true if and only if v1 was modified.
+ */
+template <typename T>
+constexpr bool _subtract(T &v1, T v2)
+{
+  return _add(v1, v2 == MF_T_inf<T> ? MF_T_m_inf<T> : (v2 == MF_T_m_inf<T> ? MF_T_inf<T> : -v2));
+};
+
+/**
+ * @private
+ * @brief Multiplies v1 and v2, stores the result in v1 and returns true if and only if v1 was modified.
+ */
+template <typename T>
+constexpr bool _multiply(T &v1, T v2)
+{
+  bool v1_is_infinite = v1 == MF_T_inf<T> || v1 == MF_T_m_inf<T>;
+  bool v2_is_infinite = v2 == MF_T_inf<T> || v2 == MF_T_m_inf<T>;
+
+  if (_is_nan(v1) || _is_nan(v2) || (v1_is_infinite && v2 == 0) || (v1 == 0 && v2_is_infinite)) {
+    v1 = std::numeric_limits<T>::quiet_NaN();
+    return false;
+  }
+
+  if ((v1 == MF_T_inf<T> && v2 > 0) || (v1 == MF_T_m_inf<T> && v2 < 0) || (v1 < 0 && v2 == MF_T_m_inf<T>) ||
+      (v1 > 0 && v2 == MF_T_inf<T>)) {
+    v1 = MF_T_inf<T>;
+    return true;
+  }
+
+  if ((v1 == MF_T_inf<T> && v2 < 0) || (v1 == MF_T_m_inf<T> && v2 > 0) || (v1 > 0 && v2 == MF_T_m_inf<T>) ||
+      (v1 < 0 && v2 == MF_T_inf<T>)) {
+    v1 = MF_T_m_inf<T>;
+    return true;
+  }
+
+  v1 *= v2;
+  return true;
+};
+
+/**
+ * @private
+ * @brief Divides v1 and v2, stores the result in v1 and returns true if and only if v1 was modified.
+ */
+template <typename T>
+constexpr bool _divide(T &v1, T v2)
+{
+  bool v1_is_infinite = v1 == MF_T_inf<T> || v1 == MF_T_m_inf<T>;
+  bool v2_is_infinite = v2 == MF_T_inf<T> || v2 == MF_T_m_inf<T>;
+
+  if (_is_nan(v1) || _is_nan(v2) || v2 == 0 || (v1_is_infinite && v2_is_infinite)) {
+    v1 = std::numeric_limits<T>::quiet_NaN();
+    return false;
+  }
+
+  if (v1 == 0 || (v1_is_infinite && v2 > 0)) return true;
+
+  if (v1_is_infinite && v2 < 0) {
+    v1 = v1 == MF_T_inf<T> ? MF_T_m_inf<T> : (v1 == MF_T_m_inf<T> ? MF_T_inf<T> : -v1);
+    return true;
+  }
+
+  if (v2_is_infinite) {
+    v1 = 0;
+    return true;
+  }
+
+  v1 /= v2;
+  return true;
+};
+
+template <class T>
+T _get_value(std::istream &stream)
+{
+  if constexpr (std::numeric_limits<T>::has_infinity) {
+    auto pos = stream.tellg();
+    char first;
+    stream >> first;
+    if (first == 'i') {
+      stream >> first;  // n
+      stream >> first;  // f
+      return std::numeric_limits<T>::infinity();
+    }
+    if (first == '-') {
+      stream >> first;  // i
+      if (first == 'i') {
+        stream >> first;  // n
+        stream >> first;  // f
+        return -std::numeric_limits<T>::infinity();
+      }  // else could be a negative number
+    }
+    if (first == 'n') {
+      if constexpr (std::numeric_limits<T>::has_quiet_NaN) {
+        stream >> first;  // a
+        stream >> first;  // n
+        return std::numeric_limits<T>::quiet_NaN();
+      } else {
+        throw std::invalid_argument("Wrong input stream format for value, no nan values allowed.");
+      }
+    }
+    stream.seekg(pos, std::ios_base::beg);
+  }
+
+  T val;
+  stream >> val;
+  if (stream.fail()) throw std::invalid_argument("Wrong input stream format for value.");
+  return val;
+};
+
+}  // namespace multi_filtration
+
+}  // namespace Gudhi
+
+#endif  // MF_UTILS_H_