WIP

Author: serge-sans-paille

.github/workflows/sanitizer.yml

@@ -13,7 +13,6 @@ jobs:
     strategy:
       matrix:
         sanitizer:
-          - type
           - memory
           - undefined
     steps:

include/xsimd/arch/common/xsimd_common_math.hpp

@@ -118,6 +118,11 @@ namespace xsimd
             }
             template <class A, class T_out, class T_in>
             XSIMD_INLINE batch<T_out, A> batch_cast(batch<T_in, A> const& self, batch<T_out, A> const&, requires_arch<common>, with_slow_conversion) noexcept
+#if defined (__clang__) || __GNUC__
+            __attribute__((no_sanitize("undefined")));
+#endif
+            template <class A, class T_out, class T_in>
+            XSIMD_INLINE batch<T_out, A> batch_cast(batch<T_in, A> const& self, batch<T_out, A> const&, requires_arch<common>, with_slow_conversion) noexcept
             {
                 static_assert(!std::is_same<T_in, T_out>::value, "there should be no conversion for this type combination");
                 using batch_type_in = batch<T_in, A>;
@@ -126,7 +131,8 @@ namespace xsimd
                 alignas(A::alignment()) T_in buffer_in[batch_type_in::size];
                 alignas(A::alignment()) T_out buffer_out[batch_type_out::size];
                 self.store_aligned(&buffer_in[0]);
-                std::copy(std::begin(buffer_in), std::end(buffer_in), std::begin(buffer_out));
+                for (size_t i = 0; i < batch_type_in::size; ++i)
+                    buffer_out[i] = static_cast<T_out>(buffer_in[i]);
                 return batch_type_out::load_aligned(buffer_out);
             }
 
@@ -2010,7 +2016,9 @@ namespace xsimd
             auto negself = self < zero;
             auto iszeropowpos = self == zero && other >= zero;
             auto adj_self = select(iszeropowpos, batch_type(1), abs(self));
-            batch_type z = exp(other * log(adj_self));
+            auto log_adj_self = log(adj_self);
+            auto t = other * log_adj_self;
+            batch_type z = exp(t);
             z = select(iszeropowpos, zero, z);
             z = select(is_odd(other) && negself, -z, z);
             auto invalid = negself && !(is_flint(other) || isinf(other));

test/test_batch.cpp

@@ -879,12 +879,12 @@ struct batch_test
         for (size_t i = 0; i < size; ++i)
         {
             bool negative_lhs = std::is_signed<T>::value && (i % 2 == 1);
-            lhs[i] = value_type(i) * (negative_lhs ? -10 : 10);
+            lhs[i] = value_type(i) * (negative_lhs ? -3 : 3);
             if (lhs[i] == value_type(0))
             {
                 lhs[i] += value_type(1);
             }
-            rhs[i] = value_type(i) + value_type(4);
+            rhs[i] = value_type(i) + value_type(2);
         }
         scalar = value_type(3);
     }

test/test_batch_cast.cpp

@@ -29,7 +29,7 @@ namespace detail
     is_convertible(T_in value)
     {
         int64_t signed_value = static_cast<int64_t>(value);
-        return signed_value <= static_cast<int64_t>(std::numeric_limits<T_out>::max()) && signed_value >= static_cast<int64_t>(std::numeric_limits<T_out>::lowest());
+        return signed_value < static_cast<int64_t>(std::numeric_limits<T_out>::max()) && signed_value >= static_cast<int64_t>(std::numeric_limits<T_out>::lowest());
     }
 
     template <class T_out, class T_in>
@@ -43,7 +43,7 @@ namespace detail
     inline typename std::enable_if<std::is_floating_point<T_in>::value && std::is_integral<T_out>::value, bool>::type
     is_convertible(T_in value)
     {
-        return value <= static_cast<T_in>(std::numeric_limits<T_out>::max()) && value >= static_cast<T_in>(std::numeric_limits<T_out>::lowest());
+        return value < static_cast<T_in>(std::numeric_limits<T_out>::max()) && value >= static_cast<T_in>(std::numeric_limits<T_out>::lowest());
     }
 
     template <class T_out, class T_in>
@@ -328,12 +328,19 @@ struct batch_cast_test
         using B_common_in = xsimd::batch<T_in>;
         using B_common_out = xsimd::batch<T_out>;
 
-        T_in in_test_value = static_cast<T_in>(test_value);
+        auto clamp = [](T v)
+        {
+            return static_cast<T_in>(xsimd::min(v, static_cast<T>(std::numeric_limits<T_in>::max() - 1)));
+        };
+
+        T_in in_test_value = clamp(test_value);
         if (detail::is_convertible<T_out>(in_test_value))
         {
             B_common_out res = xsimd::batch_cast<T_out>(B_common_in(in_test_value));
             INFO(name);
-            CHECK_SCALAR_EQ(res.get(0), static_cast<T_out>(in_test_value));
+            T_out scalar_ref = static_cast<T_out>(in_test_value);
+            T_out scalar_res = res.get(0);
+            CHECK_SCALAR_EQ(scalar_ref, scalar_res);
         }
     }
 

test/test_batch_int.cpp

@@ -239,8 +239,8 @@ struct batch_int_test
             array_type expected;
             std::transform(lhs.cbegin(), lhs.cend(), expected.begin(),
                            [nb_sh](const value_type& v)
-                           { return v << nb_sh; });
-            batch_type res = batch_lhs() << nb_sh;
+                           { return xsimd::abs(v) << nb_sh; });
+            batch_type res = abs(batch_lhs()) << nb_sh;
             INFO("batch << scalar");
             CHECK_BATCH_EQ(res, expected);
         }
@@ -249,8 +249,8 @@ struct batch_int_test
             array_type expected;
             std::transform(lhs.cbegin(), lhs.cend(), shift.cbegin(), expected.begin(),
                            [](const value_type& l, const value_type& r)
-                           { return l << r; });
-            batch_type res = batch_lhs() << batch_shift();
+                           { return xsimd::abs(l) << r; });
+            batch_type res = abs(batch_lhs()) << batch_shift();
             INFO("batch << batch");
             CHECK_BATCH_EQ(res, expected);
         }

test/test_power.cpp

@@ -40,9 +40,9 @@ struct power_test
         for (size_t i = 0; i < nb_input; ++i)
         {
             zero_input[i] = 0;
-            lhs_input[i] = value_type(i) / 4 + value_type(1.2) * std::sqrt(value_type(i + 0.25));
+            lhs_input[i] = value_type(i / 4 + 1.2 * std::sqrt(i + 0.25));
             zlhs_input[i] = lhs_input[i] * (i % 2);
-            rhs_input[i] = value_type(10.2) / (i + 2) + value_type(0.25);
+            rhs_input[i] = value_type(10.2 / (i + 2) + 0.25);
         }
 
         expected.resize(nb_input);

test/test_select.cpp

@@ -34,10 +34,14 @@ struct select_test
         nb_input = size * 10000;
         lhs_input.resize(nb_input);
         rhs_input.resize(nb_input);
+        auto clamp = [](double v)
+        {
+            return static_cast<value_type>(std::min(v, static_cast<double>(std::numeric_limits<value_type>::max())));
+        };
         for (size_t i = 0; i < nb_input; ++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] = clamp(i / 4 + 1.2 * std::sqrt(i + 0.25));
+            rhs_input[i] = clamp(10.2 / (i + 2) + 0.25);
         }
         expected.resize(nb_input);
         res.resize(nb_input);