as_signed and as_unsigned

Author: gouarin

include/xtensor/generators/xbuilder.hpp

@@ -30,6 +30,8 @@
 #include "../core/xoperation.hpp"
 #include "../generators/xgenerator.hpp"
 #include "../views/xbroadcast.hpp"
+#include "../utils/xutils.hpp"
+
 
 namespace xt
 {
@@ -498,8 +500,8 @@ namespace xt
             inline value_type access(const tuple_type& t, size_type axis, It first, It last) const
             {
                 // trim off extra indices if provided to match behavior of containers
-                auto dim_offset = std::distance(first, last) - std::get<0>(t).dimension();
-                size_t axis_dim = *(first + axis + dim_offset);
+                auto dim_offset = std::distance(first, last) - as_signed(std::get<0>(t).dimension());
+                size_t axis_dim = as_unsigned(*(first + as_signed(axis) + dim_offset));
                 auto match = [&](auto& arr)
                 {
                     if (axis_dim >= arr.shape()[axis])
@@ -520,7 +522,7 @@ namespace xt
                         const size_t stride = std::accumulate(
                             shape.begin() + i + 1,
                             shape.end(),
-                            1,
+                            1ul,
                             std::multiplies<size_t>()
                         );
                         if (i == axis)
@@ -529,11 +531,11 @@ namespace xt
                         }
                         else
                         {
-                            const auto len = (*(first + i + dim_offset));
+                            const auto len = as_unsigned(*(first + as_signed(i) + dim_offset));
                             offset += len * stride;
                         }
                     }
-                    const auto element = arr.begin() + offset;
+                    const auto element = arr.begin() + as_signed(offset);
                     return *element;
                 };
 
@@ -563,7 +565,7 @@ namespace xt
             {
                 auto get_item = [&](auto& arr)
                 {
-                    size_t offset = 0;
+                    std::ptrdiff_t offset = 0;
                     const size_t end = arr.dimension();
                     size_t after_axis = 0;
                     for (size_t i = 0; i < end; i++)
@@ -576,16 +578,16 @@ namespace xt
                         const size_t stride = std::accumulate(
                             shape.begin() + i + 1,
                             shape.end(),
-                            1,
+                            1ul,
                             std::multiplies<size_t>()
                         );
-                        const auto len = (*(first + i + after_axis));
-                        offset += len * stride;
+                        const auto len = as_unsigned(*(first + as_signed(i + after_axis)));
+                        offset += as_signed(len * stride);
                     }
                     const auto element = arr.begin() + offset;
                     return *element;
                 };
-                size_type i = *(first + axis);
+                auto i = as_unsigned((*(first + as_signed(axis))));
                 return apply<value_type>(i, get_item, t);
             }
         };

include/xtensor/misc/xfft.hpp

@@ -13,6 +13,7 @@
 #include "../views/xaxis_slice_iterator.hpp"
 #include "../views/xview.hpp"
 #include "./xtl_concepts.hpp"
+#include "../utils/xutils.hpp"
 
 namespace xt
 {
@@ -61,15 +62,15 @@ namespace xt
                     auto odd = radix2(xt::view(ev, xt::range(1, _, 2)));
 #endif
 
-                    auto range = xt::arange<double>(N / 2);
-                    auto exp = xt::exp(static_cast<value_type>(-2i) * pi * range / N);
+                    auto range = xt::arange<double>(0.5*static_cast<double>(N));
+                    auto exp = xt::exp(static_cast<value_type>(-2i) * pi * range / static_cast<precision>(N));
                     auto t = exp * odd;
                     auto first_half = even + t;
                     auto second_half = even - t;
                     // TODO: should be a call to stack if performance was improved
                     auto spectrum = xt::xtensor<value_type, 1>::from_shape({N});
-                    xt::view(spectrum, xt::range(0, N / 2)) = first_half;
-                    xt::view(spectrum, xt::range(N / 2, N)) = second_half;
+                    xt::view(spectrum, xt::range(0, static_cast<size_t>(N / 2))) = first_half;
+                    xt::view(spectrum, xt::range(static_cast<size_t>(N / 2), N)) = second_half;
                     return spectrum;
                 }
             }
