WIP

Author: serge-sans-paille

test/test_bitwise_cast.cpp

@@ -21,67 +21,46 @@ struct bitwise_cast_test
     static constexpr size_t N = CP::size;
 
     using int32_batch = xsimd::batch<int32_t>;
-    using float_batch = xsimd::batch<float>;
-
-    using int32_vector = std::vector<int32_t, xsimd::default_allocator<int32_t>>;
-    using float_vector = std::vector<float, xsimd::default_allocator<float>>;
-
-    int32_vector ftoi32_res;
-    float_vector i32tof_res;
-
-#if !XSIMD_WITH_ALTIVEC
     using int64_batch = xsimd::batch<int64_t>;
+    using float_batch = xsimd::batch<float>;
     using double_batch = xsimd::batch<double>;
 
+    using int32_vector = std::vector<int32_t, xsimd::default_allocator<int32_t>>;
     using int64_vector = std::vector<int64_t, xsimd::default_allocator<int64_t>>;
+    using float_vector = std::vector<float, xsimd::default_allocator<float>>;
     using double_vector = std::vector<double, xsimd::default_allocator<double>>;
 
+    int32_vector ftoi32_res;
     int32_vector dtoi32_res;
-    float_vector i64tof_res;
-    float_vector dtof_res;
     int64_vector ftoi64_res;
     int64_vector dtoi64_res;
+    float_vector i32tof_res;
+    float_vector i64tof_res;
+    float_vector dtof_res;
     double_vector i32tod_res;
     double_vector i64tod_res;
     double_vector ftod_res;
-#endif
 
     bitwise_cast_test()
         : ftoi32_res(2 * N)
-        , i32tof_res(2 * N)
-#if !XSIMD_WITH_ALTIVEC
         , dtoi32_res(2 * N)
-        , i64tof_res(2 * N)
-        , dtof_res(2 * N)
         , ftoi64_res(N)
         , dtoi64_res(N)
+        , i32tof_res(2 * N)
+        , i64tof_res(2 * N)
+        , dtof_res(2 * N)
         , i32tod_res(N)
         , i64tod_res(N)
         , ftod_res(N)
-#endif
     {
         {
             int32_batch input = i32_input();
             bitcast b;
             b.i32[0] = input.get(0);
             b.i32[1] = input.get(1);
             std::fill(i32tof_res.begin(), i32tof_res.end(), b.f[0]);
-#if !XSIMD_WITH_ALTIVEC
             std::fill(i32tod_res.begin(), i32tod_res.end(), b.d);
-#endif
-        }
-        {
-            float_batch input = f_input();
-            bitcast b;
-            b.f[0] = input.get(0);
-            b.f[1] = input.get(1);
-            std::fill(ftoi32_res.begin(), ftoi32_res.end(), b.i32[0]);
-#if !XSIMD_WITH_ALTIVEC
-            std::fill(ftoi64_res.begin(), ftoi64_res.end(), b.i64);
-            std::fill(ftod_res.begin(), ftod_res.end(), b.d);
-#endif
         }
-#if !XSIMD_WITH_ALTIVEC
         {
             int64_batch input = i64_input();
             bitcast b;
@@ -93,6 +72,15 @@ struct bitwise_cast_test
                 i64tof_res[2 * i + 1] = b.f[1];
             }
         }
+        {
+            float_batch input = f_input();
+            bitcast b;
+            b.f[0] = input.get(0);
+            b.f[1] = input.get(1);
+            std::fill(ftoi32_res.begin(), ftoi32_res.end(), b.i32[0]);
+            std::fill(ftoi64_res.begin(), ftoi64_res.end(), b.i64);
+            std::fill(ftod_res.begin(), ftod_res.end(), b.d);
+        }
         {
             double_batch input = d_input();
             bitcast b;
@@ -107,7 +95,6 @@ struct bitwise_cast_test
                 dtof_res[2 * i + 1] = b.f[1];
             }
         }
