Rename builder.hpp > map.hpp

Author: AntoinePrv

benchmark/bench_map_unary.cpp

@@ -11,7 +11,7 @@
 #include <benchmark/benchmark.h>
 
 #include "map_unary_utils.hpp"
-#include "xsimd_algorithm/builder.hpp"
+#include "xsimd_algorithm/map.hpp"
 #include "xsimd_test_utils/map_unary_data.hpp"
 #include "xsimd_test_utils/utils.hpp"
 
@@ -21,8 +21,8 @@ namespace
     using xsimd::bench::bench_scalar;
     using xsimd::bench::bench_transform;
     using xsimd::bench::register_bench;
-    using xsimd::builder::alignment_options;
-    using xsimd::builder::map_options;
+    using xsimd::alignment_options;
+    using xsimd::map_options;
 
     template <typename Op>
     void register_benches()

benchmark/bench_math.cpp

@@ -19,7 +19,7 @@ namespace
     using xsimd::bench::bench_map_unary;
     using xsimd::bench::bench_scalar;
     using xsimd::bench::register_bench;
-    using xsimd::builder::alignment_options;
+    using xsimd::alignment_options;
 
     /// Register math benchmarks.
     ///

benchmark/map_unary_utils.hpp

@@ -15,13 +15,13 @@
 #include <benchmark/benchmark.h>
 
 #include "bench_utils.hpp"
