rec

auto 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
   constexpr auto rec[mod = p](floating_value auto x)        noexcept; // 7
   constexpr auto rec[widen](floating_value auto x)          noexcept; // 8
}

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; denormals may not be handled.
2. The operation is performed conditionally.
3. Calls a system intrinsic if one exists; this may return reduced accuracy (roughly 12 bits). Otherwise, the regular implementation is used.
4. Equivalent to dividing one(as(x)) by x.
5. The inverse is computed in a 'round toward \(-\infty\) mode. The result is guaranteed to be less than or equal to the exact value (except for NaNs).
6. The inverse is computed in a 'round toward \(\infty\) mode. The result is guaranteed to be greater than or equal to the exact value (except for NaNs).
7. Computes the result in modular arithmetic. the parameters must be flint positive and less than the modulus. The modulus itself must be less than maxflint. Note that mul[mod = p](a, rec[mod = p](a)) is the gcd of p and a (1 iff a and p are coprime)
8. The inverse is computed in the double sized element type (if available). This decorator has no effect on double and 64 bits integrals.//!

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