Eve_core_fma_internal

Detailed Description

Variables
constexpr auto	eve::epsilon = functor<epsilon_t>
	elementwise_callable object computing the distance of the absolute value of the parameter to the next representable element of its type.

Variable Documentation

epsilon

auto eve::epsilon = functor<epsilon_t>

inlineconstexpr

elementwise_callable object computing the distance of the absolute value of the parameter to the next representable element of its type.

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 conditionally.
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";
}