shr

eve::shr = functor<shr_t>

inlineconstexpr

Header file

#include <eve/module/core.hpp>

Callable Signatures

namespace eve
{
   // Regular overloads
   constexpr auto shr(integral_value auto x, integral_value auto n)              noexcept; // 1
   template< auto N >
   constexpr auto shr(integral_value auto x, index_t<N> auto n)                  noexcept; // 2
 
   // Lanes masking
   constexpr auto shr[conditional_expr auto c](/* any of the above overloads */) noexcept; // 3
   constexpr auto shr[logical_value auto m](/* any of the above overloads */)    noexcept; // 3
}

Parameters

• x: argument to be shifted.
• n: shift.
• c: Conditional expression masking the operation.
• m: Logical value masking the operation.

Return value

1. The elementwise arithmetic right shift of the first parameter by the second one is returned. If Nis the size in bits of the element type of x, all elements of n must belong to the interval: ]0, N[ or the result is undefined.
2. This call allows optimization for architectures that have an intrinsic requiring an immediate parameter
3. The operation is performed conditionnaly

Note

Although the infix notation with << is supported, the << operator on standard scalar types is the original one and so can not be overloaded on standard floating parameters due to C++ limitations.

Warning

The behavior of this function is undefined if the shift value is out of the range [0, N[, where N is the number of bits of the input type. Use eve::rshr for a relative right shift that accepts negative shift values.

Example

// revision 0
#include <eve/module/core.hpp>
#include <iostream>
 
int main()
{
  eve::wide wi0{0, 1, 2, 3, -1, -2, -3, -4};
  eve::wide wi1{0, 4, 1, 1, 2, 2, 3, 3};
  eve::wide wi2{0, -4, 1, -1, 2, -2, 3, -3};
 
  std::cout << "<- wi0                           = " << wi0 << "\n";
  std::cout << "<- wi1                           = " << wi1 << "\n";
                                                 
  std::cout << "-> shr(wi0, wi1)                 = " << eve::shr(wi0, wi1) << "\n";
  std::cout << "-> shr(wi0, index_t<0>())        = " << eve::shr(wi0, eve::index_t<0>()) << "\n";
  std::cout << "-> shr[ignore_last(2)](wi0, wi1) = " << eve::shr[eve::ignore_last(2)](wi0, wi1) << "\n";
  std::cout << "-> shr[wi2 > 0](wi0, wi2)        = " << eve::shr[wi2 > 0](wi0, wi2) << "\n";
}