[feature] implement min_element cf issue #20

Author: retornaz-thomas

include/xsimd_algorithm/stl/min_element.hpp

@@ -0,0 +1,121 @@
+/***************************************************************************
+ * Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
+ * Martin Renou                                                             *
+ * Copyright (c) QuantStack                                                 *
+ * Copyright (c) Serge Guelton                                              *
+ *                                                                          *
+ * Distributed under the terms of the BSD 3-Clause License.                 *
+ *                                                                          *
+ * The full license is in the file LICENSE, distributed with this software. *
+ ****************************************************************************/
+
+#ifndef XSIMD_ALGORITHMS_MIN_ELEMENT_HPP
+#define XSIMD_ALGORITHMS_MIN_ELEMENT_HPP
+
+#include "xsimd/xsimd.hpp"
+
+#include <iterator>
+
+namespace xsimd
+{
+    namespace detail
+    {
+        template <class Arch = default_arch, class ForwardIterator, class Compare>
+        ForwardIterator sequential_min_element(ForwardIterator first, ForwardIterator last, Compare&& comp) noexcept
+        {
+            if (first == last)
+            {
+                return last;
+            }
+
+            ForwardIterator min_it = first;
+
+            for (++first; first != last; ++first)
+            {
+                if (comp(*min_it, *first))
+                {
+                    min_it = first;
+                }
+            }
+
+            return min_it;
+        }
+    }
+
+    template <class Arch = default_arch, class ContiguousIterator, class Compare>
+    ContiguousIterator min_element(ContiguousIterator first, ContiguousIterator last, Compare&& comp) noexcept
+    {
+        using value_type = typename std::decay<decltype(*first)>::type;
+        using batch_type = batch<value_type, Arch>;
+        
+        const std::size_t size = static_cast<std::size_t>(std::distance(first, last));
+        constexpr std::size_t simd_size = batch_type::size;
+
+        // Quick return for small ranges
+        if (size < simd_size)
+        {
+            return detail::sequential_min_element(first, last, std::forward<Compare>(comp));
+        }
+
+        // prologue: process elements until the first aligned one
+        // compute alignment offsets
+        const auto* const ptr_begin = &(*first);
+        const std::size_t align_begin = xsimd::get_alignment_offset(ptr_begin, size, simd_size);
+        const std::size_t align_end = align_begin + ((size - align_begin) & ~(simd_size - 1));
+
+        const auto align_begin_it = std::next(first, align_begin);
+        const auto align_end_it = std::next(first, align_end);
+
+        auto min_it = detail::sequential_min_element(first, align_begin_it, std::forward<Compare>(comp));
+        auto current_min = *min_it;
+        auto current_min_index = std::distance(first, min_it);
+
+        // Generate a batch of the current min value
+        batch_type current_min_batch = batch_type(current_min);
+
+        // main loop: process aligned elements
+        for (auto current = align_begin_it; current != align_end_it; std::advance(current, simd_size))
+        {
+            batch_type batch_val = batch_type::load_aligned(&(*current));
+
+            // Compare the current batch with the current min batch
+            auto mask = comp(current_min_batch, batch_val);
+
+            // Update ?
+            if (xsimd::any(mask))
+            {
+                // Update the current min batch
+                current_min_batch = xsimd::select(mask, batch_val, current_min_batch);
+                // extract the min value
+                current_min = xsimd::reduce_min(current_min_batch);
+                //retrieve position of the min value in the current batch
+                auto min_pos = std::find(current, current + simd_size, current_min);
+                if (min_pos != current + simd_size)
+                {
+                    current_min_index = std::distance(first, min_pos);
+                }
+            }
+        }
+    
+        min_it = std::next(first, current_min_index);
+
+        for (auto current = align_end_it; current != last; ++current)
+        {
+            if (comp(current_min, *current))
+            {
+                current_min = *current;
+                min_it = current;
+            }
+        }
+        return min_it;
+    }
+
+    template <class Arch = default_arch, class ContiguousIterator>
+    ContiguousIterator min_element(ContiguousIterator first, ContiguousIterator last) noexcept
+    {
+        return xsimd::min_element<Arch>(first, last, [](const auto& lhs, const auto& rhs) { return lhs > rhs; });
+    }
+
+} // namespace xsimd
+
+#endif // XSIMD_ALGORITHMS_MIN_ELEMENT_HPP

