[libc++] Support int8_t and uint8_t in integer distributions as an extension

[ldionne]

Summary

In D125283, we ensured that integer distributions would not compile when
used with arbitrary unsupported types. This effectively enforced what
the Standard mentions here: http://eel.is/c++draft/rand#req.genl-1.5.

However, this also had the effect of breaking some users that were
using integer distributions with unsupported types like int8_t. Since we
already support using __int128_t in those distributions, it is reasonable
to also support smaller types like int8_t and its unsigned variant. This
commit implements that, adds tests and documents the extension. Note that
we voluntarily don't add support for instantiating these distributions
with bool and char, since those are not integer types. However, it is
trivial to replace uses of these random distributions on char using int8_t.

It is also interesting to note that in the process of adding tests
for smaller types, I discovered that our distributions sometimes don't
provide as faithful a distribution when instantiated with smaller types,
so I had to relax a couple of tests.

Supersedes D125283.

[CrystalSplitter]

Hi Louis,

This patch should resolve >95% of the issues we're encountering in ChromeOS and Android. I think the remaining char ones we can fix on our end, as the vast majority of the breakages are with uint8_t in particular.
We appreciate the fix very much, as it's been quite a trek on our end patching up these issues (and we're still encountering them, so we'll cherrypick this ASAP). I know the Android folks will be very grateful as well for the fix.

Thanks,
~Jordan R AW

[ldionne]

Fix documentation build. I think this is going to fail in two of the test's distributions because we apparently struggle to be as faithful for small types.

After a small investigation, I think this is because our poisson distribution isn't as good for types with fewer bits, but we'll have to figure that out before shipping the patch.

• Either we're OK with the distribution not being as faithful, and we relax the tests, or
• we find a way to improve the implementation for smaller types.

[ldionne]

Rebase, try to fix CI (this was much more involved than I thought).

