epsilon

eve::epsilon = functor<epsilon_t>

inlineconstexpr

Header file

#include <eve/module/core.hpp>

Callable Signatures

namespace eve
{
   // Regular overload
   constexpr auto epsilon(value auto x)                          noexcept; // 1
 
   // Lanes masking
   constexpr auto epsilon[conditional_expr auto c](value auto x) noexcept; // 2
   constexpr auto epsilon[logical_value auto m](value auto x)    noexcept; // 2
 
   // Semantic options
   constexpr auto epsilon[downward](value auto x)                    noexcept; // 3
   constexpr auto epsilon[upward](value auto x)                      noexcept; // 1
   constexpr auto epsilon[kahan](value auto x)                       noexcept; // 1
   constexpr auto epsilon[harrisson](value auto x)                   noexcept; // 4
}

Parameters

• x: value.
• c: Conditional expression masking the operation.
• m: Logical value masking the operation.

Return value

1. The distance of abs(x) to the next representable element in the type of x. (Kahan definition)
2. The operation is performed conditionnaly.
3. The distance of abs(x) to the previous representable element in the type of x. (Goldberg definition)
4. The distance of abs(x) to the nearest representable element in the type of x, not equal to x. (Harrisson definition).

Note

somewhat faster algorithms are at hand using sulp, if you are insterested by by the signed ulp value.

External references

• wikipedia
• HAL: On the definition of ulp(x)

Example

// revision 0
#include <eve/module/core.hpp>
#include <iostream>
 
int main()
{
  eve::wide wf0{0.0, 1.0, 2.0, 3.0, -1.0, -2.0, -3.0, 10*eve::mindenormal(eve::as(-4.0))};
  eve::wide wi0{0, 1, 2, 3, -1, -2, -3, -4};
  eve::wide wu0{0u, 1u, 2u, 3u, 4u, 5u, 6u, 7u};
 
  std::cout << "<- wf0                          = " << wf0 << "\n";
  std::cout << "<- wi0                          = " << wi0 << "\n";
  std::cout << "<- wu0                          = " << wu0 << "\n";
 
  std::cout << "-> epsilon(wf0)                 = " << eve::epsilon(wf0) << "\n";
  std::cout << "-> epsilon[kahan](wf0)          = " << eve::epsilon[eve::kahan](wf0) << "\n";
  std::cout << "-> epsilon[harrisson](wf0)      = " << eve::epsilon[eve::harrisson](wf0) << "\n";
  std::cout << "-> epsilon[ignore_last(2)](wf0) = " << eve::epsilon[eve::ignore_last(2)](wf0) << "\n";
  std::cout << "-> epsilon[wf0 != 0](wf0)       = " << eve::epsilon[wf0 != 0](wf0) << "\n";
  std::cout << "-> epsilon(wu0)                 = " << eve::epsilon(wu0) << "\n";
  std::cout << "-> epsilon[ignore_last(2)](wu0) = " << eve::epsilon[eve::ignore_last(2)](wu0) << "\n";
  std::cout << "-> epsilon[wu0 != 0](wu0)       = " << eve::epsilon[wu0 != 0](wu0) << "\n";
  std::cout << "-> epsilon(wi0)                 = " << eve::epsilon(wi0) << "\n";
  std::cout << "-> epsilon[ignore_last(2)](wi0) = " << eve::epsilon[eve::ignore_last(2)](wi0) << "\n";
  std::cout << "-> epsilon[wi0 != 0](wi0)       = " << eve::epsilon[wi0 != 0](wi0) << "\n";
}