[libcxx] [test] Avoid huge main() functions and huge arrays.

[STL_MSFT]

Summary

Avoid huge main() functions and huge arrays.

Fixes MSVC warning C6262 "Function uses '62000' bytes of stack: exceeds /analyze:stacksize '16384'. Consider moving some data to heap."

Several random distribution tests featured huge main() functions. Even though they have artificial blocks in order to keep variables locally scoped, this gives MSVC's /analyze a headache, because it views main() as consuming an enormous amount of stack space (it doesn't reuse stack, at least for analysis). Splitting main() up into numbered test functions is slightly friendlier to humans and massively friendlier to /analyze.

Additionally, is_swappable_include_order.pass.cpp had a busted comment, and a 42 * 50 multidim array of doubles (actually two of them). That's a lot of stack space: 42 * 50 * 8 * 2 = 33600. As the actual size isn't important, I've reduced this to 17 by 29, which fits comfortably within /analyze's default stack (7888 bytes is less than 16K).

[bcraig]

Even though they have artificial blocks in order to keep variables locally scoped, this gives MSVC's /analyze a headache, because it views main() as consuming an enormous amount of stack space (it doesn't reuse stack, at least for analysis). Splitting main() up into numbered test functions is slightly friendlier to humans and massively friendlier to /analyze.

The optimizer tends to not reuse the stack space either, at least for Clang 3.8, MSVC 2010 (I know, ancient history), and various older GCCs. I'm not sure if modern GCCs or MSVCs do a better job of shrinking stacks when this scoping pattern is used, or when lots of statement-lifetime temporaries are involved. Both patterns have caused me considerable grief on small stack systems.

You may want to look at test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_long_double.pass.cpp and test/std/localization/locale.categories/category.numeric/locale.nm.put/facet.num.put.members/put_double.pass.cpp. They involve giant functions with lots of scoping, and they have both caused me stack pain that I haven't specifically tried to solve yet.

[bcraig]

LGTM. I don't see anything controversial here. If you want to wait for @EricWF or @mclow.lists though, that's fine.

[STL_MSFT]

I gotta wait for them, I don't have commit access. :-> (Nor do I need it at the moment)

Haven't encountered problems with those locale tests yet, although I'm still processing 670-ish compiletime and runtime failures.

[EricWF]

r273354.

test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp

 template <class T>
 inline
 T
 sqr(T x)
 {
     return x * x;
 }
 
