min_value

eve::algo::min_value = function_with_traits<min_value_>[default_simple_algo_traits]

inlineconstexpr

#include <eve/module/algo/algo/min_value.hpp>

C++ standard only has std::min_element that returns iterator to the minimum element. We have that too (see: eve::algo::min_element) but it's slower then just getting the value. So we also provide min_value for when you don't care about the position. By default unrolls by 4 and aligned all memory accesses.

Note

for equivalent elements we return the first amoung equal.

we assume that eve::is_less defined for your type is total order. (this comes up when switching min with max)

Alternative Header

#include <eve/algo.hpp>

Callable Signatures

namespace eve::algo
{
  template <eve::algo::relaxed_range Rng, typename Less>
  std::optional<eve::value_type_t<Rng>> min_value(Rng&& rng, Less less);          // 1
 
  template <eve::algo::relaxed_range Rng>
  std::optional<eve::value_type_t<Rng>> min_value(Rng&& rng);                    // 2
}

1. Returns the minimum value, according to less. If the range is empty - returns nullopt.
2. Same as 1 but the less is eve::is_less

Parameters

• rng: Relaxed input range to process
• less: SIMD strict weak ordering.

Return value

minimum value from the range. If the input range was empty, it's std::nullopt.

Example

#include <eve/module/core.hpp>
#include <eve/module/algo.hpp>
#include <tts/tts.hpp>  // as_string
#include <vector>
 
int main()
{
  std::vector<int> v{ 2, -1, 4, -1, 0 };
 
  std::cout << " -> v                                                                              = "
            << tts::as_string(v)
            << "\n";
 
  std::cout << " -> eve::algo::min_value(v)                                                       = "
            << *eve::algo::min_value(v) << "\n";
 
  std::cout << " -> eve::algo::min_element(v) - v.begin()                                         = "
            << eve::algo::min_element(v) - v.begin() << "\n";
 
  std::cout << " -> eve::algo::min_value(v, eve::is_greater)                                      = "
            << *eve::algo::min_value(v, eve::is_greater) << "\n";
 
  std::cout << " -> eve::algo::min_value(v, eve::is_greater) - v.begin()                          = "
            << eve::algo::min_element(v, eve::is_greater) - v.begin() << "\n";
 
 
  auto absolutes = eve::views::map(v, eve::abs);
  std::cout << " -> eve::algo::min_element[eve::algo::single_pass](absolutes) - absolutes.begin() = "
            << eve::algo::min_element[eve::algo::single_pass](absolutes) - absolutes.begin() << "\n";
 
}

See also

max_value

min_element