Test and fix min/max implementation on uint32_t for AVX2

Author: serge-sans-paille

include/xsimd/types/xsimd_avx_int32.hpp

@@ -441,18 +441,18 @@ namespace xsimd
             static batch_type min(const batch_type& lhs, const batch_type& rhs)
             {
 #if XSIMD_X86_INSTR_SET >= XSIMD_X86_AVX2_VERSION
-                return _mm256_min_epi32(lhs, rhs);
+                return _mm256_min_epu32(lhs, rhs);
 #else
-                XSIMD_APPLY_SSE_FUNCTION(_mm_min_epi32, lhs, rhs);
+                XSIMD_APPLY_SSE_FUNCTION(_mm_min_epu32, lhs, rhs);
 #endif
             }
 
             static batch_type max(const batch_type& lhs, const batch_type& rhs)
             {
 #if XSIMD_X86_INSTR_SET >= XSIMD_X86_AVX2_VERSION
-                return _mm256_max_epi32(lhs, rhs);
+                return _mm256_max_epu32(lhs, rhs);
 #else
-                XSIMD_APPLY_SSE_FUNCTION(_mm_max_epi32, lhs, rhs);
+                XSIMD_APPLY_SSE_FUNCTION(_mm_max_epu32, lhs, rhs);
 #endif
             }
 

test/test_batch.cpp

@@ -356,6 +356,14 @@ class batch_test : public testing::Test
             batch_type res = min(batch_lhs(), batch_rhs());
             EXPECT_BATCH_EQ(res, expected) << print_function_name("min");
         }
+        // min limit case
+        {
+            array_type expected;
+            std::transform(lhs.cbegin(), lhs.cend(), rhs.cbegin(), expected.begin(),
+                           [](const value_type& , const value_type& r) { return std::min(std::numeric_limits<value_type>::min(), r); });
+            batch_type res = xsimd::min(batch_type(std::numeric_limits<value_type>::min()), batch_rhs());
+            EXPECT_BATCH_EQ(res, expected) << print_function_name("min limit");
+        }
         // fmin
         {
             array_type expected;
@@ -372,6 +380,14 @@ class batch_test : public testing::Test
             batch_type res = max(batch_lhs(), batch_rhs());
             EXPECT_BATCH_EQ(res, expected) << print_function_name("max");
         }
+        // max limit case
+        {
+            array_type expected;
+            std::transform(lhs.cbegin(), lhs.cend(), rhs.cbegin(), expected.begin(),
+                           [](const value_type& , const value_type& r) { return std::max(std::numeric_limits<value_type>::max(), r); });
+            batch_type res = xsimd::max(batch_type(std::numeric_limits<value_type>::max()), batch_rhs());
+            EXPECT_BATCH_EQ(res, expected) << print_function_name("max limit");
+        }
         // fmax
         {
             array_type expected;