Cleanup saturated operators testing

serge-sans-paille · serge-sans-paille · commit 4d18c0fe4767 · 2022-11-04T14:27:47.000Z
Also always use the generic implementation for floating point version.
diff --git a/include/xsimd/arch/generic/xsimd_generic_arithmetic.hpp b/include/xsimd/arch/generic/xsimd_generic_arithmetic.hpp
@@ -121,6 +121,30 @@ namespace xsimd
                                  self, other);
         }
 
+        // sadd
+        template <class A>
+        inline batch<float, A> sadd(batch<float, A> const& self, batch<float, A> const& other, requires_arch<generic>) noexcept
+        {
+            return add(self, other); // no saturated arithmetic on floating point numbers
+        }
+        template <class A>
+        inline batch<double, A> sadd(batch<double, A> const& self, batch<double, A> const& other, requires_arch<generic>) noexcept
+        {
+            return add(self, other); // no saturated arithmetic on floating point numbers
+        }
+
+        // ssub
+        template <class A>
+        inline batch<float, A> ssub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<generic>) noexcept
+        {
+            return sub(self, other); // no saturated arithmetic on floating point numbers
+        }
+        template <class A>
+        inline batch<double, A> ssub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<generic>) noexcept
+        {
+            return sub(self, other); // no saturated arithmetic on floating point numbers
+        }
+
     }
 
 }
diff --git a/include/xsimd/arch/xsimd_avx.hpp b/include/xsimd/arch/xsimd_avx.hpp
@@ -1132,16 +1132,6 @@ namespace xsimd
         }
 
         // sadd
-        template <class A>
-        inline batch<float, A> sadd(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
-        {
-            return add(self, other); // no saturated arithmetic on floating point numbers
-        }
-        template <class A>
-        inline batch<double, A> sadd(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
-        {
-            return add(self, other); // no saturated arithmetic on floating point numbers
-        }
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         inline batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
@@ -1357,16 +1347,6 @@ namespace xsimd
         }
 
         // ssub
-        template <class A>
-        inline batch<float, A> ssub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx>) noexcept
-        {
-            return _mm256_sub_ps(self, other); // no saturated arithmetic on floating point numbers
-        }
-        template <class A>
-        inline batch<double, A> ssub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx>) noexcept
-        {
-            return _mm256_sub_pd(self, other); // no saturated arithmetic on floating point numbers
-        }
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         inline batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx>) noexcept
         {
diff --git a/include/xsimd/arch/xsimd_avx512f.hpp b/include/xsimd/arch/xsimd_avx512f.hpp
@@ -1350,16 +1350,6 @@ namespace xsimd
         }
 
         // sadd
-        template <class A>
-        inline batch<float, A> sadd(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
-        {
-            return add(self, other); // no saturated arithmetic on floating point numbers
-        }
-        template <class A>
-        inline batch<double, A> sadd(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
-        {
-            return add(self, other); // no saturated arithmetic on floating point numbers
-        }
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         inline batch<T, A> sadd(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
@@ -1642,16 +1632,6 @@ namespace xsimd
         }
 
         // ssub
-        template <class A>
-        inline batch<float, A> ssub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
-        {
-            return _mm512_sub_ps(self, other); // no saturated arithmetic on floating point numbers
-        }
-        template <class A>
-        inline batch<double, A> ssub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<avx512f>) noexcept
-        {
-            return _mm512_sub_pd(self, other); // no saturated arithmetic on floating point numbers
-        }
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         inline batch<T, A> ssub(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx512f>) noexcept
         {
diff --git a/include/xsimd/arch/xsimd_sse2.hpp b/include/xsimd/arch/xsimd_sse2.hpp
@@ -1325,11 +1325,7 @@ namespace xsimd
         }
 
         // sadd
-        template <class A>
-        inline batch<float, A> sadd(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
-        {
-            return _mm_add_ps(self, other); // no saturated arithmetic on floating point numbers
-        }
+
         // TODO: move this in xsimd_generic
         namespace detail
         {
@@ -1386,11 +1382,6 @@ namespace xsimd
                 }
             }
         }
-        template <class A>
-        inline batch<double, A> sadd(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
-        {
-            return _mm_add_pd(self, other); // no saturated arithmetic on floating point numbers
-        }
 
         // set
         template <class A, class... Values>
@@ -1449,11 +1440,6 @@ namespace xsimd
         }
 
         // ssub
-        template <class A>
-        inline batch<float, A> ssub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept
-        {
-            return _mm_sub_ps(self, other); // no saturated arithmetic on floating point numbers
-        }
         // TODO: move this in xsimd_generic
         namespace detail
         {
@@ -1507,12 +1493,6 @@ namespace xsimd
             }
         }
 
-        template <class A>
-        inline batch<double, A> ssub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept
-        {
-            return _mm_sub_pd(self, other); // no saturated arithmetic on floating point numbers
-        }
-
         // store_aligned
         template <class A>
         inline void store_aligned(float* mem, batch<float, A> const& self, requires_arch<sse2>) noexcept
diff --git a/include/xsimd/types/xsimd_api.hpp b/include/xsimd/types/xsimd_api.hpp
@@ -1684,7 +1684,7 @@ namespace xsimd
      * @return the result of the saturated addition.
      */
     template <class T, class A>
