Replace XTENSOR_THROW with XTENSOR_ASSERT in xt::random::choice

Author: AntoinePrv

include/xtensor/xrandom.hpp

@@ -767,14 +767,8 @@ namespace xt
         xtensor<typename T::value_type, 1> choice(const xexpression<T>& e, std::size_t n, bool replace, E& engine)
         {
             const auto& de = e.derived_cast();
-            if (de.dimension() != 1)
-            {
-                XTENSOR_THROW(std::runtime_error, "Sample expression must be 1 dimensional");
-            }
-            if (de.size() < n && !replace)
-            {
-                XTENSOR_THROW(std::runtime_error, "If replace is false, then the sample expression's size must be > n");
-            }
+            XTENSOR_ASSERT((de.dimension() == 1));
+            XTENSOR_ASSERT((replace || n <= de.size()));
             using result_type = xtensor<typename T::value_type, 1>;
             using size_type = typename result_type::size_type;
             result_type result;
@@ -837,18 +831,10 @@ namespace xt
         {
             const auto& de = e.derived_cast();
             const auto& dweights = weights.derived_cast();
-            if (de.dimension() != 1)
-            {
-                XTENSOR_THROW(std::runtime_error, "Sample and weight expression must be 1 dimensional");
-            }
-            if (de.size() < n && !replace)
-            {
-                XTENSOR_THROW(std::runtime_error, "If replace is false, then the sample expression's size must be > n");
-            }
-            if (de.size() != dweights.size() || de.dimension() != dweights.dimension())
-            {
-                XTENSOR_THROW(std::runtime_error, "Sample and weight expression must have the same size");
-            }
+            XTENSOR_ASSERT((de.dimension() == 1));
+            XTENSOR_ASSERT((replace || n <= de.size()));
+            XTENSOR_ASSERT((de.size() == dweights.size()));
+            XTENSOR_ASSERT((de.dimension() == dweights.dimension()));
             XTENSOR_ASSERT(xt::all(dweights >= 0));
             static_assert(std::is_floating_point<typename W::value_type>::value,
                           "Weight expression must be of floating point type");

test/test_xrandom.cpp

@@ -161,13 +161,6 @@ namespace xt
         auto acr3 = xt::random::choice(a, 5, true);
         ASSERT_EQ(acr1, acr3);
         ASSERT_NE(acr1, acr2);
-
-        xarray<double> b = {-1, 1};
-        xt::random::seed(42);
-        XT_ASSERT_THROW(xt::random::choice(b, 5, false), std::runtime_error);
-        XT_ASSERT_NO_THROW(xt::random::choice(b, 5, true));
-        xarray<double> multidim_input = { {1,2,3}, {3,4,5} };
-        XT_ASSERT_THROW(xt::random::choice(multidim_input, 5, true), std::runtime_error);
     }
 
     TEST(xrandom, weighted_choice)
@@ -188,16 +181,6 @@ namespace xt
             ASSERT_TRUE(all(isin(ac1, a)));
             ASSERT_TRUE(all(equal(ac1 % 2, 1)));
         }
-
-        xarray<double> b = {-1, 1};
-        xarray<double> v = {1, 1};
-        xt::random::seed(42);
-        XT_ASSERT_THROW(xt::random::choice(b, 5, v, false), std::runtime_error);
-        XT_ASSERT_NO_THROW(xt::random::choice(b, 5, v, true));
-        xarray<double> multidim_input = { {1,2,3}, {3,4,5} };
-        XT_ASSERT_THROW(xt::random::choice(multidim_input, 5, v, true), std::runtime_error);
-        xarray<double> bad_count_weights = {1, 1, 4};
-        XT_ASSERT_THROW(xt::random::choice(b, 5, bad_count_weights, true), std::runtime_error);
     }
 
     TEST(xrandom, shuffle)