smash::detail Namespace Reference

Functions
template<typename T >
constexpr auto	type_name ()
	Get type of variable as string in a human-readable way. More...
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
	Compare whether two floating-point numbers are approximately equal à la Knuth up to a given tolerance. More...

Function Documentation

type_name()

template<typename T >

constexpr auto smash::detail::type_name ( )

constexpr

Get type of variable as string in a human-readable way.

Template Parameters

T	The type to be returned.

Returns

A std::string containing the name of the type.

Definition at line 27 of file numeric_cast.h.

                           {
  std::string_view name, prefix, suffix;
#ifdef __clang__
  name = __PRETTY_FUNCTION__;
  prefix = "auto smash::detail::type_name() [T = ";
  suffix = "]";
#elif defined(__GNUC__)
  name = __PRETTY_FUNCTION__;
  prefix = "constexpr auto smash::detail::type_name() [with T = ";
  suffix = "]";
#elif defined(_MSC_VER)
  name = __FUNCSIG__;
  prefix = "auto __cdecl smash::detail::type_name<";
  suffix = ">(void)";
#else
  name = "UNKNOWN";
  prefix = "";
  suffix = "";
#endif
  name.remove_prefix(prefix.size());
  name.remove_suffix(suffix.size());
  return std::string{name};
}

almost_equal_knuthish()

template<typename N , typename = std::enable_if_t<std::is_floating_point_v<N>>>

bool smash::detail::almost_equal_knuthish ( const N  x, const N  y, const N  epsilon, const N  threshold = N{0.0}  )

noexcept

Compare whether two floating-point numbers are approximately equal à la Knuth up to a given tolerance.

On top of Knuth's tolerance predicate some corner cases are treated and the caller can specify a threshold as last parameter to make the test consider numbers equal if the absolute value of their difference is below of it.

Parameters

[in]	x	First of the two numbers.
[in]	y	Second of the two numbers.
[in]	epsilon	The relative tolerance for the test.
[in]	threshold	Threshold for the number comparison. By default this is zero, implying no threshold is considered.

Returns

false if either x or y is not a finite number, provided that the type supports non-numeric representations (i.e. is infinite or NAN);

true if x == y;

true if x == 0 and if \( |x| \le \varepsilon\);

true if y == 0 and if \( |y| \le \varepsilon\);

true if \( |x - y| \le M_\mathrm{threshold} \);

true if \( |x - y| \le \varepsilon \cdot \max(|x|, |y|) \) (Knuth's tolerance predicate);

false otherwise.

Definition at line 59 of file numerics.h.

                                                {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));
}