Floating minmax: fix negative zero handling and dedicated test coverage for arrays of +0.0 and -0.0 only (#4734)

AlexGuteniev · StephanTLavavej · web-flow · commit 3705e3651a5c · 2024-08-25T10:30:58.000-07:00
Co-authored-by: Stephan T. Lavavej &lt;stl@microsoft.com&gt;
diff --git a/stl/inc/algorithm b/stl/inc/algorithm
@@ -10203,7 +10203,7 @@ _NODISCARD constexpr pair<_Ty, _Ty> minmax(initializer_list<_Ty> _Ilist, _Pr _Pr
     _STL_ASSERT(
         _Ilist.size() != 0, "An initializer_list passed to std::minmax must not be empty. (N4971 [alg.min.max]/21)");
 #if _USE_STD_VECTOR_ALGORITHMS
-    if constexpr (_Is_min_max_optimization_safe<const _Ty*, _Pr>) {
+    if constexpr (_Is_min_max_value_optimization_safe<const _Ty*, _Pr>) {
         if (!_STD _Is_constant_evaluated()) {
             const auto _Result = _STD _Minmax_vectorized(_Ilist.begin(), _Ilist.end());
             return {static_cast<_Ty>(_Result._Min), static_cast<_Ty>(_Result._Max)};
@@ -10332,13 +10332,21 @@ namespace ranges {
 
             using _Vty = iter_value_t<_It>;
 #if _USE_STD_VECTOR_ALGORITHMS
-            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<_It, _Pr>
-                          && sized_sentinel_for<_Se, _It>) {
-                if (!_STD is_constant_evaluated()) {
-                    const auto _First_ptr = _STD to_address(_First);
-                    const auto _Last_ptr  = _First_ptr + (_Last - _First);
-                    const auto _Result    = _STD _Minmax_vectorized(_First_ptr, _Last_ptr);
-                    return {static_cast<_Vty>(_Result._Min), static_cast<_Vty>(_Result._Max)};
+            if constexpr (is_same_v<_Pj, identity> && sized_sentinel_for<_Se, _It>) {
+                if constexpr (_Is_min_max_value_optimization_safe<_It, _Pr>) {
+                    if (!_STD is_constant_evaluated()) {
+                        const auto _First_ptr = _STD to_address(_First);
+                        const auto _Last_ptr  = _First_ptr + (_Last - _First);
+                        const auto _Result    = _STD _Minmax_vectorized(_First_ptr, _Last_ptr);
+                        return {static_cast<_Vty>(_Result._Min), static_cast<_Vty>(_Result._Max)};
+                    }
+                } else if constexpr (_Is_min_max_optimization_safe<_It, _Pr>) {
+                    if (!_STD is_constant_evaluated()) {
+                        const auto _First_ptr = _STD to_address(_First);
+                        const auto _Last_ptr  = _First_ptr + (_Last - _First);
+                        const auto _Result    = _STD _Minmax_element_vectorized(_First_ptr, _Last_ptr);
+                        return {*static_cast<const _Vty*>(_Result.first), *static_cast<const _Vty*>(_Result.second)};
+                    }
                 }
             }
 #endif // _USE_STD_VECTOR_ALGORITHMS
diff --git a/stl/inc/xutility b/stl/inc/xutility
@@ -6801,6 +6801,24 @@ constexpr bool _Is_min_max_optimization_safe = // Activate the vector algorithms
 #endif // _HAS_CXX20
             is_same<_Pr, less<>>, is_same<_Pr, less<_Elem>>>>; // predicate is less
 
+// Unlike the position-based vectorized implementation, the value-based vectorized implementation
+// does not always produce the expected results for floating-point types.
+//
+// Efficient vectorization needs to find the vertical minmax first, and then the horizontal one.
+// This alters the order of comparison: index zero element is first compared against
+// vector size equal index element and only in the end against index one element.
+// With equivalent but distinguishable +0.0 and -0.0 values, the altered comparison order
+// will not produce the expected result in some cases (will return +0.0 instead of -0.0 or the reverse).
+//
+// The result is still acceptable for /fp:fast when +0.0 / -0.0 are not expected to be properly distinguished,
+// and the compiler itself takes advantage of it.
+template <class _Iter, class _Pr, class _Elem = _Iter_value_t<_Iter>>
+constexpr bool _Is_min_max_value_optimization_safe = // Activate the vector algorithms for ranges::min/max?
+#ifndef _M_FP_FAST
+    !is_floating_point_v<_Elem> &&
+#endif // ^^^ !defined(_M_FP_FAST) ^^^
+    _Is_min_max_optimization_safe<_Iter, _Pr, _Elem>;
+
 template <class _FwdIt, class _Pr>
 constexpr _FwdIt _Max_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { // find largest element
 #if _USE_STD_VECTOR_ALGORITHMS
@@ -6931,7 +6949,7 @@ _NODISCARD constexpr _Ty(max)(initializer_list<_Ty> _Ilist, _Pr _Pred) {
     _STL_ASSERT(
         _Ilist.size() != 0, "An initializer_list passed to std::max must not be empty. (N4971 [alg.min.max]/13)");
 #if _USE_STD_VECTOR_ALGORITHMS
-    if constexpr (_Is_min_max_optimization_safe<const _Ty*, _Pr>) {
+    if constexpr (_Is_min_max_value_optimization_safe<const _Ty*, _Pr>) {
         if (!_Is_constant_evaluated()) {
             return static_cast<_Ty>(_STD _Max_vectorized(_Ilist.begin(), _Ilist.end()));
         }
@@ -6977,7 +6995,7 @@ namespace ranges {
             _STL_ASSERT(_First != _Last,
                 "An initializer_list passed to std::ranges::max must not be empty. (N4971 [alg.min.max]/13)");
 #if _USE_STD_VECTOR_ALGORITHMS
-            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<const _Ty*, _Pr>) {
+            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_value_optimization_safe<const _Ty*, _Pr>) {
                 if (!_STD is_constant_evaluated()) {
                     return static_cast<_Ty>(_STD _Max_vectorized(_First, _Last));
                 }
@@ -6996,7 +7014,7 @@ namespace ranges {
             _STL_ASSERT(
                 _UFirst != _ULast, "A range passed to std::ranges::max must not be empty. (N4971 [alg.min.max]/13)");
 #if _USE_STD_VECTOR_ALGORITHMS
-            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<decltype(_UFirst), _Pr>
+            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_value_optimization_safe<decltype(_UFirst), _Pr>
                           && sized_sentinel_for<decltype(_ULast), decltype(_UFirst)>) {
                 if (!_STD is_constant_evaluated()) {
                     const auto _First_ptr = _STD to_address(_UFirst);
@@ -7155,7 +7173,7 @@ _NODISCARD constexpr _Ty(min)(initializer_list<_Ty> _Ilist, _Pr _Pred) {
     _STL_ASSERT(
         _Ilist.size() != 0, "An initializer_list passed to std::min must not be empty. (N4971 [alg.min.max]/5)");
 #if _USE_STD_VECTOR_ALGORITHMS
-    if constexpr (_Is_min_max_optimization_safe<const _Ty*, _Pr>) {
+    if constexpr (_Is_min_max_value_optimization_safe<const _Ty*, _Pr>) {
         if (!_Is_constant_evaluated()) {
             return static_cast<_Ty>(_STD _Min_vectorized(_Ilist.begin(), _Ilist.end()));
         }
@@ -7195,7 +7213,7 @@ namespace ranges {
             _STL_ASSERT(_First != _Last,
                 "An initializer_list passed to std::ranges::min must not be empty. (N4971 [alg.min.max]/5)");
 #if _USE_STD_VECTOR_ALGORITHMS
-            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<const _Ty*, _Pr>) {
+            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_value_optimization_safe<const _Ty*, _Pr>) {
                 if (!_STD is_constant_evaluated()) {
                     return static_cast<_Ty>(_STD _Min_vectorized(_First, _Last));
                 }
@@ -7214,7 +7232,7 @@ namespace ranges {
             _STL_ASSERT(
                 _UFirst != _ULast, "A range passed to std::ranges::min must not be empty. (N4971 [alg.min.max]/5)");
 #if _USE_STD_VECTOR_ALGORITHMS
-            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<decltype(_UFirst), _Pr>
+            if constexpr (is_same_v<_Pj, identity> && _Is_min_max_value_optimization_safe<decltype(_UFirst), _Pr>
                           && sized_sentinel_for<decltype(_ULast), decltype(_UFirst)>) {
                 if (!_STD is_constant_evaluated()) {
                     const auto _First_ptr = _STD to_address(_UFirst);
diff --git a/stl/src/vector_algorithms.cpp b/stl/src/vector_algorithms.cpp
@@ -1415,8 +1415,8 @@ namespace {
         template <class _Fn>
         static __m128 _H_func(const __m128 _Cur, _Fn _Funct) noexcept {
             __m128 _H_min_val = _Cur;
-            _H_min_val        = _Funct(_H_min_val, _mm_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
-            _H_min_val        = _Funct(_H_min_val, _mm_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(2, 3, 0, 1)));
+            _H_min_val        = _Funct(_mm_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(2, 3, 0, 1)), _H_min_val);
+            _H_min_val        = _Funct(_mm_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(1, 0, 3, 2)), _H_min_val);
             return _H_min_val;
         }
 
@@ -1457,11 +1457,11 @@ namespace {
         }
 
         static __m128 _Min(const __m128 _First, const __m128 _Second, __m128 = _mm_undefined_ps()) noexcept {
-            return _mm_min_ps(_First, _Second);
+            return _mm_min_ps(_Second, _First);
         }
 
         static __m128 _Max(const __m128 _First, const __m128 _Second, __m128 = _mm_undefined_ps()) noexcept {
-            return _mm_max_ps(_First, _Second);
+            return _mm_max_ps(_Second, _First);
         }
 
         static __m128i _Mask_cast(const __m128 _Mask) noexcept {
@@ -1485,9 +1485,9 @@ namespace {
         template <class _Fn>
         static __m256 _H_func(const __m256 _Cur, _Fn _Funct) noexcept {
             __m256 _H_min_val = _Cur;
-            _H_min_val        = _Funct(_H_min_val, _mm256_permute2f128_ps(_H_min_val, _mm256_undefined_ps(), 0x01));
-            _H_min_val        = _Funct(_H_min_val, _mm256_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
-            _H_min_val        = _Funct(_H_min_val, _mm256_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(2, 3, 0, 1)));
+            _H_min_val        = _Funct(_mm256_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(2, 3, 0, 1)), _H_min_val);
+            _H_min_val        = _Funct(_mm256_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(1, 0, 3, 2)), _H_min_val);
+            _H_min_val        = _Funct(_mm256_permute2f128_ps(_H_min_val, _mm256_undefined_ps(), 0x01), _H_min_val);
             return _H_min_val;
         }
 
@@ -1528,11 +1528,11 @@ namespace {
         }
 
         static __m256 _Min(const __m256 _First, const __m256 _Second, __m256 = _mm256_undefined_ps()) noexcept {
-            return _mm256_min_ps(_First, _Second);
+            return _mm256_min_ps(_Second, _First);
         }
 
         static __m256 _Max(const __m256 _First, const __m256 _Second, __m256 = _mm256_undefined_ps()) noexcept {
-            return _mm256_max_ps(_First, _Second);
+            return _mm256_max_ps(_Second, _First);
         }
 
         static __m256i _Mask_cast(const __m256 _Mask) noexcept {
@@ -1575,7 +1575,7 @@ namespace {
         template <class _Fn>
         static __m128d _H_func(const __m128d _Cur, _Fn _Funct) noexcept {
             __m128d _H_min_val = _Cur;
-            _H_min_val         = _Funct(_H_min_val, _mm_shuffle_pd(_H_min_val, _H_min_val, 1));
+            _H_min_val         = _Funct(_mm_shuffle_pd(_H_min_val, _H_min_val, 1), _H_min_val);
             return _H_min_val;
         }
 
@@ -1615,11 +1615,11 @@ namespace {
         }
 
         static __m128d _Min(const __m128d _First, const __m128d _Second, __m128d = _mm_undefined_pd()) noexcept {
-            return _mm_min_pd(_First, _Second);
+            return _mm_min_pd(_Second, _First);
         }
 
         static __m128d _Max(const __m128d _First, const __m128d _Second, __m128d = _mm_undefined_pd()) noexcept {
-            return _mm_max_pd(_First, _Second);
+            return _mm_max_pd(_Second, _First);
         }
 
         static __m128i _Mask_cast(const __m128d _Mask) noexcept {
@@ -1643,8 +1643,8 @@ namespace {
         template <class _Fn>
         static __m256d _H_func(const __m256d _Cur, _Fn _Funct) noexcept {
             __m256d _H_min_val = _Cur;
-            _H_min_val         = _Funct(_H_min_val, _mm256_permute4x64_pd(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
-            _H_min_val         = _Funct(_H_min_val, _mm256_shuffle_pd(_H_min_val, _H_min_val, 0b0101));
+            _H_min_val         = _Funct(_mm256_shuffle_pd(_H_min_val, _H_min_val, 0b0101), _H_min_val);
+            _H_min_val         = _Funct(_mm256_permute4x64_pd(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)), _H_min_val);
             return _H_min_val;
         }
 
@@ -1685,11 +1685,11 @@ namespace {
         }
 
         static __m256d _Min(const __m256d _First, const __m256d _Second, __m256d = _mm256_undefined_pd()) noexcept {
-            return _mm256_min_pd(_First, _Second);
+            return _mm256_min_pd(_Second, _First);
         }
 
         static __m256d _Max(const __m256d _First, const __m256d _Second, __m256d = _mm256_undefined_pd()) noexcept {
-            return _mm256_max_pd(_First, _Second);
+            return _mm256_max_pd(_Second, _First);
         }
 
         static __m256i _Mask_cast(const __m256d _Mask) noexcept {
diff --git a/tests/std/include/test_min_max_element_support.hpp b/tests/std/include/test_min_max_element_support.hpp
@@ -5,7 +5,9 @@
 
 #include <algorithm>
 #include <cassert>
+#include <cmath>
 #include <cstddef>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -116,6 +118,17 @@ void test_case_min_max_element(const std::vector<T>& input) {
         assert(*expected_max == actual_max_value);
         assert(*expected_minmax.first == actual_minmax_value.min);
         assert(*expected_minmax.second == actual_minmax_value.max);
+
+#ifndef _M_FP_FAST
+        // With /fp:fast mode the compiler does not try to produce the code that correctly
+        // distinguishes +0.0 and -0.0, so the algorithms are not expected to either.
+        if constexpr (std::is_floating_point_v<T>) {
+            assert(std::signbit(*expected_min) == std::signbit(actual_min_value));
+            assert(std::signbit(*expected_max) == std::signbit(actual_max_value));
+            assert(std::signbit(*expected_minmax.first) == std::signbit(actual_minmax_value.min));
+            assert(std::signbit(*expected_minmax.second) == std::signbit(actual_minmax_value.max));
+        }
+#endif // !defined(_M_FP_FAST)
     }
 #endif // _HAS_CXX20
 }
diff --git a/tests/std/include/test_vector_algorithms_support.hpp b/tests/std/include/test_vector_algorithms_support.hpp
@@ -0,0 +1,64 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#pragma once
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <functional>
+#include <isa_availability.h>
+#include <random>
+#include <vector>
+
+inline void initialize_randomness(std::mt19937_64& gen) {
+    constexpr std::size_t n = std::mt19937_64::state_size;
+    constexpr std::size_t w = std::mt19937_64::word_size;
+    static_assert(w % 32 == 0, "w should be evenly divisible by 32");
+    constexpr std::size_t k = w / 32;
+
+    std::vector<std::uint32_t> vec(n * k);
+
+    std::random_device rd;
+    std::generate(vec.begin(), vec.end(), std::ref(rd));
+
+    std::printf("This is a randomized test.\n");
+    std::printf("DO NOT IGNORE/RERUN ANY FAILURES.\n");
+    std::printf("You must report them to the STL maintainers.\n\n");
+
+    std::printf("Seed vector: ");
+    for (const auto& e : vec) {
+        std::printf("%u,", e);
+    }
+    std::printf("\n");
+
+    std::seed_seq seq(vec.cbegin(), vec.cend());
+    gen.seed(seq);
+}
+
+#if (defined(_M_IX86) || defined(_M_X64)) && !defined(_M_CEE_PURE)
+extern "C" long __isa_enabled;
+
+inline void disable_instructions(ISA_AVAILABILITY isa) {
+    __isa_enabled &= ~(1UL << static_cast<unsigned long>(isa));
+}
+#endif // (defined(_M_IX86) || defined(_M_X64)) && !defined(_M_CEE_PURE)
+
+constexpr std::size_t dataCount = 1024;
+
+template <class TestFunc>
+void run_randomized_tests_with_different_isa_levels(TestFunc tests) {
+    std::mt19937_64 gen;
+    initialize_randomness(gen);
+
+    tests(gen);
+
+#if (defined(_M_IX86) || defined(_M_X64)) && !defined(_M_CEE_PURE)
+    disable_instructions(__ISA_AVAILABLE_AVX2);
+    tests(gen);
+
+    disable_instructions(__ISA_AVAILABLE_SSE42);
+    tests(gen);
+#endif // (defined(_M_IX86) || defined(_M_X64)) && !defined(_M_CEE_PURE)
+}
diff --git a/tests/std/test.lst b/tests/std/test.lst
@@ -709,6 +709,7 @@ tests\VSO_0000000_regex_use
 tests\VSO_0000000_string_view_idl
 tests\VSO_0000000_type_traits
 tests\VSO_0000000_vector_algorithms
+tests\VSO_0000000_vector_algorithms_floats
 tests\VSO_0000000_wcfb01_idempotent_container_destructors
 tests\VSO_0000000_wchar_t_filebuf_xsmeown
 tests\VSO_0095468_clr_exception_ptr_bad_alloc
diff --git a/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp b/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp
diff --git a/tests/std/tests/VSO_0000000_vector_algorithms_floats/env.lst b/tests/std/tests/VSO_0000000_vector_algorithms_floats/env.lst
diff --git a/tests/std/tests/VSO_0000000_vector_algorithms_floats/test.cpp b/tests/std/tests/VSO_0000000_vector_algorithms_floats/test.cpp

Original file line number	Diff line number	Diff line change
`@@ -1415,8 +1415,8 @@ namespace {`
`1415`	`1415`	`template <class _Fn>`
`1416`	`1416`	`static __m128 _H_func(const __m128 _Cur, _Fn _Funct) noexcept {`
`1417`	`1417`	`__m128 _H_min_val = _Cur;`
`1418`		`- _H_min_val = _Funct(_H_min_val, _mm_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));`
`1419`		`- _H_min_val = _Funct(_H_min_val, _mm_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(2, 3, 0, 1)));`
	`1418`	`+ _H_min_val = _Funct(_mm_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(2, 3, 0, 1)), _H_min_val);`
	`1419`	`+ _H_min_val = _Funct(_mm_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(1, 0, 3, 2)), _H_min_val);`
`1420`	`1420`	`return _H_min_val;`
`1421`	`1421`	`}`
`1422`	`1422`
`@@ -1457,11 +1457,11 @@ namespace {`
`1457`	`1457`	`}`
`1458`	`1458`
`1459`	`1459`	`static __m128 _Min(const __m128 _First, const __m128 _Second, __m128 = _mm_undefined_ps()) noexcept {`
`1460`		`- return _mm_min_ps(_First, _Second);`
	`1460`	`+ return _mm_min_ps(_Second, _First);`
`1461`	`1461`	`}`
`1462`	`1462`
`1463`	`1463`	`static __m128 _Max(const __m128 _First, const __m128 _Second, __m128 = _mm_undefined_ps()) noexcept {`
`1464`		`- return _mm_max_ps(_First, _Second);`
	`1464`	`+ return _mm_max_ps(_Second, _First);`
`1465`	`1465`	`}`
`1466`	`1466`
`1467`	`1467`	`static __m128i _Mask_cast(const __m128 _Mask) noexcept {`
`@@ -1485,9 +1485,9 @@ namespace {`
`1485`	`1485`	`template <class _Fn>`
`1486`	`1486`	`static __m256 _H_func(const __m256 _Cur, _Fn _Funct) noexcept {`
`1487`	`1487`	`__m256 _H_min_val = _Cur;`
`1488`		`- _H_min_val = _Funct(_H_min_val, _mm256_permute2f128_ps(_H_min_val, _mm256_undefined_ps(), 0x01));`
`1489`		`- _H_min_val = _Funct(_H_min_val, _mm256_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));`
`1490`		`- _H_min_val = _Funct(_H_min_val, _mm256_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(2, 3, 0, 1)));`
	`1488`	`+ _H_min_val = _Funct(_mm256_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(2, 3, 0, 1)), _H_min_val);`
	`1489`	`+ _H_min_val = _Funct(_mm256_shuffle_ps(_H_min_val, _H_min_val, _MM_SHUFFLE(1, 0, 3, 2)), _H_min_val);`
	`1490`	`+ _H_min_val = _Funct(_mm256_permute2f128_ps(_H_min_val, _mm256_undefined_ps(), 0x01), _H_min_val);`
`1491`	`1491`	`return _H_min_val;`
`1492`	`1492`	`}`
`1493`	`1493`
`@@ -1528,11 +1528,11 @@ namespace {`
`1528`	`1528`	`}`
`1529`	`1529`
`1530`	`1530`	`static __m256 _Min(const __m256 _First, const __m256 _Second, __m256 = _mm256_undefined_ps()) noexcept {`
`1531`		`- return _mm256_min_ps(_First, _Second);`
	`1531`	`+ return _mm256_min_ps(_Second, _First);`
`1532`	`1532`	`}`
`1533`	`1533`
`1534`	`1534`	`static __m256 _Max(const __m256 _First, const __m256 _Second, __m256 = _mm256_undefined_ps()) noexcept {`
`1535`		`- return _mm256_max_ps(_First, _Second);`
	`1535`	`+ return _mm256_max_ps(_Second, _First);`
`1536`	`1536`	`}`
`1537`	`1537`
`1538`	`1538`	`static __m256i _Mask_cast(const __m256 _Mask) noexcept {`
`@@ -1575,7 +1575,7 @@ namespace {`
`1575`	`1575`	`template <class _Fn>`
`1576`	`1576`	`static __m128d _H_func(const __m128d _Cur, _Fn _Funct) noexcept {`
`1577`	`1577`	`__m128d _H_min_val = _Cur;`
`1578`		`- _H_min_val = _Funct(_H_min_val, _mm_shuffle_pd(_H_min_val, _H_min_val, 1));`
	`1578`	`+ _H_min_val = _Funct(_mm_shuffle_pd(_H_min_val, _H_min_val, 1), _H_min_val);`
`1579`	`1579`	`return _H_min_val;`
`1580`	`1580`	`}`
`1581`	`1581`
`@@ -1615,11 +1615,11 @@ namespace {`
`1615`	`1615`	`}`
`1616`	`1616`
`1617`	`1617`	`static __m128d _Min(const __m128d _First, const __m128d _Second, __m128d = _mm_undefined_pd()) noexcept {`
`1618`		`- return _mm_min_pd(_First, _Second);`
	`1618`	`+ return _mm_min_pd(_Second, _First);`
`1619`	`1619`	`}`
`1620`	`1620`
`1621`	`1621`	`static __m128d _Max(const __m128d _First, const __m128d _Second, __m128d = _mm_undefined_pd()) noexcept {`
`1622`		`- return _mm_max_pd(_First, _Second);`
	`1622`	`+ return _mm_max_pd(_Second, _First);`
`1623`	`1623`	`}`
`1624`	`1624`
`1625`	`1625`	`static __m128i _Mask_cast(const __m128d _Mask) noexcept {`
`@@ -1643,8 +1643,8 @@ namespace {`
`1643`	`1643`	`template <class _Fn>`
`1644`	`1644`	`static __m256d _H_func(const __m256d _Cur, _Fn _Funct) noexcept {`
`1645`	`1645`	`__m256d _H_min_val = _Cur;`
`1646`		`- _H_min_val = _Funct(_H_min_val, _mm256_permute4x64_pd(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));`
`1647`		`- _H_min_val = _Funct(_H_min_val, _mm256_shuffle_pd(_H_min_val, _H_min_val, 0b0101));`
	`1646`	`+ _H_min_val = _Funct(_mm256_shuffle_pd(_H_min_val, _H_min_val, 0b0101), _H_min_val);`
	`1647`	`+ _H_min_val = _Funct(_mm256_permute4x64_pd(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)), _H_min_val);`
`1648`	`1648`	`return _H_min_val;`
`1649`	`1649`	`}`
`1650`	`1650`
`@@ -1685,11 +1685,11 @@ namespace {`
`1685`	`1685`	`}`
`1686`	`1686`
`1687`	`1687`	`static __m256d _Min(const __m256d _First, const __m256d _Second, __m256d = _mm256_undefined_pd()) noexcept {`
`1688`		`- return _mm256_min_pd(_First, _Second);`
	`1688`	`+ return _mm256_min_pd(_Second, _First);`
`1689`	`1689`	`}`
`1690`	`1690`
`1691`	`1691`	`static __m256d _Max(const __m256d _First, const __m256d _Second, __m256d = _mm256_undefined_pd()) noexcept {`
`1692`		`- return _mm256_max_pd(_First, _Second);`
	`1692`	`+ return _mm256_max_pd(_Second, _First);`
`1693`	`1693`	`}`
`1694`	`1694`
`1695`	`1695`	`static __m256i _Mask_cast(const __m256d _Mask) noexcept {`