-int main()
-{
-    {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        D d(5, .75);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.04);
-    }
-    {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(30, .03125);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-    }
-    {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(40, .25);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.03);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.3);
-    }
-    {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(40, 0);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        // In this case:
-        //   skew     computes to 0./0. == nan
-        //   kurtosis computes to 0./0. == nan
-        //   x_skew     == inf
-        //   x_kurtosis == inf
-        //   These tests are commented out because UBSan warns about division by 0
-//        skew /= u.size() * dev * var;
-//        kurtosis /= u.size() * var * var;
-//        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-//        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-//        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(mean == x_mean);
-        assert(var == x_var);
-//        assert(skew == x_skew);
-//        assert(kurtosis == x_kurtosis);
-    }
-    {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(40, 1);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        // In this case:
-        //   skew     computes to 0./0. == nan
-        //   kurtosis computes to 0./0. == nan
-        //   x_skew     == -inf
-        //   x_kurtosis == inf
-        //   These tests are commented out because UBSan warns about division by 0
-//        skew /= u.size() * dev * var;
-//        kurtosis /= u.size() * var * var;
-//        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-//        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-//        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(mean == x_mean);
-        assert(var == x_var);
-//        assert(skew == x_skew);
-//        assert(kurtosis == x_kurtosis);
-    }
-    {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(400, 0.5);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs(skew - x_skew) < 0.01);
-        assert(std::abs(kurtosis - x_kurtosis) < 0.01);
-    }
-    {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(1, 0.5);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs(skew - x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-    }
-    {
-        const int N = 100000;
-        std::mt19937 gen1;
-        std::mt19937 gen2;
+void
+test1()
+
+void
+test2()
+
+void
+test3()
+
+void
+test4()
+//    skew /= u.size() * dev * var;
+//    kurtosis /= u.size() * var * var;
+//    kurtosis -= 3;
+//    double x_skew = (1-2*d.p()) / std::sqrt(x_var);
+//    double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
+//    assert(skew == x_skew);
+//    assert(kurtosis == x_kurtosis);
+
+void
+test5()
+//    skew /= u.size() * dev * var;
+//    kurtosis /= u.size() * var * var;
+//    kurtosis -= 3;
+//    double x_skew = (1-2*d.p()) / std::sqrt(x_var);
+//    double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
+//    assert(skew == x_skew);
+//    assert(kurtosis == x_kurtosis);
+
+void
+test6()
+
+void
+test7()
+
+void
+test8()
 
-        std::binomial_distribution<>         dist1(5, 0.1);
-        std::binomial_distribution<unsigned> dist2(5, 0.1);
 
-        for(int i = 0; i < N; ++i)
-            assert(dist1(gen1) == dist2(gen2));
-    }
-    {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(0, 0.005);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        // In this case:
-        //   skew     computes to 0./0. == nan
-        //   kurtosis computes to 0./0. == nan
-        //   x_skew     == inf
-        //   x_kurtosis == inf
-        //   These tests are commented out because UBSan warns about division by 0
-//        skew /= u.size() * dev * var;
-//        kurtosis /= u.size() * var * var;
-//        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-//        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-//        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(mean == x_mean);
-        assert(var == x_var);
-//        assert(skew == x_skew);
-//        assert(kurtosis == x_kurtosis);
-    }
-    {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(0, 0);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        // In this case:
-        //   skew     computes to 0./0. == nan
-        //   kurtosis computes to 0./0. == nan
-        //   x_skew     == inf
-        //   x_kurtosis == inf
-        //   These tests are commented out because UBSan warns about division by 0
-//        skew /= u.size() * dev * var;
-//        kurtosis /= u.size() * var * var;
-//        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-//        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-//        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(mean == x_mean);
-        assert(var == x_var);
-//        assert(skew == x_skew);
-//        assert(kurtosis == x_kurtosis);
-    }
-    {
-        typedef std::binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(0, 1);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        // In this case:
-        //   skew     computes to 0./0. == nan
-        //   kurtosis computes to 0./0. == nan
-        //   x_skew     == -inf
-        //   x_kurtosis == inf
-        //   These tests are commented out because UBSan warns about division by 0
-//        skew /= u.size() * dev * var;
-//        kurtosis /= u.size() * var * var;
-//        kurtosis -= 3;
-        double x_mean = d.t() * d.p();
-        double x_var = x_mean*(1-d.p());
-//        double x_skew = (1-2*d.p()) / std::sqrt(x_var);
-//        double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
-        assert(mean == x_mean);
-        assert(var == x_var);
-//        assert(skew == x_skew);
-//        assert(kurtosis == x_kurtosis);
-    }
+
+void
+test9()
+//    skew /= u.size() * dev * var;
+//    kurtosis /= u.size() * var * var;
+//    kurtosis -= 3;
+//    double x_skew = (1-2*d.p()) / std::sqrt(x_var);
+//    double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
+//    assert(skew == x_skew);
+//    assert(kurtosis == x_kurtosis);
+
+void
+test10()
+//    skew /= u.size() * dev * var;
+//    kurtosis /= u.size() * var * var;
+//    kurtosis -= 3;
+//    double x_skew = (1-2*d.p()) / std::sqrt(x_var);
+//    double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
+//    assert(skew == x_skew);
+//    assert(kurtosis == x_kurtosis);
+
+void
+test11()
+//    skew /= u.size() * dev * var;
+//    kurtosis /= u.size() * var * var;
+//    kurtosis -= 3;
+//    double x_skew = (1-2*d.p()) / std::sqrt(x_var);
+//    double x_kurtosis = (1-6*d.p()*(1-d.p())) / x_var;
+//    assert(skew == x_skew);
+//    assert(kurtosis == x_kurtosis);
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
+    test5();
+    test6();
+    test7();
+    test8();
+    test9();
+    test10();
+    test11();
 }

test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.geo/eval.pass.cpp

 template <class T>
 inline
 T
 sqr(T x)
 {
     return x * x;
 }
 
