rec

eve::rec = functor<rec_t>

inlineconstexpr

Header file

#include <eve/module/core.hpp>

Callable Signatures

namespace eve
{
   // Regular overload
   constexpr auto rec(value auto x)                          noexcept; // 1
 
   // Lanes masking
   constexpr auto rec[conditional_expr auto c](value auto x) noexcept; // 2
   constexpr auto rec[logical_value auto m](value auto x)    noexcept; // 2
 
   // Semantic options
   constexpr auto rec[raw](value auto x)                     noexcept; // 3
   constexpr auto rec[pedantic](value auto x)                noexcept; // 4
   constexpr auto rec[lower](floating_value auto x)          noexcept; // 5
   constexpr auto rec[upper](floating_value auto x)          noexcept; // 6
}

Parameters

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

Return value

1. The value of the inverse of x is returned but does not take care of denormals.
2. The operation is performed conditionnaly.
3. call a proper system intrinsic if one exists, but with possibly very poor accuracy in return (circa 12 bits). Otherwise it uses the regular call.
4. equivalent to the division operation of one(as(x)) by x.
5. The inverse is computed in a 'round toward $-\infty$ mode. The result is guaranted to be less or equal to the exact one (except for Nans).
6. The inverse is computed in a 'round toward $\infty$ mode. The result is guaranted to be greater or equal to the exact one (except for Nans).

Note

For integral value rec(x) is equivalent to:

• If x==1 or x==-1, x is returned.
• If x==0, the greatest representable positive value is returned.
• Otherwise 0 is returned.

Example

// revision 0
#include <eve/module/core.hpp>
#include <iostream>
#include <iomanip>
 
int main()
{
  eve::wide wf0{0.0, 1.0, 2.0, 3.0, -1.0, -2.0, -3.0, -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 << "-> rec(wf0)                 = " << eve::rec(wf0) << "\n";
  std::cout << "-> rec[ignore_last(2)](wf0) = " << eve::rec[eve::ignore_last(2)](wf0) << "\n";
  std::cout << "-> rec[wf0 != 0](wf0)       = " << eve::rec[wf0 != 0](wf0) << "\n";
  std::cout << "-> rec[raw](wf0)            = " << eve::rec[eve::raw](wf0) << "\n";
  std::cout << "-> rec[pedantic](wf0)       = " << eve::rec[eve::pedantic](wf0) << "\n";
  std::cout << "-> rec(wu0)                 = " << eve::rec(wu0) << "\n";
  std::cout << "-> rec[ignore_last(2)](wu0) = " << eve::rec[eve::ignore_last(2)](wu0) << "\n";
  std::cout << "-> rec[wu0 != 0](wu0)       = " << eve::rec[wu0 != 0](wu0) << "\n";
  std::cout << "-> rec[raw](wu0)            = " << eve::rec[eve::raw](wu0) << "\n";
  std::cout << "-> rec[pedantic](wu0)       = " << eve::rec[eve::pedantic](wu0) << "\n";
  std::cout << "-> rec(wi0)                 = " << eve::rec(wi0) << "\n";
  std::cout << "-> rec[ignore_last(2)](wi0) = " << eve::rec[eve::ignore_last(2)](wi0) << "\n";
  std::cout << "-> rec[wi0 != 0](wi0)       = " << eve::rec[wi0 != 0](wi0) << "\n";
  std::cout << "-> rec[raw](wi0)            = " << eve::rec[eve::raw](wi0) << "\n";
  std::cout << "-> rec[pedantic](wi0)       = " << eve::rec[eve::pedantic](wi0) << "\n";
  std::cout << std::setprecision(20) << "-> rec[lower](wf1)         = " << eve::rec[eve::lower](wf0) << "\n";
  std::cout << std::setprecision(20) << "-> rec[upper](wf1)         = " << eve::rec[eve::upper](wf0) << "\n";
  std::cout << std::setprecision(20) << "-> rec[lower][strict](wf0)   = " << eve::rec[eve::lower][eve::strict](wf0) << "\n";
  std::cout << std::setprecision(20) << "-> rec[upper][strict](wf0)   = " << eve::rec[eve::upper][eve::strict](wf0) << "\n";
}