-#endif
     }
 
     void test_to_int32()
@@ -119,14 +106,29 @@ struct bitwise_cast_test
             INFO("to_int32(float)");
             CHECK_VECTOR_EQ(i32vres, ftoi32_res);
         }
-#if !XSIMD_WITH_ALTIVEC
         {
             int32_batch i32bres = xsimd::bitwise_cast<int32_t>(d_input());
             i32bres.store_aligned(i32vres.data());
             INFO("to_int32(double)");
             CHECK_VECTOR_EQ(i32vres, dtoi32_res);
         }
-#endif
+    }
+
+    void test_to_int64()
+    {
+        int64_vector i64vres(int64_batch::size);
+        {
+            int64_batch i64bres = xsimd::bitwise_cast<int64_t>(f_input());
+            i64bres.store_aligned(i64vres.data());
+            INFO("to_int64(float)");
+            CHECK_VECTOR_EQ(i64vres, ftoi64_res);
+        }
+        {
+            int64_batch i64bres = xsimd::bitwise_cast<int64_t>(d_input());
+            i64bres.store_aligned(i64vres.data());
+            INFO("to_int64(double)");
+            CHECK_VECTOR_EQ(i64vres, dtoi64_res);
+        }
     }
 
     void test_to_float()
@@ -138,7 +140,6 @@ struct bitwise_cast_test
             INFO("to_float(int32_t)");
             CHECK_VECTOR_EQ(fvres, i32tof_res);
         }
-#if !XSIMD_WITH_ALTIVEC
         {
             float_batch fbres = xsimd::bitwise_cast<float>(i64_input());
             fbres.store_aligned(fvres.data());
@@ -151,26 +152,6 @@ struct bitwise_cast_test
             INFO("to_float(double)");
             CHECK_VECTOR_EQ(fvres, dtof_res);
         }
-#endif
-    }
-
-#if !XSIMD_WITH_ALTIVEC
-
-    void test_to_int64()
-    {
-        int64_vector i64vres(int64_batch::size);
-        {
-            int64_batch i64bres = xsimd::bitwise_cast<int64_t>(f_input());
-            i64bres.store_aligned(i64vres.data());
-            INFO("to_int64(float)");
-            CHECK_VECTOR_EQ(i64vres, ftoi64_res);
-        }
-        {
-            int64_batch i64bres = xsimd::bitwise_cast<int64_t>(d_input());
-            i64bres.store_aligned(i64vres.data());
-            INFO("to_int64(double)");
-            CHECK_VECTOR_EQ(i64vres, dtoi64_res);
-        }
     }
 
     void test_to_double()
@@ -195,30 +176,27 @@ struct bitwise_cast_test
             CHECK_VECTOR_EQ(dvres, ftod_res);
         }
     }
-#endif
 
 private:
     int32_batch i32_input() const
     {
         return int32_batch(2);
     }
 
-    float_batch f_input() const
+    int64_batch i64_input() const
     {
-        return float_batch(3.);
+        return int64_batch(2);
     }
 
-#if !XSIMD_WITH_ALTIVEC
-    int64_batch i64_input() const
+    float_batch f_input() const
     {
-        return int64_batch(2);
+        return float_batch(3.);
     }
 
     double_batch d_input() const
     {
         return double_batch(2.5e17);
     }
-#endif
 
     union bitcast
     {
@@ -234,13 +212,11 @@ TEST_CASE_TEMPLATE("[bitwise cast]", B, CONVERSION_TYPES)
     bitwise_cast_test<B> Test;
     SUBCASE("to_int32") { Test.test_to_int32(); }
 
-    SUBCASE("to_float") { Test.test_to_float(); }
-
-#if !XSIMD_WITH_ALTIVEC
     SUBCASE("to_int64") { Test.test_to_int64(); }
 
+    SUBCASE("to_float") { Test.test_to_float(); }
+
     SUBCASE("to_double") { Test.test_to_double(); }
-#endif
 }
 #endif
 #endif