@@ -82,15 +83,15 @@ namespace xt
 
                 // Find a power-of-2 convolution length m such that m >= n * 2 + 1
                 const std::size_t n = data.size();
-                size_t m = std::ceil(std::log2(n * 2 + 1));
-                m = std::pow(2, m);
+                auto m = static_cast<size_t>(std::ceil(std::log2(n * 2 + 1)));
+                m = 1 << m;
 
                 // Trignometric table
                 auto exp_table = xt::xtensor<std::complex<precision>, 1>::from_shape({n});
                 xt::xtensor<std::size_t, 1> i = xt::pow(xt::linspace<std::size_t>(0, n - 1, n), 2);
                 i %= (n * 2);
 
-                auto angles = xt::eval(precision{3.141592653589793238463} * i / n);
+                auto angles = xt::eval(static_cast<precision>(3.141592653589793238463) * xt::cast<precision>(i) / static_cast<precision>(n));
                 auto j = std::complex<precision>(0, 1);
                 exp_table = xt::exp(-angles * j);
 
@@ -112,7 +113,7 @@ namespace xt
                 auto spectrum_k = xv * yv;
                 auto complex_args = xt::conj(spectrum_k);
                 auto fft_res = radix2(complex_args);
-                auto cv = xt::conj(fft_res) / m;
+                auto cv = xt::conj(fft_res) / static_cast<precision>(m);
 
                 return xt::eval(xt::view(cv, xt::range(0, n)) * exp_table);
             }
@@ -162,7 +163,7 @@ namespace xt
             if constexpr (xtl::is_complex<typename std::decay<E>::type::value_type>::value)
             {
                 // check the length of the data on that axis
-                const std::size_t n = e.shape(axis);
+                const std::size_t n = e.shape(as_unsigned(axis));
                 if (n == 0)
                 {
                     XTENSOR_THROW(std::runtime_error, "Cannot take the iFFT along an empty dimention");
@@ -218,7 +219,7 @@ namespace xt
             auto outvec = ifft(xv, axis);
 
             // Scaling (because this FFT implementation omits it)
-            outvec = outvec / n;
+            outvec = outvec / static_cast<double>(n);
 
             return outvec;
         }

include/xtensor/misc/xmanipulation.hpp

@@ -296,8 +296,8 @@ namespace xt
             auto perm = xtl::make_sequence<S>(dim, 0);
             using id_t = typename S::value_type;
             std::iota(perm.begin(), perm.end(), id_t(0));
-            perm[ax1] = ax2;
-            perm[ax2] = ax1;
+            perm[ax1] = static_cast<id_t>(ax2);
+            perm[ax2] = static_cast<id_t>(ax1);
             return perm;
         }
     }
@@ -339,18 +339,18 @@ namespace xt
 
             // Initializing to src_norm handles case where `dest == -1` and the loop
             // does not go check `perm_idx == dest_norm` a `dim+1`th time.
-            auto perm = xtl::make_sequence<S>(dim, src_norm);
+            auto perm = xtl::make_sequence<S>(dim, static_cast<id_t>(src_norm));
             id_t perm_idx = 0;
             for (id_t i = 0; xtl::cmp_less(i, dim); ++i)
             {
-                if (xtl::cmp_equal(perm_idx, dest_norm))
+                if (xtl::cmp_equal(static_cast<std::size_t>(perm_idx), dest_norm))
                 {
-                    perm[perm_idx] = src_norm;
+                    perm[static_cast<std::size_t>(perm_idx)] = static_cast<id_t>(src_norm);
                     ++perm_idx;
                 }
-                if (xtl::cmp_not_equal(i, src_norm))
+                if (xtl::cmp_not_equal(static_cast<std::size_t>(i), src_norm))
                 {
-                    perm[perm_idx] = i;
+                    perm[static_cast<std::size_t>(perm_idx)] = i;
                     ++perm_idx;
                 }
             }

include/xtensor/misc/xsort.hpp