-int main()
-{
-    {
-        typedef std::geometric_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(.03125);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
-        double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-    }
-    {
-        typedef std::geometric_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(0.05);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
-        double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
-    }
-    {
-        typedef std::geometric_distribution<> D;
-        typedef std::minstd_rand G;
-        G g;
-        D d(.25);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
-        double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
-    }
-    {
-        typedef std::geometric_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(0.5);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
-        double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
-    }
-    {
-        typedef std::geometric_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(0.75);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
-        double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
-    }
-    {
-        typedef std::geometric_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(0.96875);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt((1 - d.p()));
-        double x_kurtosis = 6 + sqr(d.p()) / (1 - d.p());
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
-    }
+void
+test1()
+
+void
+test2()
+
+void
+test3()
+
+void
+test4()
+
+void
+test5()
+
+void
+test6()
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
+    test5();
+    test6();
 }

test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.negbin/eval.pass.cpp

 template <class T>
 inline
 T
 sqr(T x)
 {
     return x * x;
 }
 
-int main()
-{
-    {
-        typedef std::negative_binomial_distribution<> D;
-        typedef std::minstd_rand G;
-        G g;
-        D d(5, .25);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.k() * (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
-        double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.02);
-    }
-    {
-        typedef std::negative_binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(30, .03125);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.k() * (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
-        double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-    }
-    {
-        typedef std::negative_binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(40, .25);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.k() * (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
-        double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
-    }
-    {
-        typedef std::negative_binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(40, 1);
-        const int N = 1000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.k() * (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
-        double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
-        assert(mean == x_mean);
-        assert(var == x_var);
-    }
-    {
-        typedef std::negative_binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(400, 0.5);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.k() * (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
-        double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.04);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.05);
-    }
-    {
-        typedef std::negative_binomial_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(1, 0.05);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v <= d.max());
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(),
-                                              double(0)) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.k() * (1 - d.p()) / d.p();
-        double x_var = x_mean / d.p();
-        double x_skew = (2 - d.p()) / std::sqrt(d.k() * (1 - d.p()));
-        double x_kurtosis = 6. / d.k() + sqr(d.p()) / (d.k() * (1 - d.p()));
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
-    }
+void
+test1()
+
+void
+test2()
+
+void
+test3()
+
+void
+test4()
+
+void
+test5()
+
+void
+test6()
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
+    test5();
+    test6();
 }

test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval.pass.cpp

 template <class T>
 inline
 T
 sqr(T x)
 {
     return x * x;
 }
 
