rem

auto eve::rem = functor<rem_t>

inlineconstexpr

Header file

#include <eve/module/core.hpp>

Callable Signatures

namespace eve
{
   // Regular overload
   constexpr auto rem(value auto x, value auto y)                          noexcept; // 1
 
   // Lanes masking
   constexpr auto rem[conditional_expr auto c](value auto x, value auto y) noexcept; // 2
   constexpr auto rem[logical_value auto m](value auto x, value auto y)    noexcept; // 2
 
   // Semantic option
   constexpr auto rem[downward](/*any of the above overloads*/)            noexcept; // 3
   constexpr auto rem[upward](/*any of the above overloads*/)              noexcept; // 3
   constexpr auto rem[to_nearest](/*any of the above overloads*/)          noexcept; // 3
   constexpr auto rem[toward_zero](/*any of the above overloads*/)         noexcept; // 3
}

Parameters

• x, y: values argumentx.
• c: Conditional expression masking the operation.
• m: Logical value masking the operation.

Return value

1. Return the remainder after division of x by y and is equivalent to x-div[toward_zero](x, y)*y.
2. The operation is performed conditionally.
3. The call is equivalent to x-div[o](x, y)*y where o is the chosen option. For unsigned integral the options upward and nearest are undefined behaviour as the result could be negative.

Note

Although the infix notation with % is supported, the % operator on standard integral scalar type is the original one and so can lead to automatic promotion. Moreover due to C++ limitations, % is not available for scalar floating point values.

Example

// revision 1
#include <eve/module/core.hpp>
#include <iostream>
 
int main()
{
  using w_t = eve::wide<std::int16_t, eve::fixed<4>>;
  w_t pi = {3, 2, 3, 32700}, qi = {4, 2, 1, 101},  ri = {4, 2, 0, 101};
 
  std::cout << " <- pi                        = " << pi << '\n'
            << " <- qi                        = " << qi << '\n'
            << " <- ri                        = " << ri << '\n'
            << " -> rem(pi, qi)               = " << eve::rem(pi, qi) << '\n'
            << " -> rem[toward_zero](pi, qi)  = " << eve::rem[eve::toward_zero](pi, qi) << '\n'
            << " -> rem[downward](pi, qi)     = " << eve::rem[eve::downward](pi, qi) << '\n'
            << " -> rem[upward](pi, qi)       = " << eve::rem[eve::upward](pi, qi) << '\n'
            << " -> rem[toward_zero](pi, qi)  = " << eve::rem[eve::to_nearest](pi, qi) << '\n'
            << " -> pi % qi                   = " << pi % qi << '\n';
 
}