@@ -77,7 +77,7 @@ namespace xt
         {
             XTENSOR_ASSERT(ev.dimension() >= 2);
 
-            const std::size_t n_iters = leading_axis_n_iters(ev);
+            const auto n_iters = as_signed(leading_axis_n_iters(ev));
             const std::ptrdiff_t secondary_stride = get_secondary_stride(ev);
 
             const auto begin = ev.data();
@@ -94,7 +94,7 @@ namespace xt
             XTENSOR_ASSERT(e1.dimension() >= 2);
             XTENSOR_ASSERT(e1.dimension() == e2.dimension());
 
-            const std::size_t n_iters = leading_axis_n_iters(e1);
+            const auto n_iters = as_signed(leading_axis_n_iters(e1));
             const std::ptrdiff_t secondary_stride1 = get_secondary_stride(e1);
             const std::ptrdiff_t secondary_stride2 = get_secondary_stride(e2);
             XTENSOR_ASSERT(secondary_stride1 == secondary_stride2);
@@ -294,7 +294,7 @@ namespace xt
         template <class ConstRandomIt, class RandomIt, class Compare, class Method>
         inline void argsort_iter(
             ConstRandomIt data_begin,
-            ConstRandomIt data_end,
+            [[maybe_unused]] ConstRandomIt data_end,
             RandomIt idx_begin,
             RandomIt idx_end,
             Compare comp,
@@ -315,7 +315,7 @@ namespace xt
                         idx_end,
                         [&](const auto i, const auto j)
                         {
-                            return comp(*(data_begin + i), *(data_begin + j));
+                            return comp(*(data_begin + as_signed(i)), *(data_begin + as_signed(j)));
                         }
                     );
                 }
@@ -326,7 +326,7 @@ namespace xt
                         idx_end,
                         [&](const auto i, const auto j)
                         {
-                            return comp(*(data_begin + i), *(data_begin + j));
+                            return comp(*(data_begin + as_signed(i)), *(data_begin + as_signed(j)));
                         }
                     );
                 }
@@ -784,7 +784,7 @@ namespace xt
                 for (auto i : indices)
                 {
                     auto idx = current_index;
-                    idx[current_dim] = i;
+                    idx[current_dim] = as_signed(i);
                     select_indices_impl(shape, indices, axis, current_dim + 1, idx, out);
                 }
             }
@@ -793,7 +793,7 @@ namespace xt
                 for (id_t i = 0; xtl::cmp_less(i, shape[current_dim]); ++i)
                 {
                     auto idx = current_index;
-                    idx[current_dim] = i;
+                    idx[current_dim] = as_signed(i);
                     select_indices_impl(shape, indices, axis, current_dim + 1, idx, out);
                 }
             }
@@ -802,7 +802,7 @@ namespace xt
                 for (auto i : indices)
                 {
                     auto idx = current_index;
-                    idx[current_dim] = i;
+                    idx[current_dim] = as_signed(i);
                     out.push_back(std::move(idx));
                 }
             }
@@ -811,7 +811,7 @@ namespace xt
                 for (id_t i = 0; xtl::cmp_less(i, shape[current_dim]); ++i)
                 {
                     auto idx = current_index;
-                    idx[current_dim] = i;
+                    idx[current_dim] = as_signed(i);
                     out.push_back(std::move(idx));
                 }
             }
@@ -834,7 +834,7 @@ namespace xt
             const std::size_t ax = normalize_axis(e.dimension(), axis);
             using shape_t = get_strides_t<typename std::decay_t<E>::shape_type>;
             auto shape = xtl::forward_sequence<shape_t, decltype(e.shape())>(e.shape());