-int main()
-{
-    {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(-1./8192, 0.015625);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(d.m() + sqr(d.s())/2);
-        double x_var = (std::exp(sqr(d.s())) - 1) * std::exp(2*d.m() + sqr(d.s()));
-        double x_skew = (std::exp(sqr(d.s())) + 2) *
-              std::sqrt((std::exp(sqr(d.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(d.s())) + 2*std::exp(3*sqr(d.s())) +
-                          3*std::exp(2*sqr(d.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.05);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.25);
-    }
-    {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(-1./32, 0.25);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(d.m() + sqr(d.s())/2);
-        double x_var = (std::exp(sqr(d.s())) - 1) * std::exp(2*d.m() + sqr(d.s()));
-        double x_skew = (std::exp(sqr(d.s())) + 2) *
-              std::sqrt((std::exp(sqr(d.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(d.s())) + 2*std::exp(3*sqr(d.s())) +
-                          3*std::exp(2*sqr(d.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
-    }
-    {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(-1./8, 0.5);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(d.m() + sqr(d.s())/2);
-        double x_var = (std::exp(sqr(d.s())) - 1) * std::exp(2*d.m() + sqr(d.s()));
-        double x_skew = (std::exp(sqr(d.s())) + 2) *
-              std::sqrt((std::exp(sqr(d.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(d.s())) + 2*std::exp(3*sqr(d.s())) +
-                          3*std::exp(2*sqr(d.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.02);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.05);
-    }
-    {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d;
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(d.m() + sqr(d.s())/2);
-        double x_var = (std::exp(sqr(d.s())) - 1) * std::exp(2*d.m() + sqr(d.s()));
-        double x_skew = (std::exp(sqr(d.s())) + 2) *
-              std::sqrt((std::exp(sqr(d.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(d.s())) + 2*std::exp(3*sqr(d.s())) +
-                          3*std::exp(2*sqr(d.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.02);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.08);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.4);
-    }
-    {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(-0.78125, 1.25);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(d.m() + sqr(d.s())/2);
-        double x_var = (std::exp(sqr(d.s())) - 1) * std::exp(2*d.m() + sqr(d.s()));
-        double x_skew = (std::exp(sqr(d.s())) + 2) *
-              std::sqrt((std::exp(sqr(d.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(d.s())) + 2*std::exp(3*sqr(d.s())) +
-                          3*std::exp(2*sqr(d.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.04);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.2);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.7);
-    }
+void
+test1()
+
+void
+test2()
+
+void
+test3()
+
+void
+test4()
+
+void
+test5()
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
+    test5();
 }

test/std/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.lognormal/eval_param.pass.cpp

 template <class T>
 inline
 T
 sqr(T x)
 {
     return x * x;
 }
 
-int main()
-{
-
-    {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d;
-        P p(-1./8192, 0.015625);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(p.m() + sqr(p.s())/2);
-        double x_var = (std::exp(sqr(p.s())) - 1) * std::exp(2*p.m() + sqr(p.s()));
-        double x_skew = (std::exp(sqr(p.s())) + 2) *
-              std::sqrt((std::exp(sqr(p.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(p.s())) + 2*std::exp(3*sqr(p.s())) +
-                          3*std::exp(2*sqr(p.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.05);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.25);
-    }
-    {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d;
-        P p(-1./32, 0.25);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(p.m() + sqr(p.s())/2);
-        double x_var = (std::exp(sqr(p.s())) - 1) * std::exp(2*p.m() + sqr(p.s()));
-        double x_skew = (std::exp(sqr(p.s())) + 2) *
-              std::sqrt((std::exp(sqr(p.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(p.s())) + 2*std::exp(3*sqr(p.s())) +
-                          3*std::exp(2*sqr(p.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.03);
-    }
-    {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d;
-        P p(-1./8, 0.5);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(p.m() + sqr(p.s())/2);
-        double x_var = (std::exp(sqr(p.s())) - 1) * std::exp(2*p.m() + sqr(p.s()));
-        double x_skew = (std::exp(sqr(p.s())) + 2) *
-              std::sqrt((std::exp(sqr(p.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(p.s())) + 2*std::exp(3*sqr(p.s())) +
-                          3*std::exp(2*sqr(p.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.02);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.05);
-    }
-    {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(3, 4);
-        P p;
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(p.m() + sqr(p.s())/2);
-        double x_var = (std::exp(sqr(p.s())) - 1) * std::exp(2*p.m() + sqr(p.s()));
-        double x_skew = (std::exp(sqr(p.s())) + 2) *
-              std::sqrt((std::exp(sqr(p.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(p.s())) + 2*std::exp(3*sqr(p.s())) +
-                          3*std::exp(2*sqr(p.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.02);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.08);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.4);
-    }
-    {
-        typedef std::lognormal_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d;
-        P p(-0.78125, 1.25);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            assert(v > 0);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = std::exp(p.m() + sqr(p.s())/2);
-        double x_var = (std::exp(sqr(p.s())) - 1) * std::exp(2*p.m() + sqr(p.s()));
-        double x_skew = (std::exp(sqr(p.s())) + 2) *
-              std::sqrt((std::exp(sqr(p.s())) - 1));
-        double x_kurtosis = std::exp(4*sqr(p.s())) + 2*std::exp(3*sqr(p.s())) +
-                          3*std::exp(2*sqr(p.s())) - 6;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.04);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.2);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.7);
-    }
+void
+test1()
+
+void
+test2()
+
+void
+test3()
+
+void
+test4()
+
+void
+test5()
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
+    test5();
 }

test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval.pass.cpp

 template <class T>
 inline
 T
 sqr(T x)
 {
     return x * x;
 }
 
-int main()
-{
-    {
-        typedef std::extreme_value_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(0.5, 2);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.a() + d.b() * 0.577215665;
-        double x_var = sqr(d.b()) * 1.644934067;
-        double x_skew = 1.139547;
-        double x_kurtosis = 12./5;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-    }
-    {
-        typedef std::extreme_value_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(1, 2);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.a() + d.b() * 0.577215665;
-        double x_var = sqr(d.b()) * 1.644934067;
-        double x_skew = 1.139547;
-        double x_kurtosis = 12./5;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-    }
-    {
-        typedef std::extreme_value_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(1.5, 3);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.a() + d.b() * 0.577215665;
-        double x_var = sqr(d.b()) * 1.644934067;
-        double x_skew = 1.139547;
-        double x_kurtosis = 12./5;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-    }
-    {
-        typedef std::extreme_value_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(3, 4);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = d.a() + d.b() * 0.577215665;
-        double x_var = sqr(d.b()) * 1.644934067;
-        double x_skew = 1.139547;
-        double x_kurtosis = 12./5;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-    }
+void
+test1()
+
+void
+test2()
+
+void
+test3()
+
+void
+test4()
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
 }

test/std/numerics/rand/rand.dis/rand.dist.pois/rand.dist.pois.extreme/eval_param.pass.cpp

 template <class T>
 inline
 T
 sqr(T x)
 {
     return x * x;
 }
 
-int main()
-{
-    {
-        typedef std::extreme_value_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(-0.5, 1);
-        P p(0.5, 2);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = p.a() + p.b() * 0.577215665;
-        double x_var = sqr(p.b()) * 1.644934067;
-        double x_skew = 1.139547;
-        double x_kurtosis = 12./5;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-    }
-    {
-        typedef std::extreme_value_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(-0.5, 1);
-        P p(1, 2);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = p.a() + p.b() * 0.577215665;
-        double x_var = sqr(p.b()) * 1.644934067;
-        double x_skew = 1.139547;
-        double x_kurtosis = 12./5;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-    }
-    {
-        typedef std::extreme_value_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(-0.5, 1);
-        P p(1.5, 3);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = p.a() + p.b() * 0.577215665;
-        double x_var = sqr(p.b()) * 1.644934067;
-        double x_skew = 1.139547;
-        double x_kurtosis = 12./5;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-    }
-    {
-        typedef std::extreme_value_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937 G;
-        G g;
-        D d(-0.5, 1);
-        P p(3, 4);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g, p);
-            u.push_back(v);
-        }
-        double mean = std::accumulate(u.begin(), u.end(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (int i = 0; i < u.size(); ++i)
-        {
-            double dbl = (u[i] - mean);
-            double d2 = sqr(dbl);
-            var += d2;
-            skew += dbl * d2;
-            kurtosis += d2 * d2;
-        }
-        var /= u.size();
-        double dev = std::sqrt(var);
-        skew /= u.size() * dev * var;
-        kurtosis /= u.size() * var * var;
-        kurtosis -= 3;
-        double x_mean = p.a() + p.b() * 0.577215665;
-        double x_var = sqr(p.b()) * 1.644934067;
-        double x_skew = 1.139547;
-        double x_kurtosis = 12./5;
-        assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-        assert(std::abs((var - x_var) / x_var) < 0.01);
-        assert(std::abs((skew - x_skew) / x_skew) < 0.01);
-        assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-    }
+void
+test1()
+
+void
+test2()
+
+void
+test3()
+
+void
+test4()
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
 }

test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp

 template <class T>
 inline
 T
 sqr(T x)
 {
     return x*x;
 }
 
-int main()
-{
-    {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {25, 62.5, 12.5};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
-        {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
-            {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double dbl = (*j - mean);
-                    double d2 = sqr(dbl);
-                    var += d2;
-                    skew += dbl * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-            }
-        }
-    }
-    {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {0, 62.5, 12.5};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
-        {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
-            {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double dbl = (*j - mean);
-                    double d2 = sqr(dbl);
-                    var += d2;
-                    skew += dbl * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-            }
-        }
-    }
-    {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {25, 0, 12.5};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
-        {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
-            {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double dbl = (*j - mean);
-                    double d2 = sqr(dbl);
-                    var += d2;
-                    skew += dbl * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-            }
-        }
-    }
-    {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {25, 62.5, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
-        {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
-            {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double dbl = (*j - mean);
-                    double d2 = sqr(dbl);
-                    var += d2;
-                    skew += dbl * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-            }
-        }
-    }
-    {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {25, 0, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
-        {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
-            {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double dbl = (*j - mean);
-                    double d2 = sqr(dbl);
-                    var += d2;
-                    skew += dbl * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-            }
-        }
-    }
-    {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {0, 25, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
-        {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
-            {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double dbl = (*j - mean);
-                    double d2 = sqr(dbl);
-                    var += d2;
-                    skew += dbl * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-            }
-        }
-    }
-    {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {0, 0, 1};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
-        {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
-            {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double dbl = (*j - mean);
-                    double d2 = sqr(dbl);
-                    var += d2;
-                    skew += dbl * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-            }
-        }
-    }
-    {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16};
-        double p[] = {75, 25};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
-        {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
-            {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double dbl = (*j - mean);
-                    double d2 = sqr(dbl);
-                    var += d2;
-                    skew += dbl * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-            }
-        }
-    }
-    {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16};
-        double p[] = {0, 25};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
-        {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
-            {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double dbl = (*j - mean);
-                    double d2 = sqr(dbl);
-                    var += d2;
-                    skew += dbl * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-            }
-        }
-    }
-    {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16};
-        double p[] = {1, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
-        {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
-            {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double dbl = (*j - mean);
-                    double d2 = sqr(dbl);
-                    var += d2;
-                    skew += dbl * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-            }
-        }
-    }
-    {
-        typedef std::piecewise_constant_distribution<> D;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14};
-        double p[] = {1};
-        const size_t Np = sizeof(p) / sizeof(p[0]);
-        D d(b, b+Np+1, p);
-        const int N = 100000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::vector<double> prob(std::begin(p), std::end(p));
-        double s = std::accumulate(prob.begin(), prob.end(), 0.0);
-        for (int i = 0; i < prob.size(); ++i)
-            prob[i] /= s;
-        std::sort(u.begin(), u.end());
-        for (int i = 0; i < Np; ++i)
-        {
-            typedef std::vector<D::result_type>::iterator I;
-            I lb = std::lower_bound(u.begin(), u.end(), b[i]);
-            I ub = std::lower_bound(u.begin(), u.end(), b[i+1]);
-            const size_t Ni = ub - lb;
-            if (prob[i] == 0)
-                assert(Ni == 0);
-            else
-            {
-                assert(std::abs((double)Ni/N - prob[i]) / prob[i] < .01);
-                double mean = std::accumulate(lb, ub, 0.0) / Ni;
-                double var = 0;
-                double skew = 0;
-                double kurtosis = 0;
-                for (I j = lb; j != ub; ++j)
-                {
-                    double dbl = (*j - mean);
-                    double d2 = sqr(dbl);
-                    var += d2;
-                    skew += dbl * d2;
-                    kurtosis += d2 * d2;
-                }
-                var /= Ni;
-                double dev = std::sqrt(var);
-                skew /= Ni * dev * var;
-                kurtosis /= Ni * var * var;
-                kurtosis -= 3;
-                double x_mean = (b[i+1] + b[i]) / 2;
-                double x_var = sqr(b[i+1] - b[i]) / 12;
-                double x_skew = 0;
-                double x_kurtosis = -6./5;
-                assert(std::abs((mean - x_mean) / x_mean) < 0.01);
-                assert(std::abs((var - x_var) / x_var) < 0.01);
-                assert(std::abs(skew - x_skew) < 0.01);
-                assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
-            }
-        }
-    }
+void
+test1()
+
+void
+test2()
+
+void
+test3()
+
+void
+test4()
+
+void
+test5()
+
+void
+test6()
+
+void
+test7()
+
+void
+test8()
+
+void
+test9()
+
+void
+test10()
+
+void
+test11()
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
+    test5();
+    test6();
+    test7();
+    test8();
+    test9();
+    test10();
+    test11();
 }

test/std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp

 }
 
 double
 f(double x, double a, double m, double b, double c)
 {
     return a + m*(sqr(x) - sqr(b))/2 + c*(x-b);
 }
 
-int main()
-{
-    {
-        typedef std::piecewise_linear_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {0, 1, 1, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::sort(u.begin(), u.end());
-        int kp = -1;
-        double a = std::numeric_limits<double>::quiet_NaN();
-        double m = std::numeric_limits<double>::quiet_NaN();
-        double bk = std::numeric_limits<double>::quiet_NaN();
-        double c = std::numeric_limits<double>::quiet_NaN();
-        std::vector<double> areas(Np);
-        double S = 0;
-        for (int i = 0; i < areas.size(); ++i)
-        {
-            areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
-            S += areas[i];
-        }
-        for (int i = 0; i < areas.size(); ++i)
-            areas[i] /= S;
-        for (int i = 0; i < Np+1; ++i)
-            p[i] /= S;
-        for (int i = 0; i < N; ++i)
-        {
-            int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
-            if (k != kp)
-            {
-                a = 0;
-                for (int j = 0; j < k; ++j)
-                    a += areas[j];
-                m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
-                bk = b[k];
-                c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
-                kp = k;
-            }
-            assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
-        }
-    }
-    {
-        typedef std::piecewise_linear_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {0, 0, 1, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::sort(u.begin(), u.end());
-        int kp = -1;
-        double a = std::numeric_limits<double>::quiet_NaN();
-        double m = std::numeric_limits<double>::quiet_NaN();
-        double bk = std::numeric_limits<double>::quiet_NaN();
-        double c = std::numeric_limits<double>::quiet_NaN();
-        std::vector<double> areas(Np);
-        double S = 0;
-        for (int i = 0; i < areas.size(); ++i)
-        {
-            areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
-            S += areas[i];
-        }
-        for (int i = 0; i < areas.size(); ++i)
-            areas[i] /= S;
-        for (int i = 0; i < Np+1; ++i)
-            p[i] /= S;
-        for (int i = 0; i < N; ++i)
-        {
-            int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
-            if (k != kp)
-            {
-                a = 0;
-                for (int j = 0; j < k; ++j)
-                    a += areas[j];
-                m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
-                bk = b[k];
-                c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
-                kp = k;
-            }
-            assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
-        }
-    }
-    {
-        typedef std::piecewise_linear_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {1, 0, 0, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::sort(u.begin(), u.end());
-        int kp = -1;
-        double a = std::numeric_limits<double>::quiet_NaN();
-        double m = std::numeric_limits<double>::quiet_NaN();
-        double bk = std::numeric_limits<double>::quiet_NaN();
-        double c = std::numeric_limits<double>::quiet_NaN();
-        std::vector<double> areas(Np);
-        double S = 0;
-        for (int i = 0; i < areas.size(); ++i)
-        {
-            areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
-            S += areas[i];
-        }
-        for (int i = 0; i < areas.size(); ++i)
-            areas[i] /= S;
-        for (int i = 0; i < Np+1; ++i)
-            p[i] /= S;
-        for (int i = 0; i < N; ++i)
-        {
-            int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
-            if (k != kp)
-            {
-                a = 0;
-                for (int j = 0; j < k; ++j)
-                    a += areas[j];
-                m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
-                bk = b[k];
-                c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
-                kp = k;
-            }
-            assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
-        }
-    }
-    {
-        typedef std::piecewise_linear_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16};
-        double p[] = {0, 1, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::sort(u.begin(), u.end());
-        int kp = -1;
-        double a = std::numeric_limits<double>::quiet_NaN();
-        double m = std::numeric_limits<double>::quiet_NaN();
-        double bk = std::numeric_limits<double>::quiet_NaN();
-        double c = std::numeric_limits<double>::quiet_NaN();
-        std::vector<double> areas(Np);
-        double S = 0;
-        for (int i = 0; i < areas.size(); ++i)
-        {
-            areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
-            S += areas[i];
-        }
-        for (int i = 0; i < areas.size(); ++i)
-            areas[i] /= S;
-        for (int i = 0; i < Np+1; ++i)
-            p[i] /= S;
-        for (int i = 0; i < N; ++i)
-        {
-            int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
-            if (k != kp)
-            {
-                a = 0;
-                for (int j = 0; j < k; ++j)
-                    a += areas[j];
-                m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
-                bk = b[k];
-                c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
-                kp = k;
-            }
-            assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
-        }
-    }
-    {
-        typedef std::piecewise_linear_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14};
-        double p[] = {1, 1};
-        const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::sort(u.begin(), u.end());
-        int kp = -1;
-        double a = std::numeric_limits<double>::quiet_NaN();
-        double m = std::numeric_limits<double>::quiet_NaN();
-        double bk = std::numeric_limits<double>::quiet_NaN();
-        double c = std::numeric_limits<double>::quiet_NaN();
-        std::vector<double> areas(Np);
-        double S = 0;
-        for (int i = 0; i < areas.size(); ++i)
-        {
-            areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
-            S += areas[i];
-        }
-        for (int i = 0; i < areas.size(); ++i)
-            areas[i] /= S;
-        for (int i = 0; i < Np+1; ++i)
-            p[i] /= S;
-        for (int i = 0; i < N; ++i)
-        {
-            int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
-            if (k != kp)
-            {
-                a = 0;
-                for (int j = 0; j < k; ++j)
-                    a += areas[j];
-                m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
-                bk = b[k];
-                c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
-                kp = k;
-            }
-            assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
-        }
-    }
-    {
-        typedef std::piecewise_linear_distribution<> D;
-        typedef D::param_type P;
-        typedef std::mt19937_64 G;
-        G g;
-        double b[] = {10, 14, 16, 17};
-        double p[] = {25, 62.5, 12.5, 0};
-        const size_t Np = sizeof(p) / sizeof(p[0]) - 1;
-        D d(b, b+Np+1, p);
-        const int N = 1000000;
-        std::vector<D::result_type> u;
-        for (int i = 0; i < N; ++i)
-        {
-            D::result_type v = d(g);
-            assert(d.min() <= v && v < d.max());
-            u.push_back(v);
-        }
-        std::sort(u.begin(), u.end());
-        int kp = -1;
-        double a = std::numeric_limits<double>::quiet_NaN();
-        double m = std::numeric_limits<double>::quiet_NaN();
-        double bk = std::numeric_limits<double>::quiet_NaN();
-        double c = std::numeric_limits<double>::quiet_NaN();
-        std::vector<double> areas(Np);
-        double S = 0;
-        for (int i = 0; i < areas.size(); ++i)
-        {
-            areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
-            S += areas[i];
-        }
-        for (int i = 0; i < areas.size(); ++i)
-            areas[i] /= S;
-        for (int i = 0; i < Np+1; ++i)
-            p[i] /= S;
-        for (int i = 0; i < N; ++i)
-        {
-            int k = std::lower_bound(b, b+Np+1, u[i]) - b - 1;
-            if (k != kp)
-            {
-                a = 0;
-                for (int j = 0; j < k; ++j)
-                    a += areas[j];
-                m = (p[k+1] - p[k]) / (b[k+1] - b[k]);
-                bk = b[k];
-                c = (b[k+1]*p[k] - b[k]*p[k+1]) / (b[k+1] - b[k]);
-                kp = k;
-            }
-            assert(std::abs(f(u[i], a, m, bk, c) - double(i)/N) < .001);
-        }
-    }
+void
+test1()
+
+void
+test2()
+
+void
+test3()
+
+void
+test4()
+
+void
+test5()
+
+void
+test6()
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
+    test5();
+    test6();
 }

test/std/utilities/meta/meta.unary/meta.unary.prop/is_swappable_include_order.pass.cpp

 // type_traits
 
 // is_swappable
 
 // IMPORTANT: The include order is part of the test. We want to pick up
 // the following definitions in this order:
 //   1) is_swappable, is_nothrow_swappable
 //   2) iter_swap, swap_ranges
-//   3) swap(T (&)[N], T(&)[N]
+//   3) swap(T (&)[N], T (&)[N])
 // This test checks that (1) and (2) see forward declarations
 // for (3).
 #include <type_traits>
 #include <algorithm>
 #include <utility>
 
 #include "test_macros.h"
 
 int main()
 {
     // Use a builtin type so we don't get ADL lookup.
-    typedef double T[42][50];
+    typedef double T[17][29];
     {
         LIBCPP_STATIC_ASSERT(std::__is_swappable<T>::value, "");
 #if TEST_STD_VER > 14
         static_assert(std::is_swappable_v<T>);
 #endif
     }
     {
         T t1 = {};
         T t2 = {};
        std::iter_swap(t1, t2);
-       std::swap_ranges(t1, t1 + 42, t2);
+       std::swap_ranges(t1, t1 + 17, t2);
     }
 }