next

eve::next = {}

inlineconstexpr

Computes the nth next representable element.

Defined in Header

#include <eve/module/core.hpp>

Callable Signatures

namespace eve
{
   template< eve::value T, eve::integral_value N >
   eve::common_compatible_t<T, U> next(T x, N n = 1) noexcept;
}

Parameters

• x: floating argument.
• n : integral value argument.

Return value

The value of the nth representable value greater than x is returned. If n is zero returns x.

Example

#include <eve/module/core.hpp>
#include <eve/wide.hpp>
#include <iostream>
#include <iomanip>
 
using wide_ft = eve::wide<float, eve::fixed<4>>;
using wide_it = eve::wide<std::int16_t, eve::fixed<4>>;
 
int main()
{
  wide_ft pf = {-0.0f, 2.0f, eve::eps(eve::as<float>()), 0.0f};
  wide_it pi = {-1, 2, -3, -32};
 
  std::cout << "---- simd" << '\n'
            << "<- pf                  = " << std::setprecision(12) << pf << '\n'
            << "-> next(pf)            = " << eve::next(pf) << '\n'
            << "-> pedantic(next)(pf)  = " << eve::pedantic(eve::next)(pf) << '\n'
            << "<- pi                  = " << pi << '\n'
            << "-> next(pi)            = " << eve::next(pi) << '\n';
 
  float        xf = 0.0f;
  std::int16_t xi = -3;
 
  std::cout << "---- scalar" << '\n'
            << "<- xf                  = " << xf << '\n'
            << "-> next(xf, 3)         = " << eve::next(xf, 3) << '\n'
            << "<- xi                  = " << xi << '\n'
            << "-> next(xi)            = " << eve::next(xi) << '\n';
  return 0;
}

Semantic Modifiers

• Masked Call

  The call eve::next[mask](x, ...) provides a masked version of next which is equivalent to if_else(mask, next(x, ...), x)

  Example

  #include <eve/module/core.hpp>
  #include <eve/wide.hpp>
  #include <iostream>
  #include <iomanip>
   
  using wide_ft = eve::wide<float, eve::fixed<4>>;
   
  int main()
  {
    wide_ft pf = {-10.0f, 2.0f, eve::eps(eve::as<float>()), 0.0f};
   
    std::cout << "---- simd" << '\n'
              << "<- pf                  = " << std::setprecision(12) << pf << '\n'
              << "-> next[pf > 0](pf)    = " << eve::next[pf > 0](pf) << '\n';
    return 0;
  }

• eve::pedantic

  The call eve::pedantic(eve::next)(x, ...) provides a pedantic version of next which ensures that the successor of eve::mzero is eve::zero for floating points entries

  Example

  #include <eve/module/core.hpp>
  #include <eve/wide.hpp>
  #include <iostream>
  #include <iomanip>
   
  using wide_ft = eve::wide<float, eve::fixed<4>>;
   
  int main()
  {
    wide_ft pf = {-10.0f, 2.0f, eve::eps(eve::as<float>()), 0.0f};
   
    std::cout << "---- simd" << '\n'
              << "<- pf                  = " << std::setprecision(12) << pf << '\n'
              << "-> next[pf > 0](pf)    = " << eve::next[pf > 0](pf) << '\n';
    return 0;
  }

• eve::saturated

  The call eve::pedantic(eve::next)(x, ...) provides a pedantic version of next which ensures that eve::minf and eve::nan are fixed points.

  Example

  #include <eve/module/core.hpp>
  #include <eve/wide.hpp>
  #include <iostream>
  #include <iomanip>
   
  using wide_ft = eve::wide<float, eve::fixed<4>>;
   
  int main()
  {
    wide_ft pf = {-10.0f, 2.0f, eve::eps(eve::as<float>()), 0.0f};
   
    std::cout << "---- simd" << '\n'
              << "<- pf                  = " << std::setprecision(12) << pf << '\n'
              << "-> next[pf > 0](pf)    = " << eve::next[pf > 0](pf) << '\n';
    return 0;
  }