-#include "xsimd_algorithm/builder.hpp"
+#include "xsimd_algorithm/map.hpp"
 #include "xsimd_test_utils/utils.hpp"
 
 namespace xsimd::bench
 {
-    using xsimd::builder::alignment_options;
-    using xsimd::builder::map_options;
+    using xsimd::alignment_options;
+    using xsimd::map_options;
 
     template <typename Op, typename Alloc, typename Apply>
     void bench_unary(benchmark::State& state, Apply apply)

include/xsimd_algorithm/builder.hpp include/xsimd_algorithm/map.hppinclude/xsimd_algorithm/builder.hpp renamed to include/xsimd_algorithm/map.hpp

@@ -6,8 +6,8 @@
  * The full license is in the file LICENSE, distributed with this software. *
  ****************************************************************************/
 
-#ifndef XSIMD_ALGORITHM_BUILDER_HPP
-#define XSIMD_ALGORITHM_BUILDER_HPP
+#ifndef XSIMD_ALGORITHM_MAP_HPP
+#define XSIMD_ALGORITHM_MAP_HPP
 
 #include <algorithm>
 #include <array>
@@ -23,7 +23,7 @@
 
 #include "./macros.hpp"
 
-namespace xsimd::builder
+namespace xsimd
 {
     /// Return the pointer before the input with the given alignment or itself if aligned.
     template <typename T>

include/xsimd_algorithm/math.hpp

@@ -11,42 +11,42 @@
 
 #include <xsimd/xsimd.hpp>
 
-#include "./builder.hpp"
+#include "./map.hpp"
 
 namespace xsimd::algo
 {
     template <
-        xsimd::builder::alignment_options align = xsimd::builder::alignment_options{},
+        xsimd::alignment_options align = xsimd::alignment_options{},
         typename Arch = xsimd::default_arch,
         typename T>
     void sqrt(std::span<T const> in, std::span<T> out)
     {
-        constexpr builder::map_options opts = { .unroll_factor = 4, .pure = true };
-        return xsimd::builder::map_unary<align, opts, Arch>(
+        constexpr map_options opts = { .unroll_factor = 4, .pure = true };
+        return xsimd::map_unary<align, opts, Arch>(
             in, out, [](auto x)
             { return sqrt(x); });
     }
 
     template <
-        xsimd::builder::alignment_options align = xsimd::builder::alignment_options{},
+        xsimd::alignment_options align = xsimd::alignment_options{},
         typename Arch = xsimd::default_arch,
         typename T>
     void abs(std::span<T const> in, std::span<T> out)
     {
-        constexpr builder::map_options opts = { .unroll_factor = 4, .pure = true };
-        return xsimd::builder::map_unary<align, opts, Arch>(
+        constexpr map_options opts = { .unroll_factor = 4, .pure = true };
+        return xsimd::map_unary<align, opts, Arch>(
             in, out, [](auto x)
             { return abs(x); });
     }
 
     template <
-        xsimd::builder::alignment_options align = xsimd::builder::alignment_options{},
+        xsimd::alignment_options align = xsimd::alignment_options{},
         typename Arch = xsimd::default_arch,
         typename T>
     void exp(std::span<T const> in, std::span<T> out)
     {
-        constexpr builder::map_options opts = { .unroll_factor = 4, .pure = true };
-        return xsimd::builder::map_unary<align, opts, Arch>(
+        constexpr map_options opts = { .unroll_factor = 4, .pure = true };
+        return xsimd::map_unary<align, opts, Arch>(
             in, out, [](auto x)
             { return exp(x); });
     }

test-utils/include/xsimd_test_utils/map_unary_data.hpp

@@ -16,15 +16,15 @@
 #include <utility>
 #include <vector>
 
-#include "xsimd_algorithm/builder.hpp"
+#include "xsimd_algorithm/map.hpp"
 #include "xsimd_algorithm/stl/transform.hpp"
 
 #include "xsimd_test_utils/utils.hpp"
 
 namespace xsimd::test
 {
-    using xsimd::builder::alignment_options;
-    using xsimd::builder::map_options;
+    using xsimd::alignment_options;
+    using xsimd::map_options;
 
     /// Derives the scalar range application from the element-wise Derived::apply.
     template <typename Derived, typename In, typename Out = In>
@@ -51,7 +51,7 @@ namespace xsimd::test
             typename Arch = xsimd::default_arch>
         static void range_apply_map_unary(std::span<input_t const> in, std::span<output_t> out)
         {
-            return xsimd::builder::map_unary<aligned, opts, Arch>(
+            return xsimd::map_unary<aligned, opts, Arch>(
                 in, out, [](auto x)
                 { return Derived::apply_batch(x); });
         }

test-utils/include/xsimd_test_utils/math_ops.hpp

@@ -14,7 +14,7 @@
 #include <span>
 #include <vector>
 
-#include <xsimd_algorithm/builder.hpp>
+#include <xsimd_algorithm/map.hpp>
 #include <xsimd_algorithm/math.hpp>
 
 #include "xsimd_test_utils/utils.hpp"
@@ -28,7 +28,7 @@ namespace xsimd::test
 
         static constexpr auto name = "sqrt";
 
-        template <xsimd::builder::alignment_options aligned = xsimd::builder::alignment_options{}>
+        template <xsimd::alignment_options aligned = xsimd::alignment_options{}>
         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_options aligned = xsimd::builder::alignment_options{}>
+        template <xsimd::alignment_options aligned = xsimd::alignment_options{}>
         static void apply(std::span<T const> in, std::span<T> out)
         {
             xsimd::algo::abs<aligned>(in, out);

test/CMakeLists.txt

@@ -48,7 +48,7 @@ endif()
 set(XSIMD_ALGORITHM_TESTS
     main.cpp
     test_arange.cpp
-    test_builder.cpp
+    test_map.cpp
     test_iterator.cpp
     test_math.cpp
     test_reduce.cpp

test/test_builder.cpp test/test_map.cpptest/test_builder.cpp renamed to test/test_map.cpp

@@ -13,7 +13,7 @@
 #include <doctest/doctest.h>
 #include <xsimd_test_utils/utils.hpp>
 
-#include "xsimd_algorithm/builder.hpp"
+#include "xsimd_algorithm/map.hpp"
 
 /// Map unary test where one input batch pairs with two output batches.
 TEST_CASE("map_unary int32 to int64")
@@ -30,7 +30,7 @@ TEST_CASE("map_unary int32 to int64")
     const auto func = [](auto const& x)
     { return xsimd::widen(x + input_type { 1 }); };
 
-    xsimd::builder::map_unary(input, output, func);
+    xsimd::map_unary(input, output, func);
 
     for (std::size_t i = 0; i < size; ++i)
     {
@@ -71,7 +71,7 @@ TEST_CASE("map_unary int64 to int32")
             xsimd::make_batch_constant<std::uint32_t, low_halves>());
     };
 
-    xsimd::builder::map_unary(xsimd::test::as_span(input), xsimd::test::as_span(output), func);
+    xsimd::map_unary(xsimd::test::as_span(input), xsimd::test::as_span(output), func);
 
     for (std::size_t i = 0; i < size; ++i)
     {

test/test_math.cpp

@@ -16,7 +16,7 @@
 
 namespace
 {
-    template <typename Op, typename Alloc, xsimd::builder::alignment_options aligned = xsimd::builder::alignment_options {}>
+    template <typename Op, typename Alloc, xsimd::alignment_options aligned = xsimd::alignment_options {}>
     void check_unary_math()
     {
         // Not a multiple of the batch size, to exercise the tail.
@@ -58,7 +58,7 @@ TEST_CASE_TEMPLATE(
 
     SUBCASE("aligned without header")
     {
-        check_unary_math<Op, aligned_allocator, xsimd::builder::alignment_options { .start_aligned = true }>();
+        check_unary_math<Op, aligned_allocator, xsimd::alignment_options { .start_aligned = true }>();
     }
 
     SUBCASE("aligned with header")