style: apply clang-format (brace initializers)

Author: DiamonDinoia

include/xsimd/arch/xsimd_avx.hpp

@@ -756,7 +756,7 @@ namespace xsimd
             constexpr size_t lane = I / elements_per_lane;
             constexpr size_t sub_index = I % elements_per_lane;
             __m128 half = (lane == 0) ? detail::lower_half(self) : detail::upper_half(self);
-            return kernel::get(batch<float, sse4_1>(half), ::xsimd::index<sub_index> { }, sse4_1 { });
+            return kernel::get(batch<float, sse4_1>(half), ::xsimd::index<sub_index> {}, sse4_1 {});
         }
 
         template <class A, size_t I>
@@ -766,7 +766,7 @@ namespace xsimd
             constexpr size_t lane = I / elements_per_lane;
             constexpr size_t sub_index = I % elements_per_lane;
             __m128d half = (lane == 0) ? detail::lower_half(self) : detail::upper_half(self);
-            return kernel::get(batch<double, sse4_1>(half), ::xsimd::index<sub_index> { }, sse4_1 { });
+            return kernel::get(batch<double, sse4_1>(half), ::xsimd::index<sub_index> {}, sse4_1 {});
         }
 
         template <class A, size_t I, class T, class = std::enable_if_t<std::is_integral<T>::value>>
@@ -776,7 +776,7 @@ namespace xsimd
             constexpr size_t lane = I / elements_per_lane;
             constexpr size_t sub_index = I % elements_per_lane;
             __m128i half = (lane == 0) ? detail::lower_half(self) : detail::upper_half(self);
-            return kernel::get(batch<T, sse4_1>(half), ::xsimd::index<sub_index> { }, sse4_1 { });
+            return kernel::get(batch<T, sse4_1>(half), ::xsimd::index<sub_index> {}, sse4_1 {});
         }
 
         // insert

include/xsimd/arch/xsimd_avx512f.hpp

@@ -1376,7 +1376,7 @@ namespace xsimd
             constexpr size_t lane = I / elements_per_lane;
             constexpr size_t sub_index = I % elements_per_lane;
             __m256i half = (lane == 0) ? detail::lower_half(self) : detail::upper_half(self);
-            return kernel::get(batch<T, avx>(half), ::xsimd::index<sub_index> { }, avx { });
+            return kernel::get(batch<T, avx>(half), ::xsimd::index<sub_index> {}, avx {});
         }
 
         // insert

include/xsimd/arch/xsimd_rvv.hpp

@@ -1378,7 +1378,7 @@ namespace xsimd
             {
                 return detail::rvvmv_lane0(arg);
             }
-            return get(arg, I, rvv { });
+            return get(arg, I, rvv {});
         }
 
         template <class A, size_t I, class T, detail::rvv_enable_all_t<T> = 0>
@@ -1388,7 +1388,7 @@ namespace xsimd
             {
                 return std::complex<T> { detail::rvvmv_lane0(arg.real()), detail::rvvmv_lane0(arg.imag()) };
             }
-            return get(arg, I, rvv { });
+            return get(arg, I, rvv {});
         }
 
         // all

include/xsimd/arch/xsimd_sse2.hpp

@@ -2284,14 +2284,14 @@ namespace xsimd
             XSIMD_INLINE auto broadcast_lane_index(std::index_sequence<Is...>) noexcept
                 -> batch_constant<as_unsigned_integer_t<T>, A, static_cast<as_unsigned_integer_t<T>>(Is * 0 + I)...>
             {
-                return { };
+                return {};
             }
 
             template <class T, class A, size_t I>
             XSIMD_INLINE auto broadcast_lane_index() noexcept
-                -> decltype(broadcast_lane_index<T, A, I>(std::make_index_sequence<batch<T, A>::size> { }))
+                -> decltype(broadcast_lane_index<T, A, I>(std::make_index_sequence<batch<T, A>::size> {}))
             {
-                return { };
+                return {};
             }
         }
 
@@ -2303,7 +2303,7 @@ namespace xsimd
             // than routing through swizzle, which expands to pshuflw/pshufhw+unpck for non-trivial I.
             XSIMD_IF_CONSTEXPR(I == 0)
             {
-                return first(self, A { });
+                return first(self, A {});
             }
             else
             {
@@ -2318,11 +2318,11 @@ namespace xsimd
         {
             XSIMD_IF_CONSTEXPR(I == 0)
             {
-                return first(self, A { });
+                return first(self, A {});
             }
             else
             {
-                return first(swizzle(self, detail::broadcast_lane_index<T, A, I>(), A { }), A { });
+                return first(swizzle(self, detail::broadcast_lane_index<T, A, I>(), A {}), A {});
             }
         }
     }

include/xsimd/arch/xsimd_sse4_1.hpp

@@ -126,13 +126,13 @@ namespace xsimd
 #if defined(__x86_64__)
                 return static_cast<T>(_mm_extract_epi64(self, I));
 #else
-                return get(self, ::xsimd::index<I> { }, sse2 { });
+                return get(self, ::xsimd::index<I> {}, sse2 {});
 #endif
             }
             else
             {
                 assert(false && "unsupported arch/op combination");
-                return { };
+                return {};
             }
         }
 

include/xsimd/types/xsimd_api.hpp

@@ -1121,23 +1121,23 @@ namespace xsimd
     {
         static_assert(I < batch<T, A>::size, "index out of bounds");
         detail::static_check_supported_config<T, A>();
-        return kernel::get(b, index<I> { }, A { });
+        return kernel::get(b, index<I> {}, A {});
     }
 
     template <size_t I, class T, class A>
     XSIMD_INLINE bool get(batch_bool<T, A> const& b) noexcept
     {
         static_assert(I < batch_bool<T, A>::size, "index out of bounds");
         detail::static_check_supported_config<T, A>();
-        return kernel::get(b, index<I> { }, A { });
+        return kernel::get(b, index<I> {}, A {});
     }
 
     template <size_t I, class T, class A>
     XSIMD_INLINE typename batch<std::complex<T>, A>::value_type get(batch<std::complex<T>, A> const& b) noexcept
     {
         static_assert(I < batch<std::complex<T>, A>::size, "index out of bounds");
         detail::static_check_supported_config<T, A>();
-        return kernel::get(b, index<I> { }, A { });
+        return kernel::get(b, index<I> {}, A {});
     }
 
     /**

test/test_batch.cpp

@@ -170,7 +170,7 @@ struct batch_test
     {
         batch_type res = batch_lhs();
         CHECK_EQ(xsimd::get<0>(res), res.first());
-        test_get_impl(res, std::make_index_sequence<size> { });
+        test_get_impl(res, std::make_index_sequence<size> {});
     }
 
     void test_arithmetic() const

test/test_batch_complex.cpp

@@ -194,7 +194,7 @@ struct batch_complex_test
     {
         batch_type res = batch_lhs();
         CHECK_EQ(xsimd::get<0>(res), res.first());
-        test_get_impl(res, std::make_index_sequence<size> { });
+        test_get_impl(res, std::make_index_sequence<size> {});
     }
 
     void test_arithmetic() const