fix: improve is_cross_lane_128 implementation

Rewrite is_cross_lane_128 in a more procedural style using C++14
constexpr features with a temporary array and for loop, replacing
the recursive template implementation.

The function correctly checks for cross-lane operations on 128-bit lanes.

Author: DiamonDinoia

include/xsimd/arch/common/xsimd_common_swizzle.hpp

@@ -167,6 +167,57 @@ namespace xsimd
                 return cross_impl<0, sizeof...(Vs), sizeof...(Vs) / 2, Vs...>::value;
             }
 
+            // 128-bit lane aware cross_impl: checks per 128-bit lane
+            template <std::size_t I,
+                      std::size_t N,
+                      std::size_t LaneElems,
+                      typename U,
+                      U... Vs>
+            struct cross_impl128
+            {
+                static constexpr std::size_t Vi = static_cast<std::size_t>(get_at<U, I, Vs...>::value);
+                static constexpr bool curr = ((I / LaneElems) != (static_cast<std::size_t>(Vi) / LaneElems));
+                static constexpr bool next = cross_impl128<I + 1, N, LaneElems, U, Vs...>::value;
+                static constexpr bool value = curr || next;
+            };
+            template <std::size_t N, std::size_t LaneElems, typename U, U... Vs>
+            struct cross_impl128<N, N, LaneElems, U, Vs...>
+            {
+                static constexpr bool value = false;
+            };
+
+            template <typename ElemT, typename U, U... Vs>
+            XSIMD_INLINE constexpr bool is_cross_lane_128() noexcept
+            {
+                static_assert(std::is_integral<U>::value, "swizzle mask values must be integral");
+                static_assert(sizeof...(Vs) >= 1, "Need at least one lane");
+                constexpr std::size_t N = sizeof...(Vs);
+                constexpr std::size_t lane_elems = 16 / sizeof(ElemT);
+                constexpr U values[] = { Vs... };
+                for (std::size_t i = 0; i < N; ++i)
+                {
+                    std::size_t elem_lane = i / lane_elems;
+                    std::size_t target_lane = static_cast<std::size_t>(values[i]) / lane_elems;
+                    if (elem_lane != target_lane)
+                        return true;
+                }
+                return false;
+            }
+
+            // overload accepting an element type first to compute 128-bit lane size
+            template <typename ElemT, typename U, U... Vs>
+            XSIMD_INLINE constexpr bool is_cross_lane() noexcept
+            {
+                return is_cross_lane_128<ElemT, U, Vs...>();
+            }
+
+            // convenience overload taking element type then integer non-type parameter pack
+            template <typename ElemT, std::size_t... Vs>
+            XSIMD_INLINE constexpr bool is_cross_lane() noexcept
+            {
+                return is_cross_lane_128<ElemT, std::size_t, Vs...>();
+            }
+
             template <typename T, T... Vs>
             XSIMD_INLINE constexpr bool is_identity() noexcept { return detail::identity_impl<0, T, Vs...>(); }
             template <typename T, T... Vs>
@@ -184,7 +235,11 @@ namespace xsimd
             template <typename T, class A, T... Vs>
             XSIMD_INLINE constexpr bool is_only_from_hi(batch_constant<T, A, Vs...>) noexcept { return detail::is_only_from_hi<T, Vs...>(); }
             template <typename T, class A, T... Vs>
-            XSIMD_INLINE constexpr bool is_cross_lane(batch_constant<T, A, Vs...>) noexcept { return detail::is_cross_lane<Vs...>(); }
+            XSIMD_INLINE constexpr bool is_cross_lane(batch_constant<T, A, Vs...>) noexcept
+            {
+                static_assert(std::is_integral<T>::value, "swizzle mask values must be integral");
+                return is_cross_lane_128<T, T, Vs...>();
+            }
 
         } // namespace detail
     } // namespace kernel

test/test_batch_manip.cpp

@@ -52,11 +52,24 @@ namespace xsimd
             static_assert(is_dup_hi<std::uint32_t, 2, 3, 2, 3>(), "4-lane dup_hi failed");
             static_assert(!is_dup_lo<std::uint32_t, 2, 3, 2, 3>(), "4-lane dup_lo on dup_hi");
 
-            static_assert(is_cross_lane<0, 1, 0, 1>(), "dup-lo only → crossing");
-            static_assert(is_cross_lane<2, 3, 2, 3>(), "dup-hi only → crossing");
-            static_assert(is_cross_lane<0, 3, 3, 3>(), "one low + rest high → crossing");
-            static_assert(!is_cross_lane<1, 0, 2, 3>(), "mixed low/high → no crossing");
-            static_assert(!is_cross_lane<0, 1, 2, 3>(), "mixed low/high → no crossing");
+            static_assert(is_cross_lane<double, 0, 1, 0, 1>(), "dup-lo only → crossing");
+            static_assert(is_cross_lane<double, 2, 3, 2, 3>(), "dup-hi only → crossing");
+            static_assert(is_cross_lane<double, 0, 3, 3, 3>(), "one low + rest high → crossing");
+            static_assert(!is_cross_lane<double, 1, 0, 2, 3>(), "mixed low/high → no crossing");
+            static_assert(!is_cross_lane<double, 0, 1, 2, 3>(), "mixed low/high → no crossing");
+            // 8-lane 128-bit lane checks (use double/int64 for 2-elements-per-128-bit lanes)
+            static_assert(is_cross_lane<double, 3, 2, 1, 0, 7, 6, 5, 4>(), "8-lane 128-bit swap → crossing");
+            static_assert(!is_cross_lane<double, 0, 1, 2, 3, 4, 5, 6, 7>(), "identity 8-lane → no crossing");
+            static_assert(is_cross_lane<std::uint64_t, 3, 2, 1, 0, 7, 6, 5, 4>(), "8-lane uint64_t swap → crossing");
+            static_assert(is_cross_lane<std::int32_t, 4, 5, 6, 7, 0, 1, 2, 3>(), "8-lane int32_t swap → crossing");
+
+            // Additional compile-time checks for 16-element batches (e.g. float/int32)
+            static_assert(is_cross_lane<float, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7>(),
+                          "16-lane 128-bit swap → crossing");
+            static_assert(!is_cross_lane<float, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15>(),
+                          "identity 16-lane → no crossing");
+            static_assert(is_cross_lane<std::uint32_t, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7>(),
+                          "16-lane uint32_t swap → crossing");
         }
     }
 }