In particular, I left a bunch of TODOs around the quality of negative_binomial (which is really on poisson_distribution,
since that's what negative_binomial uses). I am out of time for figuring out how to further improve poisson_distribution
for small types. I tried various things and nothing really worked for int8_t -- I think a rewrite of the algorithm might
be necessary, but that would be an ABI break and a larger project.

[ldionne]

Try to fix tests. Do not revert modifications to poisson_distribution anymore, since that causes the reproducer tests I had added to hang.

[ldionne]

Add missing test_macros.h include

libcxx/docs/ReleaseNotes.rst

- The ``_LIBCPP_ABI_UNSTABLE`` macro has been removed in favour of setting
   they were not supposed to set ``_LIBCPP_ABI_UNSTABLE`` manually, however we
   still feel that it is worth mentioning in the release notes in case some users
   had been doing it.
 
 - The integer distributions ``binomial_distribution``, ``discrete_distribution``,
   ``geometric_distribution``, ``negative_binomial_distribution``, ``poisson_distribution``,
   and ``uniform_int_distribution`` now conform to the Standard by rejecting
   template parameter types other than ``short``, ``int``, ``long``, ``long long``,
-  (as an extension) ``__int128_t``, and the unsigned versions thereof.
-  In particular, ``uniform_int_distribution<int8_t>`` is no longer supported.
+  and the unsigned versions thereof. As an extension, ``int8_t``, ``__int128_t`` and
+  their unsigned versions are supported too. In particular, instantiating these
+  distributions with non-integer types like ``bool`` and ``char`` will not compile
+  anymore.
 
 Upcoming Deprecations and Removals
 ----------------------------------
 
 - The ``_LIBCPP_DEBUG`` macro is not supported anymore. It will be honoured until
   LLVM 16, and then it will be an error to define that macro. To enable basic
   assertions (previously ``_LIBCPP_DEBUG=0``), please use ``_LIBCPP_ENABLE_ASSERTIONS=1``.
   To enable the debug mode (previously ``_LIBCPP_DEBUG=1|2``), please ensure that

libcxx/docs/UsingLibcxx.rst

 * ``as_const``
 * ``bit_cast``
 * ``forward``
 * ``move``
 * ``move_if_noexcept``
 * ``identity::operator()``
 * ``to_integer``
 * ``to_underlying``
+
+Additional types supported in random distributions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The `C++ Standard <http://eel.is/c++draft/rand#req.genl-1.5>`_ mentions that instantiating several random number
+distributions with types other than ``short``, ``int``, ``long``, ``long long``, and their unsigned versions is
+undefined. As an extension, libc++ supports instantiating ``binomial_distribution``, ``discrete_distribution``,
+``geometric_distribution``, ``negative_binomial_distribution``, ``poisson_distribution``, and ``uniform_int_distribution``
+with ``int8_t``, ``__int128_t`` and their unsigned versions.

libcxx/include/__random/binomial_distribution.h

 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _IntType = int>
 class _LIBCPP_TEMPLATE_VIS binomial_distribution
 {
-    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be an integer type larger than char");
+    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
 public:
     // types
     typedef _IntType result_type;
 
     class _LIBCPP_TEMPLATE_VIS param_type
     {
         result_type __t_;
         double __p_;

libcxx/include/__random/discrete_distribution.h

 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _IntType = int>
 class _LIBCPP_TEMPLATE_VIS discrete_distribution
 {
-    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be an integer type larger than char");
+    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
 public:
     // types
     typedef _IntType result_type;
 
     class _LIBCPP_TEMPLATE_VIS param_type
     {
         vector<double> __p_;
     public:

libcxx/include/__random/geometric_distribution.h

 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _IntType = int>
 class _LIBCPP_TEMPLATE_VIS geometric_distribution
 {
-    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be an integer type larger than char");
+    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
 public:
     // types
     typedef _IntType result_type;
 
     class _LIBCPP_TEMPLATE_VIS param_type
     {
         double __p_;
     public:

libcxx/include/__random/is_valid.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_IS_VALID_H
 #define _LIBCPP___RANDOM_IS_VALID_H
 
 #include <__config>
+#include <cstdint>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [rand.req.genl]/1.5:
 // The effect of instantiating a template that has a template type parameter
 // named IntType is undefined unless the corresponding template argument is
 // cv-unqualified and is one of short, int, long, long long, unsigned short,
 // unsigned int, unsigned long, or unsigned long long.
 
 template<class> struct __libcpp_random_is_valid_inttype : false_type {};
+template<> struct __libcpp_random_is_valid_inttype<int8_t> : true_type {}; // extension
 template<> struct __libcpp_random_is_valid_inttype<short> : true_type {};
 template<> struct __libcpp_random_is_valid_inttype<int> : true_type {};
 template<> struct __libcpp_random_is_valid_inttype<long> : true_type {};
 template<> struct __libcpp_random_is_valid_inttype<long long> : true_type {};
+template<> struct __libcpp_random_is_valid_inttype<uint8_t> : true_type {}; // extension
 template<> struct __libcpp_random_is_valid_inttype<unsigned short> : true_type {};
 template<> struct __libcpp_random_is_valid_inttype<unsigned int> : true_type {};
 template<> struct __libcpp_random_is_valid_inttype<unsigned long> : true_type {};
 template<> struct __libcpp_random_is_valid_inttype<unsigned long long> : true_type {};
 
 #ifndef _LIBCPP_HAS_NO_INT128
-template<> struct __libcpp_random_is_valid_inttype<__int128_t> : true_type {};
-template<> struct __libcpp_random_is_valid_inttype<__uint128_t> : true_type {};
+template<> struct __libcpp_random_is_valid_inttype<__int128_t> : true_type {}; // extension
+template<> struct __libcpp_random_is_valid_inttype<__uint128_t> : true_type {}; // extension
 #endif // _LIBCPP_HAS_NO_INT128
 
 // [rand.req.urng]/3:
 // A class G meets the uniform random bit generator requirements if G models
 // uniform_random_bit_generator, invoke_result_t<G&> is an unsigned integer type,
 // and G provides a nested typedef-name result_type that denotes the same type
 // as invoke_result_t<G&>.
 // (In particular, reject URNGs with signed result_types; our distributions cannot

libcxx/include/__random/negative_binomial_distribution.h

 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _IntType = int>
 class _LIBCPP_TEMPLATE_VIS negative_binomial_distribution
 {
-    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be an integer type larger than char");
+    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
 public:
     // types
     typedef _IntType result_type;
 
     class _LIBCPP_TEMPLATE_VIS param_type
     {
         result_type __k_;
         double __p_;

 template <class _IntType>
 template<class _URNG>
 _IntType
 negative_binomial_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
 {
     static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
     result_type __k = __pr.k();
     double __p = __pr.p();
-    if (__k <= 21 * __p)
+    // When the number of bits in _IntType is small, we are too likely to
+    // overflow __f below to use this technique.
+    if (__k <= 21 * __p && sizeof(_IntType) > 1)
     {
         bernoulli_distribution __gen(__p);
         result_type __f = 0;
         result_type __s = 0;
         while (__s < __k)
         {
             if (__gen(__urng))
                 ++__s;
             else
                 ++__f;
         }
+        _LIBCPP_ASSERT(__f >= 0, "std::negative_binomial_distribution should never produce negative values. "
+                                 "This is almost certainly a signed integer overflow issue on __f.");
         return __f;
     }
     return poisson_distribution<result_type>(gamma_distribution<double>
                                             (__k, (1-__p)/__p)(__urng))(__urng);
 }
 
 template <class _CharT, class _Traits, class _IntType>
 basic_ostream<_CharT, _Traits>&

libcxx/include/__random/poisson_distribution.h

 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _IntType = int>
 class _LIBCPP_TEMPLATE_VIS poisson_distribution
 {
-    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be an integer type larger than char");
+    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
 public:
     // types
     typedef _IntType result_type;
 
     class _LIBCPP_TEMPLATE_VIS param_type
     {
         double __mean_;
         double __s_;

libcxx/include/__random/uniform_int_distribution.h

for (size_t __k = __n0_; __k < __n_; ++__k)
         _Sp += __u & __mask1_;
     }
     return _Sp;
 }
 
 template<class _IntType = int>
 class uniform_int_distribution
 {
-    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be an integer type larger than char");
+    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
 public:
     // types
     typedef _IntType result_type;
 
     class param_type
     {
         result_type __a_;
         result_type __b_;

libcxx/test/libcxx/numerics/rand/rand.req.urng/valid_int_type.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <random>
 
 #include <random>
 
 void test()
 {
   {
-    std::binomial_distribution<bool> baddist; //expected-error@*:* {{IntType must be an integer type larger than char}}
+    std::binomial_distribution<bool> baddist; //expected-error@*:* {{IntType must be a supported integer type}}
     std::binomial_distribution<int> okdist;
     (void)baddist;
     (void)okdist;
   }
   {
-    std::discrete_distribution<bool> baddist; //expected-error@*:* {{IntType must be an integer type larger than char}}
+    std::discrete_distribution<bool> baddist; //expected-error@*:* {{IntType must be a supported integer type}}
     std::discrete_distribution<int> okdist;
     (void)baddist;
     (void)okdist;
   }
   {
-    std::geometric_distribution<bool> baddist; //expected-error@*:* {{IntType must be an integer type larger than char}}
+    std::geometric_distribution<bool> baddist; //expected-error@*:* {{IntType must be a supported integer type}}
     std::geometric_distribution<int> okdist;
     (void)baddist;
     (void)okdist;
   }
   {
-    std::negative_binomial_distribution<bool> baddist; //expected-error@*:* {{IntType must be an integer type larger than char}}
+    std::negative_binomial_distribution<bool> baddist; //expected-error@*:* {{IntType must be a supported integer type}}
     std::negative_binomial_distribution<int> okdist;
     (void)baddist;
     (void)okdist;
   }
   {
-    std::poisson_distribution<bool> baddist; //expected-error@*:* {{IntType must be an integer type larger than char}}
+    std::poisson_distribution<bool> baddist; //expected-error@*:* {{IntType must be a supported integer type}}
     std::poisson_distribution<int> okdist;
     (void)baddist;
     (void)okdist;
   }
   {
-    std::uniform_int_distribution<bool> baddist; //expected-error@*:* {{IntType must be an integer type larger than char}}
+    std::uniform_int_distribution<bool> baddist; //expected-error@*:* {{IntType must be a supported integer type}}
     std::uniform_int_distribution<int> okdist;
     (void)baddist;
     (void)okdist;
   }
 }

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

 
 // template<class _URNG> result_type operator()(_URNG& g);
 
 #include <random>
 #include <numeric>
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
-inline
-T
-sqr(T x)
-{
+T sqr(T x) {
     return x * x;
 }
 
-void
-test1()
-{
-    typedef std::binomial_distribution<> D;
+template <class T>
+void test1() {
+    typedef std::binomial_distribution<T> D;
     typedef std::mt19937_64 G;
     G g;
     D d(5, .75);
     const int N = 1000000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test1() {
     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);
 }
 
-void
-test2()
-{
-    typedef std::binomial_distribution<> D;
+template <class T>
+void test2() {
+    typedef std::binomial_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(30, .03125);
     const int N = 100000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test2() {
     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);
 }
 
-void
-test3()
-{
-    typedef std::binomial_distribution<> D;
+template <class T>
+void test3() {
+    typedef std::binomial_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(40, .25);
     const int N = 100000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test3() {
     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);
 }
 
-void
-test4()
-{
-    typedef std::binomial_distribution<> D;
+template <class T>
+void test4() {
+    typedef std::binomial_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(40, 0);
     const int N = 100000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test4() {
     assert(mean == x_mean);
     assert(var == x_var);
     // assert(skew == x_skew);
     (void)skew; (void)x_skew;
     // assert(kurtosis == x_kurtosis);
     (void)kurtosis; (void)x_kurtosis;
 }
 
-void
-test5()
-{
-    typedef std::binomial_distribution<> D;
+template <class T>
+void test5() {
+    typedef std::binomial_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(40, 1);
     const int N = 100000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test5() {
     assert(mean == x_mean);
     assert(var == x_var);
     // assert(skew == x_skew);
     (void)skew; (void)x_skew;
     // assert(kurtosis == x_kurtosis);
     (void)kurtosis; (void)x_kurtosis;
 }
 
-void
-test6()
-{
-    typedef std::binomial_distribution<> D;
+template <class T>
+void test6() {
+    typedef std::binomial_distribution<T> D;
     typedef std::mt19937 G;
     G g;
-    D d(400, 0.5);
+    D d(127, 0.5);
     const int N = 100000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test6() {
     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(skew - x_skew) < 0.02);
     assert(std::abs(kurtosis - x_kurtosis) < 0.01);
 }
 
-void
-test7()
-{
-    typedef std::binomial_distribution<> D;
+template <class T>
+void test7() {
+    typedef std::binomial_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(1, 0.5);
     const int N = 100000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test7() {
     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);
 }
 
-void
-test8()
-{
+template <class T>
+void test8() {
     const int N = 100000;
     std::mt19937 gen1;
     std::mt19937 gen2;
 
-    std::binomial_distribution<>         dist1(5, 0.1);
-    std::binomial_distribution<unsigned> dist2(5, 0.1);
+    using UnsignedT = typename std::make_unsigned<T>::type;
+    std::binomial_distribution<T>         dist1(5, 0.1);
+    std::binomial_distribution<UnsignedT> dist2(5, 0.1);
 
-    for(int i = 0; i < N; ++i) {
-        int r1 = dist1(gen1);
-        unsigned r2 = dist2(gen2);
+    for (int i = 0; i < N; ++i) {
+        T r1 = dist1(gen1);
+        UnsignedT r2 = dist2(gen2);
         assert(r1 >= 0);
-        assert(static_cast<unsigned>(r1) == r2);
+        assert(static_cast<UnsignedT>(r1) == r2);
     }
 }
 
-void
-test9()
-{
-    typedef std::binomial_distribution<> D;
+template <class T>
+void test9() {
+    typedef std::binomial_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(0, 0.005);
     const int N = 100000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test9() {
     assert(mean == x_mean);
     assert(var == x_var);
     // assert(skew == x_skew);
     (void)skew; (void)x_skew;
     // assert(kurtosis == x_kurtosis);
     (void)kurtosis; (void)x_kurtosis;
 }
 
-void
-test10()
-{
-    typedef std::binomial_distribution<> D;
+template <class T>
+void test10() {
+    typedef std::binomial_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(0, 0);
     const int N = 100000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test10() {
     assert(mean == x_mean);
     assert(var == x_var);
     // assert(skew == x_skew);
     (void)skew; (void)x_skew;
     // assert(kurtosis == x_kurtosis);
     (void)kurtosis; (void)x_kurtosis;
 }
 
-void
-test11()
-{
-    typedef std::binomial_distribution<> D;
+template <class T>
+void test11() {
+    typedef std::binomial_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(0, 1);
     const int N = 100000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test11() {
     assert(mean == x_mean);
     assert(var == x_var);
     // assert(skew == x_skew);
     (void)skew; (void)x_skew;
     // assert(kurtosis == x_kurtosis);
     (void)kurtosis; (void)x_kurtosis;
 }
 
-int main(int, char**)
-{
-    test1();
-    test2();
-    test3();
-    test4();
-    test5();
-    test6();
-    test7();
-    test8();
-    test9();
-    test10();
-    test11();
+template <class T>
+void tests() {
+    test1<T>();
+    test2<T>();
+    test3<T>();
+    test4<T>();
+    test5<T>();
+    test6<T>();
+    test7<T>();
+    test8<T>();
+    test9<T>();
+    test10<T>();
+    test11<T>();
+}
+
+int main(int, char**) {
+    tests<short>();
+    tests<int>();
+    tests<long>();
+    tests<long long>();
+
+    tests<unsigned short>();
+    tests<unsigned int>();
+    tests<unsigned long>();
+    tests<unsigned long long>();
+
+#if defined(_LIBCPP_VERSION) // extension
+    tests<int8_t>();
+    tests<uint8_t>();
+#if !defined(TEST_HAS_NO_INT128)
+    tests<__int128_t>();
+    tests<__uint128_t>();
+#endif
+#endif
 
     return 0;
 }

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

 #include <random>
 #include <numeric>
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
-inline
-T
-sqr(T x)
-{
+T sqr(T x) {
     return x * x;
 }
 
 void test_small_inputs() {
   std::mt19937 engine;
   std::geometric_distribution<std::int16_t> distribution(5.45361e-311);
   typedef std::geometric_distribution<std::int16_t>::result_type result_type;
   for (int i = 0; i < 1000; ++i) {
     volatile result_type res = distribution(engine);
     ((void)res);
   }
 }
 
-void
-test1()
-{
-    typedef std::geometric_distribution<> D;
+template <class T>
+void test1() {
+    typedef std::geometric_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(.03125);
     const int N = 1000000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test1() {
     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);
 }
 
-void
-test2()
-{
-    typedef std::geometric_distribution<> D;
+template <class T>
+void test2() {
+    typedef std::geometric_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(0.05);
     const int N = 1000000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test2() {
     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);
 }
 
-void
-test3()
-{
-    typedef std::geometric_distribution<> D;
+template <class T>
+void test3() {
+    typedef std::geometric_distribution<T> D;
     typedef std::minstd_rand G;
     G g;
     D d(.25);
     const int N = 1000000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test3() {
     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
-test4()
-{
-    typedef std::geometric_distribution<> D;
+template <class T>
+void test4() {
+    typedef std::geometric_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(0.5);
     const int N = 1000000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test4() {
     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
-test5()
-{
-    typedef std::geometric_distribution<> D;
+template <class T>
+void test5() {
+    typedef std::geometric_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(0.75);
     const int N = 1000000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test5() {
     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
-test6()
-{
-    typedef std::geometric_distribution<> D;
+template <class T>
+void test6() {
+    typedef std::geometric_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(0.96875);
     const int N = 1000000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test6() {
     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);
 }
 
-int main(int, char**)
-{
-    test1();
-    test2();
-    test3();
-    test4();
-    test5();
-    test6();
+template <class T>
+void tests() {
+    test1<T>();
+    test2<T>();
+    test3<T>();
+    test4<T>();
+    test5<T>();
+    test6<T>();
+}
+
+int main(int, char**) {
     test_small_inputs();
 
+    tests<short>();
+    tests<int>();
+    tests<long>();
+    tests<long long>();
+
+    tests<unsigned short>();
+    tests<unsigned int>();
+    tests<unsigned long>();
+    tests<unsigned long long>();
+
+#if defined(_LIBCPP_VERSION) // extension
+    // TODO: std::geometric_distribution currently doesn't work reliably with small types.
+    // tests<int8_t>();
+    // tests<uint8_t>();
+#if !defined(TEST_HAS_NO_INT128)
+    tests<__int128_t>();
+    tests<__uint128_t>();
+#endif
+#endif
+
     return 0;
 }

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

 
 // template<class _URNG> result_type operator()(_URNG& g);
 
 #include <random>
 #include <numeric>
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
-inline
-T
-sqr(T x)
-{
+T sqr(T x) {
     return x * x;
 }
 
-void
-test1()
-{
-    typedef std::negative_binomial_distribution<> D;
+template <class T>
+void test1() {
+    typedef std::negative_binomial_distribution<T> D;
     typedef std::minstd_rand G;
     G g;
     D d(5, .25);
     const int N = 1000000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test1() {
     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);
 }
 
-void
-test2()
-{
-    typedef std::negative_binomial_distribution<> D;
+template <class T>
+void test2() {
+    typedef std::negative_binomial_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(30, .03125);
     const int N = 1000000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test2() {
     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);
 }
 
-void
-test3()
-{
-    typedef std::negative_binomial_distribution<> D;
+template <class T>
+void test3() {
+    typedef std::negative_binomial_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(40, .25);
     const int N = 1000000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test3() {
     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
-test4()
-{
-    typedef std::negative_binomial_distribution<> D;
+template <class T>
+void test4() {
+    typedef std::negative_binomial_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(40, 1);
     const int N = 1000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test4() {
     assert(mean == x_mean);
     assert(var == x_var);
     // assert(skew == x_skew);
     (void)skew; (void)x_skew;
     // assert(kurtosis == x_kurtosis);
     (void)kurtosis; (void)x_kurtosis;
 }
 
-void
-test5()
-{
-    typedef std::negative_binomial_distribution<> D;
+template <class T>
+void test5() {
+    typedef std::negative_binomial_distribution<T> D;
     typedef std::mt19937 G;
     G g;
-    D d(400, 0.5);
+    D d(127, 0.5);
     const int N = 1000000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test5() {
     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);
 }
 
-void
-test6()
-{
-    typedef std::negative_binomial_distribution<> D;
+template <class T>
+void test6() {
+    typedef std::negative_binomial_distribution<T> D;
     typedef std::mt19937 G;
     G g;
     D d(1, 0.05);
     const int N = 1000000;
-    std::vector<D::result_type> u;
+    std::vector<typename D::result_type> u;
     for (int i = 0; i < N; ++i)
     {
-        D::result_type v = d(g);
+        typename 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;
void test6() {
     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);
 }
 
-int main(int, char**)
-{
-    test1();
-    test2();
-    test3();
-    test4();
-    test5();
-    test6();
+template <class T>
+void tests() {
+    test1<T>();
+    test2<T>();
+    test3<T>();
+    test4<T>();
+    test5<T>();
+    test6<T>();
+}
+
+int main(int, char**) {
+    tests<short>();
+    tests<int>();
+    tests<long>();
+    tests<long long>();
+
+    tests<unsigned short>();
+    tests<unsigned int>();
+    tests<unsigned long>();
+    tests<unsigned long long>();
+
+#if defined(_LIBCPP_VERSION) // extension
+    // TODO: std::negative_binomial_distribution currently doesn't work reliably with small types.
+    // tests<int8_t>();
+    // tests<uint8_t>();
+#if !defined(TEST_HAS_NO_INT128)
+    tests<__int128_t>();
+    tests<__uint128_t>();
+#endif
+#endif
 
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dist/rand.dist.pois/rand.dist.pois.poisson/eval.pass.cpp

 #include <random>
 #include <cassert>
 #include <vector>
 #include <numeric>
 
 #include "test_macros.h"
 
 template <class T>
-inline
-T
-sqr(T x)
-{
-    return x * x;
+T sqr(T x) {
 }
 
 void test_bad_ranges() {
   // Test cases where the mean is around the largest representable integer for
   // `result_type`. These cases don't generate valid poisson distributions, but
   // at least they don't blow up.
   std::mt19937 eng;
 
std::mt19937 eng;
     std::poisson_distribution<std::int16_t> distribution(-100);
     for (int i=0; i < 1000; ++i) {
       volatile std::int16_t res = distribution(eng);
       ((void)res);
     }
   }
 }
 
-int main(int, char**)
-{
-    {
-        typedef std::poisson_distribution<> D;
-        typedef std::minstd_rand G;
-        G g;
-        D d(2);
-        const int N = 100000;
-        std::vector<double> 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(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (unsigned 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.mean();
-        double x_var = d.mean();
-        double x_skew = 1 / std::sqrt(x_var);
-        double x_kurtosis = 1 / 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.03);
-    }
-    {
-        typedef std::poisson_distribution<> D;
-        typedef std::minstd_rand G;
-        G g;
-        D d(0.75);
-        const int N = 100000;
-        std::vector<double> 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(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (unsigned 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.mean();
-        double x_var = d.mean();
-        double x_skew = 1 / std::sqrt(x_var);
-        double x_kurtosis = 1 / 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::poisson_distribution<> D;
-        typedef std::mt19937 G;
-        G g;
-        D d(20);
-        const int N = 1000000;
-        std::vector<double> 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(), 0.0) / u.size();
-        double var = 0;
-        double skew = 0;
-        double kurtosis = 0;
-        for (unsigned 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.mean();
-        double x_var = d.mean();
-        double x_skew = 1 / std::sqrt(x_var);
-        double x_kurtosis = 1 / 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);
-    }
+template <class T>
+void tests() {
+    typedef std::poisson_distribution<T> D;
+      typename D::result_type v = d(g);
+    typedef std::poisson_distribution<T> D;
+      typename D::result_type v = d(g);
+    typedef std::poisson_distribution<T> D;
+      typename D::result_type v = d(g);
+}
 
-    test_bad_ranges();
-    return 0;
+int main(int, char**) {
+
+  tests<short>();
+  tests<int>();
+  tests<long>();
+  tests<long long>();
+
+  tests<unsigned short>();
+  tests<unsigned int>();
+  tests<unsigned long>();
+  tests<unsigned long long>();
+
+#if defined(_LIBCPP_VERSION) // extension
+  // TODO: std::poisson_distribution currently doesn't work reliably with small types.
+  // tests<int8_t>();
+  // tests<uint8_t>();
+#if !defined(TEST_HAS_NO_INT128)
+  tests<__int128_t>();
+  tests<__uint128_t>();
+#endif
+#endif
+
 }

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp

 // template<class _URNG> result_type operator()(_URNG& g);
 
 #include <random>
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
+template <class T>
+void tests() {
+    typedef long long Frequency;
     {
-    {
-        typedef std::discrete_distribution<> D;
+        typedef std::discrete_distribution<T> D;
         typedef std::minstd_rand G;
         G g;
         D d;
         const int N = 100;
-        std::vector<D::result_type> u(d.max()+1);
+        std::vector<Frequency> u(d.max()+1);
         for (int i = 0; i < N; ++i)
         {
-            D::result_type v = d(g);
+            typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
             u[v]++;
         }
         std::vector<double> prob = d.probabilities();
-        for (int i = 0; i <= d.max(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
             assert((double)u[i]/N == prob[i]);
     }
     {
-        typedef std::discrete_distribution<> D;
+        typedef std::discrete_distribution<T> D;
         typedef std::minstd_rand G;
         G g;
         double p0[] = {.3};
         D d(p0, p0+1);
         const int N = 100;
-        std::vector<D::result_type> u(d.max()+1);
+        std::vector<Frequency> u(d.max()+1);
         for (int i = 0; i < N; ++i)
         {
-            D::result_type v = d(g);
+            typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
             u[v]++;
         }
         std::vector<double> prob = d.probabilities();
-        for (int i = 0; i <= d.max(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
             assert((double)u[i]/N == prob[i]);
     }
     {
-        typedef std::discrete_distribution<> D;
+        typedef std::discrete_distribution<T> D;
         typedef std::minstd_rand G;
         G g;
         double p0[] = {.75, .25};
         D d(p0, p0+2);
         const int N = 1000000;
-        std::vector<D::result_type> u(d.max()+1);
+        std::vector<Frequency> u(d.max()+1);
         for (int i = 0; i < N; ++i)
         {
-            D::result_type v = d(g);
+            typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
             u[v]++;
         }
         std::vector<double> prob = d.probabilities();
-        for (int i = 0; i <= d.max(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
             assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
     }
     {
-        typedef std::discrete_distribution<> D;
+        typedef std::discrete_distribution<T> D;
         typedef std::minstd_rand G;
         G g;
         double p0[] = {0, 1};
         D d(p0, p0+2);
         const int N = 1000000;
-        std::vector<D::result_type> u(d.max()+1);
+        std::vector<Frequency> u(d.max()+1);
         for (int i = 0; i < N; ++i)
         {
-            D::result_type v = d(g);
+            typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
             u[v]++;
         }
         std::vector<double> prob = d.probabilities();
         assert((double)u[0]/N == prob[0]);
         assert((double)u[1]/N == prob[1]);
     }
     {
-        typedef std::discrete_distribution<> D;
+        typedef std::discrete_distribution<T> D;
         typedef std::minstd_rand G;
         G g;
         double p0[] = {1, 0};
         D d(p0, p0+2);
         const int N = 1000000;
-        std::vector<D::result_type> u(d.max()+1);
+        std::vector<Frequency> u(d.max()+1);
         for (int i = 0; i < N; ++i)
         {
-            D::result_type v = d(g);
+            typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
             u[v]++;
         }
         std::vector<double> prob = d.probabilities();
         assert((double)u[0]/N == prob[0]);
         assert((double)u[1]/N == prob[1]);
     }
     {
-        typedef std::discrete_distribution<> D;
+        typedef std::discrete_distribution<T> D;
         typedef std::minstd_rand G;
         G g;
         double p0[] = {.3, .1, .6};
         D d(p0, p0+3);
         const int N = 10000000;
-        std::vector<D::result_type> u(d.max()+1);
+        std::vector<Frequency> u(d.max()+1);
         for (int i = 0; i < N; ++i)
         {
-            D::result_type v = d(g);
+            typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
             u[v]++;
         }
         std::vector<double> prob = d.probabilities();
-        for (int i = 0; i <= d.max(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
             assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
     }
     {
-        typedef std::discrete_distribution<> D;
+        typedef std::discrete_distribution<T> D;
         typedef std::minstd_rand G;
         G g;
         double p0[] = {0, 25, 75};
         D d(p0, p0+3);
         const int N = 1000000;
-        std::vector<D::result_type> u(d.max()+1);
+        std::vector<Frequency> u(d.max()+1);
         for (int i = 0; i < N; ++i)
         {
-            D::result_type v = d(g);
+            typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
             u[v]++;
         }
         std::vector<double> prob = d.probabilities();
-        for (int i = 0; i <= d.max(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
             if (prob[i] != 0)
                 assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
             else
                 assert(u[i] == 0);
     }
     {
-        typedef std::discrete_distribution<> D;
+        typedef std::discrete_distribution<T> D;
         typedef std::minstd_rand G;
         G g;
         double p0[] = {25, 0, 75};
         D d(p0, p0+3);
         const int N = 1000000;
-        std::vector<D::result_type> u(d.max()+1);
+        std::vector<Frequency> u(d.max()+1);
         for (int i = 0; i < N; ++i)
         {
-            D::result_type v = d(g);
+            typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
             u[v]++;
         }
         std::vector<double> prob = d.probabilities();
-        for (int i = 0; i <= d.max(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
             if (prob[i] != 0)
                 assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
             else
                 assert(u[i] == 0);
     }
     {
-        typedef std::discrete_distribution<> D;
+        typedef std::discrete_distribution<T> D;
         typedef std::minstd_rand G;
         G g;
         double p0[] = {25, 75, 0};
         D d(p0, p0+3);
         const int N = 1000000;
-        std::vector<D::result_type> u(d.max()+1);
+        std::vector<Frequency> u(d.max()+1);
         for (int i = 0; i < N; ++i)
         {
-            D::result_type v = d(g);
+            typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
             u[v]++;
         }
         std::vector<double> prob = d.probabilities();
-        for (int i = 0; i <= d.max(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
             if (prob[i] != 0)
                 assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
             else
                 assert(u[i] == 0);
     }
     {
-        typedef std::discrete_distribution<> D;
+        typedef std::discrete_distribution<T> D;
         typedef std::minstd_rand G;
         G g;
         double p0[] = {0, 0, 1};
         D d(p0, p0+3);
         const int N = 100;
-        std::vector<D::result_type> u(d.max()+1);
+        std::vector<Frequency> u(d.max()+1);
         for (int i = 0; i < N; ++i)
         {
-            D::result_type v = d(g);
+            typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
             u[v]++;
         }
         std::vector<double> prob = d.probabilities();
-        for (int i = 0; i <= d.max(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
             if (prob[i] != 0)
                 assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
             else
                 assert(u[i] == 0);
     }
     {
-        typedef std::discrete_distribution<> D;
+        typedef std::discrete_distribution<T> D;
         typedef std::minstd_rand G;
         G g;
         double p0[] = {0, 1, 0};
         D d(p0, p0+3);
         const int N = 100;
-        std::vector<D::result_type> u(d.max()+1);
+        std::vector<Frequency> u(d.max()+1);
         for (int i = 0; i < N; ++i)
         {
-            D::result_type v = d(g);
+            typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
             u[v]++;
         }
         std::vector<double> prob = d.probabilities();
-        for (int i = 0; i <= d.max(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
             if (prob[i] != 0)
                 assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
             else
                 assert(u[i] == 0);
     }
     {
-        typedef std::discrete_distribution<> D;
+        typedef std::discrete_distribution<T> D;
         typedef std::minstd_rand G;
         G g;
         double p0[] = {1, 0, 0};
         D d(p0, p0+3);
         const int N = 100;
-        std::vector<D::result_type> u(d.max()+1);
+        std::vector<Frequency> u(d.max()+1);
         for (int i = 0; i < N; ++i)
         {
-            D::result_type v = d(g);
+            typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
             u[v]++;
         }
         std::vector<double> prob = d.probabilities();
-        for (int i = 0; i <= d.max(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
             if (prob[i] != 0)
                 assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
             else
                 assert(u[i] == 0);
     }
     {
-        typedef std::discrete_distribution<> D;
+        typedef std::discrete_distribution<T> D;
         typedef std::minstd_rand G;
         G g;
         double p0[] = {33, 0, 0, 67};
         D d(p0, p0+3);
         const int N = 1000000;
-        std::vector<D::result_type> u(d.max()+1);
+        std::vector<Frequency> u(d.max()+1);
         for (int i = 0; i < N; ++i)
         {
-            D::result_type v = d(g);
+            typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
             u[v]++;
         }
         std::vector<double> prob = d.probabilities();
-        for (int i = 0; i <= d.max(); ++i)
+        for (unsigned i = 0; i < u.size(); ++i)
             if (prob[i] != 0)
                 assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
             else
                 assert(u[i] == 0);
     }
+}
+
+int main(int, char**) {
+    tests<short>();
+    tests<int>();
+    tests<long>();
+    tests<long long>();
+
+    tests<unsigned short>();
+    tests<unsigned int>();
+    tests<unsigned long>();
+    tests<unsigned long long>();
+
+#if defined(_LIBCPP_VERSION) // extension
+    tests<int8_t>();
+    tests<uint8_t>();
+#if !defined(TEST_HAS_NO_INT128)
+    tests<__int128_t>();
+    tests<__uint128_t>();
+#endif
+#endif
 
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp

 
 // The __int128 conversions to/from floating point crash on MinGW on x86_64.
 // This is fixed in Clang 14 by https://reviews.llvm.org/D110413.
 #if defined(__x86_64__) && defined(__MINGW32__) && defined(__clang_major__) && __clang_major__ < 14
  #define TEST_BUGGY_I128_FP
 #endif
 
 template <class T>
-T sqr(T x)
-{
+T sqr(T x) {
     return x * x;
 }
 
 template <class ResultType, class EngineType>
-void test_statistics(ResultType a, ResultType b)
-{
+void test_statistics(ResultType a, ResultType b) {
     ASSERT_SAME_TYPE(typename std::uniform_int_distribution<ResultType>::result_type, ResultType);
 
     EngineType g;
     std::uniform_int_distribution<ResultType> dist(a, b);
     assert(dist.a() == a);
     assert(dist.b() == b);
     std::vector<ResultType> u;
     for (int i = 0; i < 10000; ++i) {
void test_statistics(ResultType a, ResultType b) {
 
     assert(std::abs(mean - expected_mean) < range / 100);
     assert(std::abs(var - expected_var) < expected_var / 50);
     assert(-0.1 < skew && skew < 0.1);
     assert(1.6 < kurtosis && kurtosis < 2.0);
 }
 
 template <class ResultType, class EngineType>
-void test_statistics()
-{
+void test_statistics() {
     test_statistics<ResultType, EngineType>(0, std::numeric_limits<ResultType>::max());
 }
 
 int main(int, char**)
 {
     test_statistics<int, std::minstd_rand0>();
     test_statistics<int, std::minstd_rand>();
     test_statistics<int, std::mt19937>();
int main(int, char**)
 
     test_statistics<unsigned short, std::minstd_rand0>();
     test_statistics<unsigned int, std::minstd_rand0>();
     test_statistics<unsigned long, std::minstd_rand0>();
     test_statistics<unsigned long long, std::minstd_rand0>();
 
     test_statistics<short, std::minstd_rand0>(SHRT_MIN, SHRT_MAX);
 
-    // http://eel.is/c++draft/rand.req#genl-1.5
-    // The effect of instantiating a template that has a parameter
-    // named IntType is undefined unless the corresponding template
-    // argument is cv-unqualified and is one of short, int, long,
-    // long long, unsigned short, unsigned int, unsigned long,
-    // or unsigned long long.
-    // (We support __int128 as an extension.)
+#if defined(_LIBCPP_VERSION) // extension
+    test_statistics<int8_t, std::minstd_rand0>();
+    test_statistics<uint8_t, std::minstd_rand0>();
 
 #if !defined(TEST_HAS_NO_INT128) && !defined(TEST_BUGGY_I128_FP)
     test_statistics<__int128_t, std::minstd_rand0>();
     test_statistics<__uint128_t, std::minstd_rand0>();
 
     test_statistics<__int128_t, std::minstd_rand0>(-100, 900);
     test_statistics<__int128_t, std::minstd_rand0>(0, UINT64_MAX);
     test_statistics<__int128_t, std::minstd_rand0>(std::numeric_limits<__int128_t>::min(), std::numeric_limits<__int128_t>::max());
     test_statistics<__uint128_t, std::minstd_rand0>(0, UINT64_MAX);
 #endif
+#endif
 
     return 0;
 }