numerics.h

Go to the documentation of this file.

/*
 *
 *    Copyright (c) 2014-2018,2020,2022-2023,2025
 *      SMASH Team
 *
 *    GNU General Public License (GPLv3 or later)
 *
 */
 
#ifndef SRC_INCLUDE_SMASH_NUMERICS_H_
#define SRC_INCLUDE_SMASH_NUMERICS_H_
 
#include <algorithm>
#include <cassert>
#include <cmath>
#include <initializer_list>
#include <limits>
#include <type_traits>
 
#include "constants.h"
 
namespace smash {
 
namespace detail {
 
template <typename N, typename = std::enable_if_t<std::is_floating_point_v<N>>>
bool almost_equal_knuthish(const N x, const N y, const N epsilon,
                           const N threshold = N{0.0}) noexcept {
  assert(epsilon > 0);
  assert(threshold >= 0);
  if constexpr (std::numeric_limits<N>::is_iec559) {
    if (!std::isfinite(x) || !std::isfinite(y)) {
      return false;
    }
  }
  if (x == y)
    return true;
  else if (x == 0)
    return std::abs(y) <= epsilon;
  else if (y == 0)
    return std::abs(x) <= epsilon;
  else
    return std::abs(x - y) <= threshold ||
           std::abs(x - y) <= epsilon * std::max(std::abs(x), std::abs(y));
}
 
}  // namespace detail
 
template <typename N, typename = std::enable_if_t<std::is_floating_point_v<N>>>
bool almost_equal(const N x, const N y) {
  return detail::almost_equal_knuthish<N>(x, y, static_cast<N>(really_small));
}
 
template <typename N, typename = std::enable_if_t<std::is_floating_point_v<N>>>
bool almost_equal_physics(const N x, const N y) {
  const auto threshold = static_cast<N>(really_small);
  const auto epsilon = static_cast<N>(small_number);
  return detail::almost_equal_knuthish<N>(x, y, epsilon, threshold);
}
 
template <typename T = std::initializer_list<double>>
bool is_any_nan(const T& collection) {
  for (const auto& number : collection) {
    if (unlikely(std::isnan(number)))
      return true;
  }
  return false;
}
 
}  // namespace smash
 
#endif  // SRC_INCLUDE_SMASH_NUMERICS_H_