Added test of basic math functions for integral batches (sse and avx)

Author: JohanMabille

test/xsimd_basic_math_test.cpp

@@ -33,6 +33,13 @@ namespace xsimd
 }
 
 #if XSIMD_X86_INSTR_SET >= XSIMD_X86_SSE2_VERSION
+TEST(xsimd, sse_int32_basic_math)
+{
+    std::ofstream out("log/sse_int32_basic_math.log", std::ios_base::out);
+    bool res = xsimd::test_basic_math<int32_t, 4, 16>(out, "sse int32_t");
+    EXPECT_TRUE(res);
+}
+
 TEST(xsimd, sse_float_basic_math)
 {
     std::ofstream out("log/sse_float_basic_math.log", std::ios_base::out);
@@ -49,6 +56,13 @@ TEST(xsimd, sse_double_basic_math)
 #endif
 
 #if XSIMD_X86_INSTR_SET >= XSIMD_X86_AVX_VERSION
+TEST(xsimd, avx_int32_basic_math)
+{
+    std::ofstream out("log/avx_int32_basic_math.log", std::ios_base::out);
+    bool res = xsimd::test_basic_math<int32_t, 8, 32>(out, "avx int32_t");
+    EXPECT_TRUE(res);
+}
+
 TEST(xsimd, avx_float_basic_math)
 {
     std::ofstream out("log/avx_float_basic_math.log", std::ios_base::out);

test/xsimd_basic_math_test.hpp

@@ -66,8 +66,8 @@ namespace xsimd
         clip_hi = 1.;
         for (size_t i = 0; i < N; ++i)
         {
-            lhs_input[i] = value_type(i) / 4 + value_type(1.2) * std::sqrt(value_type(i + 0.25));
-            rhs_input[i] = value_type(10.2) / (i + 2) + value_type(0.25);
+            lhs_input[i] = value_type(i) / 4 + value_type(1.2) * std::sqrt(value_type(i + 0.25)) + 1.;
+            rhs_input[i] = value_type(10.2) / (i + 2) + value_type(0.25) + 1.;
             from_input[i] = rhs_input[i] - value_type(1);
             fmod_res[i] = std::fmod(lhs_input[i], rhs_input[i]);
             remainder_res[i] = std::remainder(lhs_input[i], rhs_input[i]);
@@ -81,6 +81,76 @@ namespace xsimd
         }
     }
 
+    namespace detail
+    {
+        template <class T, bool is_int = std::is_integral<typename T::value_type>::value>
+        struct infinity_tester
+        {
+            using tester_type = T;
+            using vector_type = typename T::vector_type;
+            using res_type = typename T::res_type;
+
+            static inline bool isfinite(std::ostream& out,
+                                        const std::string& topic,
+                                        tester_type& tester,
+                                        res_type& res)
+            {
+                vector_type lhs = infinity<vector_type>();
+                vector_type vres = select(xsimd::isfinite(lhs), vector_type(1.), vector_type(0.));
+                detail::store_vec(vres, res);
+                bool success = check_almost_equal(topic, res, tester.inf_res, out);
+                typename res_type::value_type scalar_cond_res = xsimd::isfinite(lhs[0])?1.:0.;
+                success &= check_almost_equal(topic, scalar_cond_res, tester.inf_res[0], out);
+                return success;
+            }
+
+            static inline bool isinf(std::ostream& out,
+                                     const std::string& topic,
+                                     tester_type& tester,
+                                     res_type& res)
+
+            {
+                vector_type lhs = infinity<vector_type>();
+                vector_type vres = select(xsimd::isinf(lhs), vector_type(0.), vector_type(1.));
+                detail::store_vec(vres, res);
+                bool success = check_almost_equal(topic, res, tester.inf_res, out);
+                typename res_type::value_type scalar_cond_res = xsimd::isinf(lhs[0])?0.:1.;
+                success &= check_almost_equal(topic, scalar_cond_res, tester.inf_res[0], out);
+                return success;
+            }
+        };
+
+        template <class T>
+        struct infinity_tester<T, true>
+        {
+            using tester_type = T;
+            using vector_type = typename T::vector_type;
+            using res_type = typename T::res_type;
+
+            static inline bool isfinite(std::ostream& out,
+                                        const std::string& topic,
+                                        tester_type& tester,
+                                        res_type&)
+            {
+                vector_type lhs(1.);
+                typename res_type::value_type scalar_cond_res = xsimd::isfinite(lhs[0])?0.:1.;
+                bool success = check_almost_equal(topic, scalar_cond_res, tester.inf_res[0], out);
+                return true;
+            }
+
+            static inline bool isinf(std::ostream& out,
+                                     const std::string& topic,
+                                     tester_type& tester,
+                                     res_type&)
+            {   
+                vector_type lhs(1.);
+                typename res_type::value_type scalar_cond_res = xsimd::isfinite(lhs[0])?1.:0.;
+                bool success = check_almost_equal(topic, scalar_cond_res, tester.inf_res[0], out);
+                return true;
+            }
+        };
+    }
+
     template <class T>
     bool test_simd_basic_math(std::ostream& out, T& tester)
     {
@@ -152,28 +222,15 @@ namespace xsimd
         detail::store_vec(vres, res);
         tmp_success = check_almost_equal(topic, res, tester.finite_res, out);
         success = success && tmp_success;
-        lhs = infinity<vector_type>();
-        vres = select(isfinite(lhs), vector_type(1.), vector_type(0.));
-        detail::store_vec(vres, res);
-        tmp_success = check_almost_equal(topic, res, tester.inf_res, out);
-        success = success && tmp_success;
-        scalar_cond_res = xsimd::isfinite(lhs[0])?1.:0.;
-        success &= check_almost_equal(topic, scalar_cond_res, tester.inf_res[0], out);
+        success = success && detail::infinity_tester<T>::isfinite(out, topic, tester, res);
 
         topic = "isinf    : ";
         lhs = vector_type(12.);
         vres = select(isinf(lhs), vector_type(0.), vector_type(1.));
         detail::store_vec(vres, res);
         tmp_success = check_almost_equal(topic, res, tester.finite_res, out);
         success = success && tmp_success;
-        lhs = infinity<vector_type>();
-        vres = select(isinf(lhs), vector_type(0.), vector_type(1.));
-        detail::store_vec(vres, res);
-        tmp_success = check_almost_equal(topic, res, tester.inf_res, out);
-        success = success && tmp_success;
-        scalar_cond_res = xsimd::isinf(lhs[0])?0.:1.;
-        success &= check_almost_equal(topic, scalar_cond_res, tester.inf_res[0], out);
-
+        
         topic = "nextafter: ";
         detail::load_vec(lhs, tester.from_input);
         detail::load_vec(rhs, tester.rhs_input);

test/xsimd_test_utils.hpp

@@ -232,12 +232,50 @@ namespace xsimd
         return os;
     }
 
-    template <class T>
-    inline bool check_almost_equal(const std::string& topic, const T& res, const T& ref, std::ostream& out)
+    namespace detail
+    {
+        template <class T1, class T2>
+        struct almost_equal_checker
+        {
+            static bool run_scalar(const T1& res, const T2& ref)
+            {
+                return almost_equal_checker<T1, T1>::run_scalar(res, T1(ref));
+            }
+
+            template <class A1, class A2>
+            static bool run_vector(const std::vector<T1, A1>& res,
+                                   const std::vector<T2, A2>& ref)
+            {
+                std::vector<T1, A1> new_ref(ref.size());
+                std::transform(ref.cbegin(), ref.end(), new_ref.begin(),
+                               [](const T2& v) { return static_cast<T1>(v); });
+                return almost_equal_checker<T1, T1>::run_vector(res, new_ref);
+            }
+        };
+
+        template <class T>
+        struct almost_equal_checker<T, T>
+        {
+            static bool run_scalar(const T& res, const T& ref)
+            {
+                return scalar_comparison<T>::run(res, ref);
+            }
+
+            template <class A>
+            static bool run_vector(const std::vector<T, A>& res,
+                                   const std::vector<T, A>& ref)
+            {
+                return vector_comparison(res, ref);
+            }
+        };
+    };
+
+    template <class T1, class T2>
+    inline bool check_almost_equal(const std::string& topic, const T1& res, const T2& ref, std::ostream& out)
     {
         out << topic;
         out << std::setprecision(20);
-        if (scalar_comparison<T>::run(res, ref))
+        if (detail::almost_equal_checker<T1, T2>::run_scalar(res, ref))
         {
             out << "OK" << std::endl;
             return true;
@@ -255,12 +293,15 @@ namespace xsimd
 
 #define PRINT_COUT
 
-    template <class T, class A>
-    inline bool check_almost_equal(const std::string& topic, const std::vector<T, A>& res, const std::vector<T, A>& ref, std::ostream& out)
+    template <class T1, class A1, class T2, class A2>
+    inline bool check_almost_equal(const std::string& topic,
+                                   const std::vector<T1, A1>& res,
+                                   const std::vector<T2, A2>& ref,
+                                   std::ostream& out)
     {
         out << topic;
         out << std::setprecision(20);
-        int comp = vector_comparison(res, ref);
+        int comp = detail::almost_equal_checker<T1, T2>::run_vector(res, ref);
         if (comp == 0)
         {
             out << "OK" << std::endl;