last_true

auto eve::last_true = functor<last_true_t>

inlineconstexpr

#include <eve/module/core.hpp>

Callable Signatures

template <relaxed_logical_value L>
std::optional<std::ptrdiff_t> last_true(L m) noexcept;                                               // 1
 
template <logical_simd_value L>
std::optional<std::ptrdiff_t> last_true(top_bits<L> m) noexcept;                                     // 1
 
// lane masking
std::optional<std::ptrdiff_t> last_true[conditional_expr auto c](/* any of the above */) noexcept;   // 2
std::optional<std::ptrdiff_t> last_true[logical_value auto c](/* any of the above */) noexcept;      // 2

Parameters

• m - logical_value or top_bits where to find last true value

Return value

1. An std::optional containing the index of the last element which evaluates to true, std::nullopt if there are none.
2. Same as 1. but masked elements are ignored during the search.

Should you check for any?

The function is considering the case when nothing is set to be likely, checking for eve::any before hand is not going to be helpful. At the moment there isn't a function that would do otherwise.

What if I know there is a match?

We would recommend eve::last_true(m) - this is likely to trigger compiler optimizations, based on it being UB otherwise.

Example

// revision 0
#include <eve/module/core.hpp>
#include <iostream>
#include <optional>
 
void show(char const* what, std::optional<std::ptrdiff_t> r)
{
  std::cout << what;
  if( r ) std::cout << *r << "\n"; else std::cout << "nullopt\n";
}
 
int main()
{
  eve::wide<std::int32_t, eve::fixed<8>> w = {1, 0, 3, 0, 5, 0, 0, 8};
  auto m = w > 0;
 
  std::cout << "<- w                              = " << w << "\n";
  std::cout << "<- m = (w > 0)                    = " << m << "\n";
 
  show("-> last_true(m)                   = ", eve::last_true(m));
  show("-> last_true[eve::ignore_last(2)](m) = ", eve::last_true[eve::ignore_last(2)](m));
  show("-> last_true(w > 100)              = ", eve::last_true(w > 100));
}