-    inline auto sadd(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x + y)
+    inline batch<T, A> sadd(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return kernel::sadd<A>(x, y, A {});
@@ -1884,7 +1884,7 @@ namespace xsimd
      * @return the result of the saturated difference.
      */
     template <class T, class A>
-    inline auto ssub(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x - y)
+    inline batch<T, A> ssub(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return kernel::ssub<A>(x, y, A {});
diff --git a/test/test_batch.cpp b/test/test_batch.cpp
@@ -250,7 +250,6 @@ struct batch_test
 
     void test_saturated_arithmetic() const
     {
-#ifdef T
         // batch + batch
         {
             array_type expected;
@@ -259,6 +258,7 @@ struct batch_test
             INFO("sadd(batch, batch)");
             CHECK_BATCH_EQ(res, expected);
         }
+#if 0
         // batch + scalar
         {
             array_type expected;
@@ -271,6 +271,7 @@ struct batch_test
             INFO("sadd(scalar, batch)");
             CHECK_BATCH_EQ(rres, expected);
         }
+#endif
         // batch - batch
         {
             array_type expected;
@@ -280,6 +281,7 @@ struct batch_test
             INFO("ssub(batch, batch)");
             CHECK_BATCH_EQ(res, expected);
         }
+#if 0
         // batch - scalar
         {
             array_type expected;

Original file line number	Diff line number	Diff line change
`@@ -1325,11 +1325,7 @@ namespace xsimd`
`1325`	`1325`	`}`
`1326`	`1326`
`1327`	`1327`	`// sadd`
`1328`		`- template <class A>`
`1329`		`- inline batch<float, A> sadd(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept`
`1330`		`- {`
`1331`		`- return _mm_add_ps(self, other); // no saturated arithmetic on floating point numbers`
`1332`		`- }`
	`1328`	`+`
`1333`	`1329`	`// TODO: move this in xsimd_generic`
`1334`	`1330`	`namespace detail`
`1335`	`1331`	`{`
`@@ -1386,11 +1382,6 @@ namespace xsimd`
`1386`	`1382`	`}`
`1387`	`1383`	`}`
`1388`	`1384`	`}`
`1389`		`- template <class A>`
`1390`		`- inline batch<double, A> sadd(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept`
`1391`		`- {`
`1392`		`- return _mm_add_pd(self, other); // no saturated arithmetic on floating point numbers`
`1393`		`- }`
`1394`	`1385`
`1395`	`1386`	`// set`
`1396`	`1387`	`template <class A, class... Values>`
`@@ -1449,11 +1440,6 @@ namespace xsimd`
`1449`	`1440`	`}`
`1450`	`1441`
`1451`	`1442`	`// ssub`
`1452`		`- template <class A>`
`1453`		`- inline batch<float, A> ssub(batch<float, A> const& self, batch<float, A> const& other, requires_arch<sse2>) noexcept`
`1454`		`- {`
`1455`		`- return _mm_sub_ps(self, other); // no saturated arithmetic on floating point numbers`
`1456`		`- }`
`1457`	`1443`	`// TODO: move this in xsimd_generic`
`1458`	`1444`	`namespace detail`
`1459`	`1445`	`{`
`@@ -1507,12 +1493,6 @@ namespace xsimd`
`1507`	`1493`	`}`
`1508`	`1494`	`}`
`1509`	`1495`
`1510`		`- template <class A>`
`1511`		`- inline batch<double, A> ssub(batch<double, A> const& self, batch<double, A> const& other, requires_arch<sse2>) noexcept`
`1512`		`- {`
`1513`		`- return _mm_sub_pd(self, other); // no saturated arithmetic on floating point numbers`
`1514`		`- }`
`1515`		`-`
`1516`	`1496`	`// store_aligned`
`1517`	`1497`	`template <class A>`
`1518`	`1498`	`inline void store_aligned(float* mem, batch<float, A> const& self, requires_arch<sse2>) noexcept`
Original file line number	Diff line number	Diff line change
`@@ -250,7 +250,6 @@ struct batch_test`
`250`	`250`
`251`	`251`	`void test_saturated_arithmetic() const`
`252`	`252`	`{`
`253`		`-#ifdef T`
`254`	`253`	`// batch + batch`
`255`	`254`	`{`
`256`	`255`	`array_type expected;`
`@@ -259,6 +258,7 @@ struct batch_test`
`259`	`258`	`INFO("sadd(batch, batch)");`
`260`	`259`	`CHECK_BATCH_EQ(res, expected);`
`261`	`260`	`}`
	`261`	`+#if 0`
`262`	`262`	`// batch + scalar`
`263`	`263`	`{`
`264`	`264`	`array_type expected;`
`@@ -271,6 +271,7 @@ struct batch_test`
`271`	`271`	`INFO("sadd(scalar, batch)");`
`272`	`272`	`CHECK_BATCH_EQ(rres, expected);`
`273`	`273`	`}`
	`274`	`+#endif`
`274`	`275`	`// batch - batch`
`275`	`276`	`{`
`276`	`277`	`array_type expected;`
`@@ -280,6 +281,7 @@ struct batch_test`
`280`	`281`	`INFO("ssub(batch, batch)");`
`281`	`282`	`CHECK_BATCH_EQ(res, expected);`
`282`	`283`	`}`
	`284`	`+#if 0`
`283`	`285`	`// batch - scalar`
`284`	`286`	`{`
`285`	`287`	`array_type expected;`