-            shape[ax] = indices.size();
+            shape[ax] = as_signed(indices.size());
             return reshape_view(
                 index_view(std::forward<E>(e), select_indices(e.shape(), indices, ax)),
                 std::move(shape)
@@ -915,12 +915,12 @@ namespace xt
         auto kth_gamma = detail::quantile_kth_gamma<T, id_t, P>(n, probas, alpha, beta);
 
         // Select relevant values for computing interpolating quantiles
-        auto e_partition = xt::partition(std::forward<E>(e), kth_gamma.first, ax);
-        auto e_kth = detail::fancy_indexing(std::move(e_partition), std::move(kth_gamma.first), ax);
+        auto e_partition = xt::partition(std::forward<E>(e), kth_gamma.first, as_signed(ax));
+        auto e_kth = detail::fancy_indexing(std::move(e_partition), std::move(kth_gamma.first), as_signed(ax));
 
         // Reshape interpolation coefficients
         auto gm1_g_shape = xtl::make_sequence<tmp_shape_t>(e.dimension(), 1);
-        gm1_g_shape[ax] = kth_gamma.second.size();
+        gm1_g_shape[ax] = as_signed(kth_gamma.second.size());
         auto gm1_g_reshaped = reshape_view(std::move(kth_gamma.second), std::move(gm1_g_shape));
 
         // Compute interpolation
@@ -930,9 +930,9 @@ namespace xt
         auto e_kth_g_shape = detail::unsqueeze_shape(e_kth_g.shape(), ax);
         e_kth_g_shape[ax] = 2;
         e_kth_g_shape[ax + 1] /= 2;
-        auto quantiles = xt::sum(reshape_view(std::move(e_kth_g), std::move(e_kth_g_shape)), ax);
+        auto quantiles = xt::sum(reshape_view(std::move(e_kth_g), std::move(e_kth_g_shape)), as_signed(ax));
         // Cannot do a transpose on a non-strided expression so we have to eval
-        return moveaxis(eval(std::move(quantiles)), ax, 0);
+        return moveaxis(eval(std::move(quantiles)), as_signed(ax), 0);
     }
 
     // Static proba array overload

include/xtensor/utils/xutils.hpp

@@ -1050,6 +1050,25 @@ namespace xt
     template <class E, size_t N>
     using has_rank_t = typename has_rank<std::decay_t<E>, N>::type;
 
+    /*************
+     * as_signed *
+     *************/
+
+    template <class T>
+    std::make_signed_t<T> as_signed(T t)
+    {
+        return static_cast<std::make_signed_t<T>>(t);
+    }
+
+    /***************
+     * as_unsigned *
+     ***************/
+
+    template <class T>
+    std::make_unsigned_t<T> as_unsigned(T t)
+    {
+        return static_cast<std::make_unsigned_t<T>>(t);
+    }
 }
 
 #endif

include/xtensor/views/index_mapper.hpp

@@ -11,6 +11,7 @@
 #define XTENSOR_INDEX_MAPPER_HPP
 
 #include "xview.hpp"
+#include "../utils/xutils.hpp"
 
 namespace xt
 {
@@ -400,8 +401,8 @@ namespace xt
     {
         constexpr size_t n_indices_full = n_indices_full_v<FirstIndice, OtherIndices...>;
 
-        constexpr size_t underlying_n_dimensions = xt::static_dimension<
-            typename std::decay_t<UnderlyingContainer>::shape_type>::value;
+        constexpr auto underlying_n_dimensions = as_unsigned(xt::static_dimension<
+            typename std::decay_t<UnderlyingContainer>::shape_type>::value);
 
         // If there is too many indices, we need to drop the first ones.
         // If the number of dimensions of the underlying container is known at compile time we can drop them
@@ -511,12 +512,12 @@ namespace xt
             if constexpr (std::is_integral_v<current_slice>)
             {
                 assert(i == 0);
-                return size_t(slice);
+                return as_unsigned(slice);
             }
             else
             {
                 assert(i < slice.size());
-                return size_t(slice(i));
+                return as_unsigned(slice(as_signed(i)));
             }
         }
         else

include/xtensor/views/xindex_view.hpp

@@ -511,7 +511,7 @@ namespace xt
     template <class It>
     inline auto xindex_view<CT, I>::element(It first, It /*last*/) -> reference
     {
-        return m_e[m_indices[(*first)]];
+        return m_e[m_indices[as_unsigned(*first)]];
     }
 
     /**
@@ -523,7 +523,7 @@ namespace xt
     template <class It>
     inline auto xindex_view<CT, I>::element(It first, It /*last*/) const -> const_reference
     {
-        return m_e[m_indices[(*first)]];
+        return m_e[m_indices[as_unsigned(*first)]];
     }
 
     /**