filtration_value_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):       Hannah Schreiber
 *
 *    Copyright (C) 2025 Inria
 *
 *    Modification(s):
 *      - YYYY/MM Author: Description of the modification
 */
 
#ifndef SIMPLEX_TREE_FILTRATION_VALUE_UTILS_H_
#define SIMPLEX_TREE_FILTRATION_VALUE_UTILS_H_
 
#include <cstddef>  // std::size_t
#include <limits>   // std::numeric_limits
#include <cmath>    // std::isnan
 
#include <gudhi/Simplex_tree/serialization_utils.h>
 
namespace Gudhi {
 
namespace simplex_tree {

inline struct empty_filtration_value_t {
  template <class T> explicit operator T() const { return T(0); }
} empty_filtration_value;
 
}  // namespace simplex_tree

template <typename Arithmetic_filtration_value>
bool is_positive_infinity(const Arithmetic_filtration_value& f)
{
  if constexpr (std::numeric_limits<Arithmetic_filtration_value>::has_infinity) {
    return f == std::numeric_limits<Arithmetic_filtration_value>::infinity();
  } else {
    return f == std::numeric_limits<Arithmetic_filtration_value>::max();
  }
}

template <typename Arithmetic_filtration_value>
bool unify_lifetimes(Arithmetic_filtration_value& f1, const Arithmetic_filtration_value& f2)
{
  if (f2 < f1){
    f1 = f2;
    return true;
  }
  return false;
}

template <typename Arithmetic_filtration_value>
bool intersect_lifetimes(Arithmetic_filtration_value& f1, const Arithmetic_filtration_value& f2)
{
  if constexpr (std::numeric_limits<Arithmetic_filtration_value>::has_quiet_NaN) {
    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;
  }
}

template <typename Trivial_filtration_value>
char* serialize_value_to_char_buffer(Trivial_filtration_value value, char* start) {
  return Gudhi::simplex_tree::serialize_trivial(value, start);
}

template <typename Trivial_filtration_value>
const char* deserialize_value_from_char_buffer(Trivial_filtration_value& value, const char* start) {
  return Gudhi::simplex_tree::deserialize_trivial(value, start);
}

template<typename Trivial_filtration_value>
constexpr std::size_t get_serialization_size_of([[maybe_unused]] Trivial_filtration_value value) {
  return sizeof(Trivial_filtration_value);
}
 
}  // namespace Gudhi
 
#endif  // SIMPLEX_TREE_FILTRATION_VALUE_UTILS_H_