Test refactoring: rouding functions

Author: JohanMabille

test/CMakeLists.txt

@@ -154,6 +154,8 @@ set(XSIMD_TESTS
     test_interface.cpp
     test_memory.cpp
     test_poly_evaluation.cpp
+    test_power.cpp
+    test_rounding.cpp
     test_utils.hpp
     #[[    xsimd_api_test.hpp
     xsimd_api_test.cpp

test/test_rounding.cpp

@@ -0,0 +1,159 @@
+/***************************************************************************
+* Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
+* Martin Renou                                                             *
+* Copyright (c) QuantStack                                                 *
+*                                                                          *
+* Distributed under the terms of the BSD 3-Clause License.                 *
+*                                                                          *
+* The full license is in the file LICENSE, distributed with this software. *
+****************************************************************************/
+
+#include "test_utils.hpp"
+
+template <class B>
+class rounding_test : public testing::Test
+{
+protected:
+
+    using batch_type = B;
+    using value_type = typename B::value_type;
+    static constexpr size_t size = B::size;
+    static constexpr size_t nb_input = 8;
+    static constexpr size_t nb_batches = nb_input / size;
+
+    std::array<value_type, nb_input> input;
+    std::array<value_type, nb_input> expected;
+    std::array<value_type, nb_input> res;
+
+    rounding_test()
+    {
+        input[0] = value_type(-3.5);
+        input[1] = value_type(-2.7);
+        input[2] = value_type(-2.5);
+        input[3] = value_type(-2.3);
+        input[4] = value_type(2.3);
+        input[5] = value_type(2.5);
+        input[6] = value_type(2.7);
+        input[7] = value_type(3.5);
+    }
+
+    void test_rounding_functions()
+    {
+        // ceil
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                        [](const value_type& v) { return std::ceil(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_batches; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = ceil(in);
+                detail::store_batch(out, res, i);
+            }
+            for (size_t i = nb_batches; i < nb_input; ++i)
+            {
+                res[i] = std::ceil(input[i]);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            EXPECT_EQ(diff, 0) << print_function_name("ceil");
+        }
+        // floor
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                        [](const value_type& v) { return std::floor(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_batches; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = floor(in);
+                detail::store_batch(out, res, i);
+            }
+            for (size_t i = nb_batches; i < nb_input; ++i)
+            {
+                res[i] = std::floor(input[i]);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            EXPECT_EQ(diff, 0) << print_function_name("floor");
+        }
+        // trunc
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                        [](const value_type& v) { return std::trunc(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_batches; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = trunc(in);
+                detail::store_batch(out, res, i);
+            }
+            for (size_t i = nb_batches; i < nb_input; ++i)
+            {
+                res[i] = std::trunc(input[i]);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            EXPECT_EQ(diff, 0) << print_function_name("trunc");
+        }
+        // round
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                        [](const value_type& v) { return std::round(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_batches; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = round(in);
+                detail::store_batch(out, res, i);
+            }
+            for (size_t i = nb_batches; i < nb_input; ++i)
+            {
+                res[i] = std::round(input[i]);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            EXPECT_EQ(diff, 0) << print_function_name("round");
+        }
+        // nearbyint
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                        [](const value_type& v) { return std::nearbyint(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_batches; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = nearbyint(in);
+                detail::store_batch(out, res, i);
+            }
+            for (size_t i = nb_batches; i < nb_input; ++i)
+            {
+                res[i] = std::nearbyint(input[i]);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            EXPECT_EQ(diff, 0) << print_function_name("nearbyint");
+        }
+        // rint
+        {
+            std::transform(input.cbegin(), input.cend(), expected.begin(),
+                        [](const value_type& v) { return std::rint(v); });
+            batch_type in, out;
+            for (size_t i = 0; i < nb_batches; i += size)
+            {
+                detail::load_batch(in, input, i);
+                out = rint(in);
+                detail::store_batch(out, res, i);
+            }
+            for (size_t i = nb_batches; i < nb_input; ++i)
+            {
+                res[i] = std::rint(input[i]);
+            }
+            size_t diff = detail::get_nb_diff(res, expected);
+            EXPECT_EQ(diff, 0) << print_function_name("rint");
+        }
+    }
+};
+
+TYPED_TEST_SUITE(rounding_test, batch_float_types, simd_test_names);
+
+TYPED_TEST(rounding_test, rounding)
+{
+    this->test_rounding_functions();
+}
+

test/test_utils.hpp

@@ -384,20 +384,33 @@ namespace detail
         return expect_batch_near(lhs_expression, rhs_expression, tmp, rhs);
     }
 
-    template <class T, class A>
-    size_t get_nb_diff(const std::vector<T, A>& lhs, const std::vector<T, A>& rhs)
+    template <class It>
+    size_t get_nb_diff(It lhs_begin, It lhs_end, It rhs_begin)
     {
         size_t res = 0;
-        for (size_t i = 0; i < lhs.size(); ++i)
+        using value_type = typename std::iterator_traits<It>::value_type;
+        while (lhs_begin != lhs_end)
         {
-            if (!scalar_comparison<T>::run(lhs[i], rhs[i]))
+            if (!scalar_comparison<value_type>::run(*lhs_begin++, *rhs_begin++))
             {
                 ++res;
             }
         }
         return res;
     }
 
+    template <class T, class A>
+    size_t get_nb_diff(const std::vector<T, A>& lhs, const std::vector<T, A>& rhs)
+    {
+        return get_nb_diff(lhs.begin(), lhs.end(), rhs.begin());
+    }
+
+    template <class T, size_t N>
+    size_t get_nb_diff(const std::array<T, N>& lhs, const std::array<T, N>& rhs)
+    {
+        return get_nb_diff(lhs.begin(), lhs.end(), rhs.begin());
+    }
+
     template <class B, class S>
     void load_batch(B& b, const S& src, size_t i = 0)
     {