prevint

auto eve::prevint = functor<prevint_t>

inlineconstexpr

This function is equivalent to dec for integral types. For floating point types, it will skip over the non-representable values between the input and the previous representable integer.

Defined in Header

#include <eve/module/core.hpp>

Callable Signatures

namespace eve
{
   // Regular overloads
   constexpr auto prevint(value auto x)                                              noexcept; // 1
 
   // Lanes masking
   constexpr auto prevint[conditional_expr auto c](/* any of the above overloads */) noexcept; // 2
   constexpr auto prevint[logical_value auto m](/* any of the above overloads */)    noexcept; // 2
 
   // Exclusive Semantic options - Only one of those can be set at once
   constexpr auto prevint[raw](value auto x)                                         noexcept; // 3
   constexpr auto prevint[saturated](value auto x)                                   noexcept; // 4
}

Parameters

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

Return value

1. The greatest representable integer value less than x is returned.
2. The operation is performed conditionnaly
3. same as 1. but inf returns nan.
4. ensures that the input is never less than the result of the call. (It can be equal for minimal representable value)

Example

#include <eve/eve.hpp>
#include <iostream>
 
int main()
{
  eve::wide<eve::float16_t, eve::fixed<8>> w{
    static_cast<eve::float16_t>(-0.0f),
    static_cast<eve::float16_t>(0.0f),
    static_cast<eve::float16_t>(32768.0f),
    static_cast<eve::float16_t>(-32768.0f),
    eve::nan(eve::as<eve::float16_t>{}),
    eve::inf(eve::as<eve::float16_t>{}),
    eve::minf(eve::as<eve::float16_t>{}),
    eve::valmin(eve::as<eve::float16_t>{}),
  };
 
  std::cout << "<- w                     = " << w << "\n";
  std::cout << "-> prevint(w)            = " << eve::prevint(w) << "\n";
  std::cout << "-> prevint[saturated](w) = " << eve::prevint[eve::saturated](w) << "\n";
  std::cout << "-> prevint[raw](w)       = " << eve::prevint[eve::raw](w) << "\n";
 
  eve::wide<std::int16_t, eve::fixed<4>> iw{0, 1, 32767, -32768};
  std::cout << "<- iw                     = " << iw << "\n";
  std::cout << "-> prevint(iw)            = " << eve::prevint(iw) << "\n";
  std::cout << "-> prevint[saturated](iw) = " << eve::prevint[eve::saturated](iw) << "\n";
  std::cout << "-> prevint[raw](iw)       = " << eve::prevint[eve::raw](iw) << "\n";
}