projects / platform / upstream / boost.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Imported Upstream version 1.72.0
[platform/upstream/boost.git] / libs / math / test / univariate_statistics_test.cpp
diff --git a/libs/math/test/univariate_statistics_test.cpp b/libs/math/test/univariate_statistics_test.cpp
index 181da01..5cee988 100644 (file)
--- a/libs/math/test/univariate_statistics_test.cpp
+++ b/libs/math/test/univariate_statistics_test.cpp
@@ -13,7 +13,7 @@
 #include <boost/core/lightweight_test.hpp>
 #include <boost/numeric/ublas/vector.hpp>
 #include <boost/math/constants/constants.hpp>
-#include <boost/math/tools/univariate_statistics.hpp>
+#include <boost/math/statistics/univariate_statistics.hpp>
 #include <boost/multiprecision/cpp_bin_float.hpp>
 #include <boost/multiprecision/cpp_complex.hpp>
 
@@ -57,7 +57,7 @@ std::vector<T> generate_random_vector(size_t size, size_t seed)
     else if constexpr (std::is_integral<T>::value)
     {
         // Rescaling by larger than 2 is UB!
-        std::uniform_int_distribution<T> dis(std::numeric_limits<T>::lowest()/2, std::numeric_limits<T>::max()/2);
+        std::uniform_int_distribution<T> dis(std::numeric_limits<T>::lowest()/2, (std::numeric_limits<T>::max)()/2);
         for (size_t i = 0; i < v.size(); ++i)
         {
          v[i] = dis(gen);
@@ -104,23 +104,23 @@ void test_integer_mean()
 {
     double tol = 100*std::numeric_limits<double>::epsilon();
     std::vector<Z> v{1,2,3,4,5};
-    double mu = boost::math::tools::mean(v);
+    double mu = boost::math::statistics::mean(v);
     BOOST_TEST(abs(mu - 3) < tol);
 
     // Work with std::array?
     std::array<Z, 5> w{1,2,3,4,5};
-    mu = boost::math::tools::mean(w);
+    mu = boost::math::statistics::mean(w);
     BOOST_TEST(abs(mu - 3) < tol);
 
     v = generate_random_vector<Z>(global_size, global_seed);
     Z scale = 2;
 
-    double m1 = scale*boost::math::tools::mean(v);
+    double m1 = scale*boost::math::statistics::mean(v);
     for (auto & x : v)
     {
         x *= scale;
     }
-    double m2 = boost::math::tools::mean(v);
+    double m2 = boost::math::statistics::mean(v);
     BOOST_TEST(abs(m1 - m2) < tol*abs(m1));
 }
 
@@ -140,29 +140,29 @@ void test_mean()
 {
     Real tol = std::numeric_limits<Real>::epsilon();
     std::vector<Real> v{1,2,3,4,5};
-    Real mu = boost::math::tools::mean(v.begin(), v.end());
+    Real mu = boost::math::statistics::mean(v.begin(), v.end());
     BOOST_TEST(abs(mu - 3) < tol);
 
     // Does range call work?
-    mu = boost::math::tools::mean(v);
+    mu = boost::math::statistics::mean(v);
     BOOST_TEST(abs(mu - 3) < tol);
 
     // Can we successfully average only part of the vector?
-    mu = boost::math::tools::mean(v.begin(), v.begin() + 3);
+    mu = boost::math::statistics::mean(v.begin(), v.begin() + 3);
     BOOST_TEST(abs(mu - 2) < tol);
 
     // Does it work when we const qualify?
-    mu = boost::math::tools::mean(v.cbegin(), v.cend());
+    mu = boost::math::statistics::mean(v.cbegin(), v.cend());
     BOOST_TEST(abs(mu - 3) < tol);
 
     // Does it work for std::array?
     std::array<Real, 7> u{1,2,3,4,5,6,7};
-    mu = boost::math::tools::mean(u.begin(), u.end());
+    mu = boost::math::statistics::mean(u.begin(), u.end());
     BOOST_TEST(abs(mu - 4) < tol);
 
     // Does it work for a forward iterator?
     std::forward_list<Real> l{1,2,3,4,5,6,7};
-    mu = boost::math::tools::mean(l.begin(), l.end());
+    mu = boost::math::statistics::mean(l.begin(), l.end());
     BOOST_TEST(abs(mu - 4) < tol);
 
     // Does it work with ublas vectors?
@@ -171,17 +171,17 @@ void test_mean()
     {
         w[i] = i+1;
     }
-    mu = boost::math::tools::mean(w.cbegin(), w.cend());
+    mu = boost::math::statistics::mean(w.cbegin(), w.cend());
     BOOST_TEST(abs(mu - 4) < tol);
 
     v = generate_random_vector<Real>(global_size, global_seed);
     Real scale = 2;
-    Real m1 = scale*boost::math::tools::mean(v);
+    Real m1 = scale*boost::math::statistics::mean(v);
     for (auto & x : v)
     {
         x *= scale;
     }
-    Real m2 = boost::math::tools::mean(v);
+    Real m2 = boost::math::statistics::mean(v);
     BOOST_TEST(abs(m1 - m2) < tol*abs(m1));
 
     // Stress test:
@@ -189,7 +189,7 @@ void test_mean()
     {
         v = generate_random_vector<Real>(i, 12803);
         auto naive_ = naive_mean(v);
-        auto higham_ = boost::math::tools::mean(v);
+        auto higham_ = boost::math::statistics::mean(v);
         if (abs(higham_ - naive_) >= 100*tol*abs(naive_))
         {
             std::cout << std::hexfloat;
@@ -208,12 +208,12 @@ void test_complex_mean()
     typedef typename Complex::value_type Real;
     Real tol = std::numeric_limits<Real>::epsilon();
     std::vector<Complex> v{{0,1},{0,2},{0,3},{0,4},{0,5}};
-    auto mu = boost::math::tools::mean(v.begin(), v.end());
+    auto mu = boost::math::statistics::mean(v.begin(), v.end());
     BOOST_TEST(abs(mu.imag() - 3) < tol);
     BOOST_TEST(abs(mu.real()) < tol);
 
     // Does range work?
-    mu = boost::math::tools::mean(v);
+    mu = boost::math::statistics::mean(v);
     BOOST_TEST(abs(mu.imag() - 3) < tol);
     BOOST_TEST(abs(mu.real()) < tol);
 }
@@ -223,38 +223,38 @@ void test_variance()
 {
     Real tol = std::numeric_limits<Real>::epsilon();
     std::vector<Real> v{1,1,1,1,1,1};
-    Real sigma_sq = boost::math::tools::variance(v.begin(), v.end());
+    Real sigma_sq = boost::math::statistics::variance(v.begin(), v.end());
     BOOST_TEST(abs(sigma_sq) < tol);
 
-    sigma_sq = boost::math::tools::variance(v);
+    sigma_sq = boost::math::statistics::variance(v);
     BOOST_TEST(abs(sigma_sq) < tol);
 
-    Real s_sq = boost::math::tools::sample_variance(v);
+    Real s_sq = boost::math::statistics::sample_variance(v);
     BOOST_TEST(abs(s_sq) < tol);
 
     std::vector<Real> u{1};
-    sigma_sq = boost::math::tools::variance(u.cbegin(), u.cend());
+    sigma_sq = boost::math::statistics::variance(u.cbegin(), u.cend());
     BOOST_TEST(abs(sigma_sq) < tol);
 
     std::array<Real, 8> w{0,1,0,1,0,1,0,1};
-    sigma_sq = boost::math::tools::variance(w.begin(), w.end());
+    sigma_sq = boost::math::statistics::variance(w.begin(), w.end());
     BOOST_TEST(abs(sigma_sq - 1.0/4.0) < tol);
 
-    sigma_sq = boost::math::tools::variance(w);
+    sigma_sq = boost::math::statistics::variance(w);
     BOOST_TEST(abs(sigma_sq - 1.0/4.0) < tol);
 
     std::forward_list<Real> l{0,1,0,1,0,1,0,1};
-    sigma_sq = boost::math::tools::variance(l.begin(), l.end());
+    sigma_sq = boost::math::statistics::variance(l.begin(), l.end());
     BOOST_TEST(abs(sigma_sq - 1.0/4.0) < tol);
 
     v = generate_random_vector<Real>(global_size, global_seed);
     Real scale = 2;
-    Real m1 = scale*scale*boost::math::tools::variance(v);
+    Real m1 = scale*scale*boost::math::statistics::variance(v);
     for (auto & x : v)
     {
         x *= scale;
     }
-    Real m2 = boost::math::tools::variance(v);
+    Real m2 = boost::math::statistics::variance(v);
     BOOST_TEST(abs(m1 - m2) < tol*abs(m1));
 
     // Wikipedia example for a variance of N sided die:
@@ -268,7 +268,7 @@ void test_variance()
             v[i] = i + 1;
         }
 
-        sigma_sq = boost::math::tools::variance(v);
+        sigma_sq = boost::math::statistics::variance(v);
 
         BOOST_TEST(abs(sigma_sq - (n*n-1)/Real(12)) <= tol*sigma_sq);
     }
@@ -280,21 +280,21 @@ void test_integer_variance()
 {
     double tol = std::numeric_limits<double>::epsilon();
     std::vector<Z> v{1,1,1,1,1,1};
-    double sigma_sq = boost::math::tools::variance(v);
+    double sigma_sq = boost::math::statistics::variance(v);
     BOOST_TEST(abs(sigma_sq) < tol);
 
     std::forward_list<Z> l{0,1,0,1,0,1,0,1};
-    sigma_sq = boost::math::tools::variance(l.begin(), l.end());
+    sigma_sq = boost::math::statistics::variance(l.begin(), l.end());
     BOOST_TEST(abs(sigma_sq - 1.0/4.0) < tol);
 
     v = generate_random_vector<Z>(global_size, global_seed);
     Z scale = 2;
-    double m1 = scale*scale*boost::math::tools::variance(v);
+    double m1 = scale*scale*boost::math::statistics::variance(v);
     for (auto & x : v)
     {
         x *= scale;
     }
-    double m2 = boost::math::tools::variance(v);
+    double m2 = boost::math::statistics::variance(v);
     BOOST_TEST(abs(m1 - m2) < tol*abs(m1));
 }
 
@@ -303,32 +303,32 @@ void test_integer_skewness()
 {
     double tol = std::numeric_limits<double>::epsilon();
     std::vector<Z> v{1,1,1};
-    double skew = boost::math::tools::skewness(v);
+    double skew = boost::math::statistics::skewness(v);
     BOOST_TEST(abs(skew) < tol);
 
     // Dataset is symmetric about the mean:
     v = {1,2,3,4,5};
-    skew = boost::math::tools::skewness(v);
+    skew = boost::math::statistics::skewness(v);
     BOOST_TEST(abs(skew) < tol);
 
     v = {0,0,0,0,5};
     // mu = 1, sigma^2 = 4, sigma = 2, skew = 3/2
-    skew = boost::math::tools::skewness(v);
+    skew = boost::math::statistics::skewness(v);
     BOOST_TEST(abs(skew - 3.0/2.0) < tol);
 
     std::forward_list<Z> v2{0,0,0,0,5};
-    skew = boost::math::tools::skewness(v);
+    skew = boost::math::statistics::skewness(v);
     BOOST_TEST(abs(skew - 3.0/2.0) < tol);
 
 
     v = generate_random_vector<Z>(global_size, global_seed);
     Z scale = 2;
-    double m1 = boost::math::tools::skewness(v);
+    double m1 = boost::math::statistics::skewness(v);
     for (auto & x : v)
     {
         x *= scale;
     }
-    double m2 = boost::math::tools::skewness(v);
+    double m2 = boost::math::statistics::skewness(v);
     BOOST_TEST(abs(m1 - m2) < tol*abs(m1));
 
 }
@@ -338,35 +338,35 @@ void test_skewness()
 {
     Real tol = std::numeric_limits<Real>::epsilon();
     std::vector<Real> v{1,1,1};
-    Real skew = boost::math::tools::skewness(v);
+    Real skew = boost::math::statistics::skewness(v);
     BOOST_TEST(abs(skew) < tol);
 
     // Dataset is symmetric about the mean:
     v = {1,2,3,4,5};
-    skew = boost::math::tools::skewness(v);
+    skew = boost::math::statistics::skewness(v);
     BOOST_TEST(abs(skew) < tol);
 
     v = {0,0,0,0,5};
     // mu = 1, sigma^2 = 4, sigma = 2, skew = 3/2
-    skew = boost::math::tools::skewness(v);
+    skew = boost::math::statistics::skewness(v);
     BOOST_TEST(abs(skew - Real(3)/Real(2)) < tol);
 
     std::array<Real, 5> w1{0,0,0,0,5};
-    skew = boost::math::tools::skewness(w1);
+    skew = boost::math::statistics::skewness(w1);
     BOOST_TEST(abs(skew - Real(3)/Real(2)) < tol);
 
     std::forward_list<Real> w2{0,0,0,0,5};
-    skew = boost::math::tools::skewness(w2);
+    skew = boost::math::statistics::skewness(w2);
     BOOST_TEST(abs(skew - Real(3)/Real(2)) < tol);
 
     v = generate_random_vector<Real>(global_size, global_seed);
     Real scale = 2;
-    Real m1 = boost::math::tools::skewness(v);
+    Real m1 = boost::math::statistics::skewness(v);
     for (auto & x : v)
     {
         x *= scale;
     }
-    Real m2 = boost::math::tools::skewness(v);
+    Real m2 = boost::math::statistics::skewness(v);
     BOOST_TEST(abs(m1 - m2) < tol*abs(m1));
 }
 
@@ -375,25 +375,25 @@ void test_kurtosis()
 {
     Real tol = std::numeric_limits<Real>::epsilon();
     std::vector<Real> v{1,1,1};
-    Real kurt = boost::math::tools::kurtosis(v);
+    Real kurt = boost::math::statistics::kurtosis(v);
     BOOST_TEST(abs(kurt) < tol);
 
     v = {1,2,3,4,5};
     // mu =1, sigma^2 = 2, kurtosis = 17/10
-    kurt = boost::math::tools::kurtosis(v);
+    kurt = boost::math::statistics::kurtosis(v);
     BOOST_TEST(abs(kurt - Real(17)/Real(10)) < tol);
 
     v = {0,0,0,0,5};
     // mu = 1, sigma^2 = 4, sigma = 2, skew = 3/2, kurtosis = 13/4
-    kurt = boost::math::tools::kurtosis(v);
+    kurt = boost::math::statistics::kurtosis(v);
     BOOST_TEST(abs(kurt - Real(13)/Real(4)) < tol);
 
     std::array<Real, 5> v1{0,0,0,0,5};
-    kurt = boost::math::tools::kurtosis(v1);
+    kurt = boost::math::statistics::kurtosis(v1);
     BOOST_TEST(abs(kurt - Real(13)/Real(4)) < tol);
 
     std::forward_list<Real> v2{0,0,0,0,5};
-    kurt = boost::math::tools::kurtosis(v2);
+    kurt = boost::math::statistics::kurtosis(v2);
     BOOST_TEST(abs(kurt - Real(13)/Real(4)) < tol);
 
     std::vector<Real> v3(10000);
@@ -402,24 +402,24 @@ void test_kurtosis()
     for (size_t i = 0; i < v3.size(); ++i) {
         v3[i] = dis(gen);
     }
-    kurt = boost::math::tools::kurtosis(v3);
+    kurt = boost::math::statistics::kurtosis(v3);
     BOOST_TEST(abs(kurt - 3) < 0.1);
 
     std::uniform_real_distribution<long double> udis(-1, 3);
     for (size_t i = 0; i < v3.size(); ++i) {
         v3[i] = udis(gen);
     }
-    auto excess_kurtosis = boost::math::tools::excess_kurtosis(v3);
+    auto excess_kurtosis = boost::math::statistics::excess_kurtosis(v3);
     BOOST_TEST(abs(excess_kurtosis + 6.0/5.0) < 0.2);
 
     v = generate_random_vector<Real>(global_size, global_seed);
     Real scale = 2;
-    Real m1 = boost::math::tools::kurtosis(v);
+    Real m1 = boost::math::statistics::kurtosis(v);
     for (auto & x : v)
     {
         x *= scale;
     }
-    Real m2 = boost::math::tools::kurtosis(v);
+    Real m2 = boost::math::statistics::kurtosis(v);
     BOOST_TEST(abs(m1 - m2) < tol*abs(m1));
 
     // This test only passes when there are a large number of samples.
@@ -432,7 +432,7 @@ void test_kurtosis()
     //for (size_t i = 0; i < v3.size(); ++i) {
     //    v3[i] = edis(gen);
     //}
-    //excess_kurtosis = boost::math::tools::kurtosis(v3) - 3;
+    //excess_kurtosis = boost::math::statistics::kurtosis(v3) - 3;
     //BOOST_TEST(abs(excess_kurtosis - 6.0) < 0.2);
 }
 
@@ -441,27 +441,27 @@ void test_integer_kurtosis()
 {
     double tol = std::numeric_limits<double>::epsilon();
     std::vector<Z> v{1,1,1};
-    double kurt = boost::math::tools::kurtosis(v);
+    double kurt = boost::math::statistics::kurtosis(v);
     BOOST_TEST(abs(kurt) < tol);
 
     v = {1,2,3,4,5};
     // mu =1, sigma^2 = 2, kurtosis = 17/10
-    kurt = boost::math::tools::kurtosis(v);
+    kurt = boost::math::statistics::kurtosis(v);
     BOOST_TEST(abs(kurt - 17.0/10.0) < tol);
 
     v = {0,0,0,0,5};
     // mu = 1, sigma^2 = 4, sigma = 2, skew = 3/2, kurtosis = 13/4
-    kurt = boost::math::tools::kurtosis(v);
+    kurt = boost::math::statistics::kurtosis(v);
     BOOST_TEST(abs(kurt - 13.0/4.0) < tol);
 
     v = generate_random_vector<Z>(global_size, global_seed);
     Z scale = 2;
-    double m1 = boost::math::tools::kurtosis(v);
+    double m1 = boost::math::statistics::kurtosis(v);
     for (auto & x : v)
     {
         x *= scale;
     }
-    double m2 = boost::math::tools::kurtosis(v);
+    double m2 = boost::math::statistics::kurtosis(v);
     BOOST_TEST(abs(m1 - m2) < tol*abs(m1));
 }
 
@@ -470,14 +470,14 @@ void test_first_four_moments()
 {
     Real tol = 10*std::numeric_limits<Real>::epsilon();
     std::vector<Real> v{1,1,1};
-    auto [M1_1, M2_1, M3_1, M4_1] = boost::math::tools::first_four_moments(v);
+    auto [M1_1, M2_1, M3_1, M4_1] = boost::math::statistics::first_four_moments(v);
     BOOST_TEST(abs(M1_1 - 1) < tol);
     BOOST_TEST(abs(M2_1) < tol);
     BOOST_TEST(abs(M3_1) < tol);
     BOOST_TEST(abs(M4_1) < tol);
 
     v = {1, 2, 3, 4, 5};
-    auto [M1_2, M2_2, M3_2, M4_2] = boost::math::tools::first_four_moments(v);
+    auto [M1_2, M2_2, M3_2, M4_2] = boost::math::statistics::first_four_moments(v);
     BOOST_TEST(abs(M1_2 - 3) < tol);
     BOOST_TEST(abs(M2_2 - 2) < tol);
     BOOST_TEST(abs(M3_2) < tol);
@@ -490,47 +490,47 @@ void test_median()
     std::mt19937 g(12);
     std::vector<Real> v{1,2,3,4,5,6,7};
 
-    Real m = boost::math::tools::median(v.begin(), v.end());
+    Real m = boost::math::statistics::median(v.begin(), v.end());
     BOOST_TEST_EQ(m, 4);
 
     std::shuffle(v.begin(), v.end(), g);
     // Does range call work?
-    m = boost::math::tools::median(v);
+    m = boost::math::statistics::median(v);
     BOOST_TEST_EQ(m, 4);
 
     v = {1,2,3,3,4,5};
-    m = boost::math::tools::median(v.begin(), v.end());
+    m = boost::math::statistics::median(v.begin(), v.end());
     BOOST_TEST_EQ(m, 3);
     std::shuffle(v.begin(), v.end(), g);
-    m = boost::math::tools::median(v.begin(), v.end());
+    m = boost::math::statistics::median(v.begin(), v.end());
     BOOST_TEST_EQ(m, 3);
 
     v = {1};
-    m = boost::math::tools::median(v.begin(), v.end());
+    m = boost::math::statistics::median(v.begin(), v.end());
     BOOST_TEST_EQ(m, 1);
 
     v = {1,1};
-    m = boost::math::tools::median(v.begin(), v.end());
+    m = boost::math::statistics::median(v.begin(), v.end());
     BOOST_TEST_EQ(m, 1);
 
     v = {2,4};
-    m = boost::math::tools::median(v.begin(), v.end());
+    m = boost::math::statistics::median(v.begin(), v.end());
     BOOST_TEST_EQ(m, 3);
 
     v = {1,1,1};
-    m = boost::math::tools::median(v.begin(), v.end());
+    m = boost::math::statistics::median(v.begin(), v.end());
     BOOST_TEST_EQ(m, 1);
 
     v = {1,2,3};
-    m = boost::math::tools::median(v.begin(), v.end());
+    m = boost::math::statistics::median(v.begin(), v.end());
     BOOST_TEST_EQ(m, 2);
     std::shuffle(v.begin(), v.end(), g);
-    m = boost::math::tools::median(v.begin(), v.end());
+    m = boost::math::statistics::median(v.begin(), v.end());
     BOOST_TEST_EQ(m, 2);
 
     // Does it work with std::array?
     std::array<Real, 3> w{1,2,3};
-    m = boost::math::tools::median(w);
+    m = boost::math::statistics::median(w);
     BOOST_TEST_EQ(m, 2);
 
     // Does it work with ublas?
@@ -538,7 +538,7 @@ void test_median()
     w1[0] = 1;
     w1[1] = 2;
     w1[2] = 3;
-    m = boost::math::tools::median(w);
+    m = boost::math::statistics::median(w);
     BOOST_TEST_EQ(m, 2);
 }
 
@@ -547,53 +547,53 @@ void test_median_absolute_deviation()
 {
     std::vector<Real> v{-1, 2, -3, 4, -5, 6, -7};
 
-    Real m = boost::math::tools::median_absolute_deviation(v.begin(), v.end(), 0);
+    Real m = boost::math::statistics::median_absolute_deviation(v.begin(), v.end(), 0);
     BOOST_TEST_EQ(m, 4);
 
     std::mt19937 g(12);
     std::shuffle(v.begin(), v.end(), g);
-    m = boost::math::tools::median_absolute_deviation(v, 0);
+    m = boost::math::statistics::median_absolute_deviation(v, 0);
     BOOST_TEST_EQ(m, 4);
 
     v = {1, -2, -3, 3, -4, -5};
-    m = boost::math::tools::median_absolute_deviation(v.begin(), v.end(), 0);
+    m = boost::math::statistics::median_absolute_deviation(v.begin(), v.end(), 0);
     BOOST_TEST_EQ(m, 3);
     std::shuffle(v.begin(), v.end(), g);
-    m = boost::math::tools::median_absolute_deviation(v.begin(), v.end(), 0);
+    m = boost::math::statistics::median_absolute_deviation(v.begin(), v.end(), 0);
     BOOST_TEST_EQ(m, 3);
 
     v = {-1};
-    m = boost::math::tools::median_absolute_deviation(v.begin(), v.end(), 0);
+    m = boost::math::statistics::median_absolute_deviation(v.begin(), v.end(), 0);
     BOOST_TEST_EQ(m, 1);
 
     v = {-1, 1};
-    m = boost::math::tools::median_absolute_deviation(v.begin(), v.end(), 0);
+    m = boost::math::statistics::median_absolute_deviation(v.begin(), v.end(), 0);
     BOOST_TEST_EQ(m, 1);
     // The median is zero, so coincides with the default:
-    m = boost::math::tools::median_absolute_deviation(v.begin(), v.end());
+    m = boost::math::statistics::median_absolute_deviation(v.begin(), v.end());
     BOOST_TEST_EQ(m, 1);
 
-    m = boost::math::tools::median_absolute_deviation(v);
+    m = boost::math::statistics::median_absolute_deviation(v);
     BOOST_TEST_EQ(m, 1);
 
 
     v = {2, -4};
-    m = boost::math::tools::median_absolute_deviation(v.begin(), v.end(), 0);
+    m = boost::math::statistics::median_absolute_deviation(v.begin(), v.end(), 0);
     BOOST_TEST_EQ(m, 3);
 
     v = {1, -1, 1};
-    m = boost::math::tools::median_absolute_deviation(v.begin(), v.end(), 0);
+    m = boost::math::statistics::median_absolute_deviation(v.begin(), v.end(), 0);
     BOOST_TEST_EQ(m, 1);
 
     v = {1, 2, -3};
-    m = boost::math::tools::median_absolute_deviation(v.begin(), v.end(), 0);
+    m = boost::math::statistics::median_absolute_deviation(v.begin(), v.end(), 0);
     BOOST_TEST_EQ(m, 2);
     std::shuffle(v.begin(), v.end(), g);
-    m = boost::math::tools::median_absolute_deviation(v.begin(), v.end(), 0);
+    m = boost::math::statistics::median_absolute_deviation(v.begin(), v.end(), 0);
     BOOST_TEST_EQ(m, 2);
 
     std::array<Real, 3> w{1, 2, -3};
-    m = boost::math::tools::median_absolute_deviation(w, 0);
+    m = boost::math::statistics::median_absolute_deviation(w, 0);
     BOOST_TEST_EQ(m, 2);
 
     // boost.ublas vector?
@@ -604,7 +604,7 @@ void test_median_absolute_deviation()
     u[3] = 1;
     u[4] = 2;
     u[5] = -3;
-    m = boost::math::tools::median_absolute_deviation(u, 0);
+    m = boost::math::statistics::median_absolute_deviation(u, 0);
     BOOST_TEST_EQ(m, 2);
 }
 
@@ -614,26 +614,26 @@ void test_sample_gini_coefficient()
 {
     Real tol = std::numeric_limits<Real>::epsilon();
     std::vector<Real> v{1,0,0};
-    Real gini = boost::math::tools::sample_gini_coefficient(v.begin(), v.end());
+    Real gini = boost::math::statistics::sample_gini_coefficient(v.begin(), v.end());
     BOOST_TEST(abs(gini - 1) < tol);
 
-    gini = boost::math::tools::sample_gini_coefficient(v);
+    gini = boost::math::statistics::sample_gini_coefficient(v);
     BOOST_TEST(abs(gini - 1) < tol);
 
     v[0] = 1;
     v[1] = 1;
     v[2] = 1;
-    gini = boost::math::tools::sample_gini_coefficient(v.begin(), v.end());
+    gini = boost::math::statistics::sample_gini_coefficient(v.begin(), v.end());
     BOOST_TEST(abs(gini) < tol);
 
     v[0] = 0;
     v[1] = 0;
     v[2] = 0;
-    gini = boost::math::tools::sample_gini_coefficient(v.begin(), v.end());
+    gini = boost::math::statistics::sample_gini_coefficient(v.begin(), v.end());
     BOOST_TEST(abs(gini) < tol);
 
     std::array<Real, 3> w{0,0,0};
-    gini = boost::math::tools::sample_gini_coefficient(w);
+    gini = boost::math::statistics::sample_gini_coefficient(w);
     BOOST_TEST(abs(gini) < tol);
 }
 
@@ -643,34 +643,34 @@ void test_gini_coefficient()
 {
     Real tol = std::numeric_limits<Real>::epsilon();
     std::vector<Real> v{1,0,0};
-    Real gini = boost::math::tools::gini_coefficient(v.begin(), v.end());
+    Real gini = boost::math::statistics::gini_coefficient(v.begin(), v.end());
     Real expected = Real(2)/Real(3);
     BOOST_TEST(abs(gini - expected) < tol);
 
-    gini = boost::math::tools::gini_coefficient(v);
+    gini = boost::math::statistics::gini_coefficient(v);
     BOOST_TEST(abs(gini - expected) < tol);
 
     v[0] = 1;
     v[1] = 1;
     v[2] = 1;
-    gini = boost::math::tools::gini_coefficient(v.begin(), v.end());
+    gini = boost::math::statistics::gini_coefficient(v.begin(), v.end());
     BOOST_TEST(abs(gini) < tol);
 
     v[0] = 0;
     v[1] = 0;
     v[2] = 0;
-    gini = boost::math::tools::gini_coefficient(v.begin(), v.end());
+    gini = boost::math::statistics::gini_coefficient(v.begin(), v.end());
     BOOST_TEST(abs(gini) < tol);
 
     std::array<Real, 3> w{0,0,0};
-    gini = boost::math::tools::gini_coefficient(w);
+    gini = boost::math::statistics::gini_coefficient(w);
     BOOST_TEST(abs(gini) < tol);
 
     boost::numeric::ublas::vector<Real> w1(3);
     w1[0] = 1;
     w1[1] = 1;
     w1[2] = 1;
-    gini = boost::math::tools::gini_coefficient(w1);
+    gini = boost::math::statistics::gini_coefficient(w1);
     BOOST_TEST(abs(gini) < tol);
 
     std::mt19937 gen(18);
@@ -682,7 +682,7 @@ void test_gini_coefficient()
     {
         v[i] = dis(gen);
     }
-    gini = boost::math::tools::gini_coefficient(v);
+    gini = boost::math::statistics::gini_coefficient(v);
     BOOST_TEST(abs(gini - expected) < 0.01);
 
 }
@@ -692,34 +692,34 @@ void test_integer_gini_coefficient()
 {
     double tol = std::numeric_limits<double>::epsilon();
     std::vector<Z> v{1,0,0};
-    double gini = boost::math::tools::gini_coefficient(v.begin(), v.end());
+    double gini = boost::math::statistics::gini_coefficient(v.begin(), v.end());
     double expected = 2.0/3.0;
     BOOST_TEST(abs(gini - expected) < tol);
 
-    gini = boost::math::tools::gini_coefficient(v);
+    gini = boost::math::statistics::gini_coefficient(v);
     BOOST_TEST(abs(gini - expected) < tol);
 
     v[0] = 1;
     v[1] = 1;
     v[2] = 1;
-    gini = boost::math::tools::gini_coefficient(v.begin(), v.end());
+    gini = boost::math::statistics::gini_coefficient(v.begin(), v.end());
     BOOST_TEST(abs(gini) < tol);
 
     v[0] = 0;
     v[1] = 0;
     v[2] = 0;
-    gini = boost::math::tools::gini_coefficient(v.begin(), v.end());
+    gini = boost::math::statistics::gini_coefficient(v.begin(), v.end());
     BOOST_TEST(abs(gini) < tol);
 
     std::array<Z, 3> w{0,0,0};
-    gini = boost::math::tools::gini_coefficient(w);
+    gini = boost::math::statistics::gini_coefficient(w);
     BOOST_TEST(abs(gini) < tol);
 
     boost::numeric::ublas::vector<Z> w1(3);
     w1[0] = 1;
     w1[1] = 1;
     w1[2] = 1;
-    gini = boost::math::tools::gini_coefficient(w1);
+    gini = boost::math::statistics::gini_coefficient(w1);
     BOOST_TEST(abs(gini) < tol);
 }
 
Domain: System / Base;