test/test_min_element.cpp

@@ -0,0 +1,112 @@
+/***************************************************************************
+ * Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
+ * Martin Renou                                                             *
+ * Copyright (c) QuantStack                                                 *
+ * Copyright (c) Serge Guelton                                              *
+ *                                                                          *
+ * Distributed under the terms of the BSD 3-Clause License.                 *
+ *                                                                          *
+ * The full license is in the file LICENSE, distributed with this software. *
+ ****************************************************************************/
+
+#include "xsimd_algorithm/stl/min_element.hpp"
+
+#ifndef XSIMD_NO_SUPPORTED_ARCHITECTURE
+
+#include "doctest/doctest.h"
+
+#include <cstddef>
+#include <vector>
+
+#if XSIMD_WITH_NEON && !XSIMD_WITH_NEON64
+#define MIN_ELEMENT_TYPES int, float
+#else
+#define MIN_ELEMENT_TYPES int, long, float, double
+#endif
+
+template <typename Type>
+struct min_element_test
+{
+    using vector = std::vector<Type>;
+    static constexpr std::size_t simd_size = xsimd::batch<Type>::size;
+
+    static vector fill_data(size_t size, Type min, size_t position)
+    {
+        vector result(size,Type(0));
+        
+        if (position < size)
+        {
+            result[position] = min;
+        }
+
+        return result;
+    }
+
+    void test_min_element_aligned( size_t size, size_t position) const
+    {
+        const auto minimum = Type(-42);
+        const vector data = fill_data(size, minimum, position);
+
+        const auto result = xsimd::min_element(data.begin(), data.end());
+        const auto expected = std::min_element(data.begin(), data.end());
+        
+        CHECK(result == expected);
+    }
+
+    void test_min_element_misaligned(size_t size, size_t position) const
+    {
+        const auto minimum = Type(-42);
+        const size_t missalignment = 1;
+        const vector data = fill_data(size + missalignment * 2, minimum, position);
+        auto first = data.begin() + missalignment;
+        auto last = first + size;
+
+        const auto result = xsimd::min_element(first, last);
+        const auto expected = std::min_element(first, last);
+
+        CHECK(result == expected);
+    }
+};
+
+TEST_CASE_TEMPLATE("min_element test", T, MIN_ELEMENT_TYPES)
+{
+    using Test = min_element_test<T>;
+
+    const std::array test_sizes {
+        size_t { 0 },
+        size_t { 1 },
+        Test::simd_size - 1,
+        Test::simd_size,
+        Test ::simd_size + 1,
+        Test ::simd_size *4,   
+    };
+
+    const std::array positions {
+        size_t { 0 },
+        size_t { 1 },
+        Test::simd_size / 4,
+        Test::simd_size / 2,
+        Test::simd_size - 1,
+    };
+
+    Test test;
+
+    size_t sub_case_id = 0;
+    for (const auto size : test_sizes)
+    {
+        for (const auto position : positions)
+        {
+            const std::string aligned_subcase_name = "Aligned" + std::to_string(sub_case_id++) + ", size: " + std::to_string(size) + ", position: " + std::to_string(position);
+            SUBCASE(aligned_subcase_name.c_str())
+            {
+                test.test_min_element_aligned(size, position);
+            }
+            const std::string misaligned_subcase_name = "Misaligned" + std::to_string(sub_case_id++) + ", size: " + std::to_string(size) + ", position: " + std::to_string(position);
+            SUBCASE(misaligned_subcase_name.c_str())
+            {
+                test.test_min_element_misaligned(size, position);
+            }
+        }
+    }
+}
+#endif