Fix defaults

Author: AntoinePrv

benchmark/bench_math.cpp

@@ -40,7 +40,7 @@ namespace
             static_cast<std::int64_t>(state.iterations() * size * 2 * sizeof(input_t)));
     }
 
-    template <typename Op, typename Alloc, alignment aligned = {}>
+    template <typename Op, typename Alloc, alignment aligned = alignment{}>
     void bench_simd(benchmark::State& state)
     {
         bench_unary<Op, Alloc>(
@@ -78,7 +78,7 @@ namespace
         using unaligned_alloc = typename xsimd::test::unaligned_vector<input_t>::allocator_type;
 
         register_bench<Op>("scalar/aligned", bench_scalar<Op, aligned_alloc>);
-        register_bench<Op>("simd/aligned", bench_simd<Op, aligned_alloc, { .start_aligned = true }>);
+        register_bench<Op>("simd/aligned", bench_simd<Op, aligned_alloc, alignment { .start_aligned = true }>);
         register_bench<Op>("simd/unaligned", bench_simd<Op, unaligned_alloc>);
     }
 

include/xsimd_algorithm/builder.hpp

@@ -216,8 +216,8 @@ namespace xsimd::builder
     /// std::array<batch<U, Arch>, batch_arity<U, T>>, both spanning the same element count.
     /// When arity is one, a callback over plain batches is accepted as well.
     template <
-        alignment align = {},
-        unary_options opts = {},
+        alignment align = alignment{},
+        unary_options opts = unary_options{},
         typename Arch = xsimd::default_arch,
         typename T, typename U, typename Func>
     XSIMD_INLINE void map_unary(std::span<T const> in, std::span<U> out, Func&& func)

include/xsimd_algorithm/math.hpp

@@ -16,7 +16,7 @@
 namespace xsimd::algo
 {
     template <
-        xsimd::builder::alignment align = {},
+        xsimd::builder::alignment align = xsimd::builder::alignment{},
         typename Arch = xsimd::default_arch,
         typename T>
     void sqrt(std::span<T const> in, std::span<T> out)
@@ -28,7 +28,7 @@ namespace xsimd::algo
     }
 
     template <
-        xsimd::builder::alignment align = {},
+        xsimd::builder::alignment align = xsimd::builder::alignment{},
         typename Arch = xsimd::default_arch,
         typename T>
     void abs(std::span<T const> in, std::span<T> out)
@@ -40,7 +40,7 @@ namespace xsimd::algo
     }
 
     template <
-        xsimd::builder::alignment align = {},
+        xsimd::builder::alignment align = xsimd::builder::alignment{},
         typename Arch = xsimd::default_arch,
         typename T>
     void exp(std::span<T const> in, std::span<T> out)

test-utils/include/xsimd_test_utils/math_data.hpp

@@ -41,7 +41,7 @@ namespace xsimd::test
             }
         }
 
-        template <xsimd::builder::alignment aligned = {}>
+        template <xsimd::builder::alignment aligned = xsimd::builder::alignment{}>
         static void apply_range_simd(std::span<input_t const> in, std::span<output_t> out)
         {
             constexpr builder::unary_options opts = { .unroll_factor = 4, .pure = Derived::pure };

test-utils/include/xsimd_test_utils/math_ops.hpp

@@ -28,7 +28,7 @@ namespace xsimd::test
 
         static constexpr auto name = "sqrt";
 
-        template <xsimd::builder::alignment aligned = {}>
+        template <xsimd::builder::alignment aligned = xsimd::builder::alignment{}>
         static void apply(std::span<T const> in, std::span<T> out)
         {
             xsimd::algo::sqrt<aligned>(in, out);
@@ -53,7 +53,7 @@ namespace xsimd::test
 
         static constexpr auto name = "abs";
 
-        template <xsimd::builder::alignment aligned = {}>
+        template <xsimd::builder::alignment aligned = xsimd::builder::alignment{}>
         static void apply(std::span<T const> in, std::span<T> out)
         {
             xsimd::algo::abs<aligned>(in, out);

test/test_math.cpp

@@ -16,7 +16,7 @@
 
 namespace
 {
-    template <typename Op, typename Alloc, xsimd::builder::alignment aligned = {}>
+    template <typename Op, typename Alloc, xsimd::builder::alignment aligned = xsimd::builder::alignment{}>
     void check_unary_math()
     {
         // Not a multiple of the batch size, to exercise the tail.
@@ -50,16 +50,15 @@ TEST_CASE_TEMPLATE(
     xsimd::test::abs_op<double>,
     xsimd::test::exp_op<float>,
     xsimd::test::exp_op<double>,
-    xsimd::test::widen_op<std::int32_t>
-    )
+    xsimd::test::widen_op<std::int32_t>)
 {
     using input_t = typename Op::input_t;
     using aligned_allocator = typename xsimd::test::aligned_vector<input_t>::allocator_type;
     using unaligned_allocator = typename xsimd::test::unaligned_vector<input_t>::allocator_type;
 
     SUBCASE("aligned without header")
     {
-        check_unary_math<Op, aligned_allocator, { .start_aligned = true }>();
+        check_unary_math<Op, aligned_allocator, xsimd::builder::alignment { .start_aligned = true }>();
     }
 
     SUBCASE("aligned with header")