Simplify iterators usage in weighted choice

Author: AntoinePrv

include/xtensor/xrandom.hpp

@@ -849,15 +849,13 @@ namespace xt
                 // Sample u uniformly in the range [0, sum(weights)[
                 // The index idx of the sampled element is such that weight_cumul[idx - 1] <= u < weight_cumul[idx].
                 // Where weight_cumul[-1] is implicitly 0, as the empty sum.
-                const auto weight_cumul = eval(cumsum(dweights));
-                const auto weight_cumul_begin = weight_cumul.storage().begin();
-                std::uniform_real_distribution<weight_type> weight_dist{0, weight_cumul[weight_cumul.size() - 1]};
+                const auto wc = eval(cumsum(dweights));
+                std::uniform_real_distribution<weight_type> weight_dist{0, wc[wc.size() - 1]};
                 for(auto& x : result)
                 {
                     const auto u = weight_dist(engine);
-                    const auto idx_iter = std::upper_bound(weight_cumul_begin, weight_cumul.storage().end(), u);
-                    const auto idx = static_cast<size_type>(idx_iter - weight_cumul_begin);
-                    x = de.storage()[idx];
+                    const auto idx = static_cast<size_type>(std::upper_bound(wc.cbegin(), wc.cend(), u) - wc.cbegin());
+                    x = de[idx];
                 }
 
             }
@@ -867,12 +865,12 @@ namespace xt
                 xtensor<weight_type, 1> keys;
                 keys.resize({dweights.size()});
                 std::exponential_distribution<weight_type> randexp{weight_type(1)};
-                std::transform(dweights.storage().begin(), dweights.storage().end(), keys.begin(),
+                std::transform(dweights.cbegin(), dweights.cend(), keys.begin(),
                                [&randexp, &engine](auto w){ return w / randexp(engine); });
 
                 // Find indexes for the n biggest key
                 xtensor<size_type, 1> indices = arange<size_type>(0, dweights.size());
-                std::partial_sort(indices.storage().begin(), indices.storage().begin() + n, indices.storage().end(),
+                std::partial_sort(indices.begin(), indices.begin() + n, indices.end(),
                                   [&keys](auto i, auto j) { return keys[i] > keys[j]; });
 
                 // Return samples with the n biggest keys