[libc++] Fix warning C4244 in `std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp`

[fsb4000]

Summary

frederick-vs-ja noticed that https://github.com/microsoft/STL/pull/2976#issuecomment-1201926893 while we are working on updating LLVM submodule for MS STL

C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(33): error C2220: the following warning is treated as an error
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(287): note: see reference to function template instantiation 'void tests<__int64>(void)' being compiled
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(33): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(38): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(51): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(56): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(69): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(74): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(87): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(92): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(105): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(110): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(123): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(128): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(141): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(146): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(162): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(167): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(183): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(188): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(204): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(209): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(225): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(230): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(246): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(251): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(267): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
C:\Dev\STL\llvm-project\libcxx\test\std\numerics\rand\rand.dist\rand.dist.samp\rand.dist.samp.discrete\eval.pass.cpp(272): warning C4244: 'argument': conversion from '__int64' to 'const unsigned int', possible loss of data
....

[ldionne]

Nice catch, thanks.

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

 void tests() {
     typedef long long Frequency;
     {
         typedef std::discrete_distribution<T> D;
         typedef std::minstd_rand G;
         G g;
         D d;
         const int N = 100;
-        std::vector<Frequency> u(d.max()+1);
+        std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+        assert(u.max_size() > static_cast<unsigned long long>(d.max()));
         for (int i = 0; i < N; ++i)
         {
             typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
-            u[v]++;
+            u[static_cast<std::size_t>(v)]++;
         }
         std::vector<double> prob = d.probabilities();
         for (unsigned i = 0; i < u.size(); ++i)
             assert((double)u[i]/N == prob[i]);
     }
     {
         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<Frequency> u(d.max()+1);
+        std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+        assert(u.max_size() > static_cast<unsigned long long>(d.max()));
         for (int i = 0; i < N; ++i)
         {
             typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
-            u[v]++;
+            u[static_cast<std::size_t>(v)]++;
         }
         std::vector<double> prob = d.probabilities();
         for (unsigned i = 0; i < u.size(); ++i)
             assert((double)u[i]/N == prob[i]);
     }
     {
         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<Frequency> u(d.max()+1);
+        std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+        assert(u.max_size() > static_cast<unsigned long long>(d.max()));
         for (int i = 0; i < N; ++i)
         {
             typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
-            u[v]++;
+            u[static_cast<std::size_t>(v)]++;
         }
         std::vector<double> prob = d.probabilities();
         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<T> D;
         typedef std::minstd_rand G;
         G g;
         double p0[] = {0, 1};
         D d(p0, p0+2);
         const int N = 1000000;
-        std::vector<Frequency> u(d.max()+1);
+        std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+        assert(u.max_size() > static_cast<unsigned long long>(d.max()));
         for (int i = 0; i < N; ++i)
         {
             typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
-            u[v]++;
+            u[static_cast<std::size_t>(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<T> D;
         typedef std::minstd_rand G;
         G g;
         double p0[] = {1, 0};
         D d(p0, p0+2);
         const int N = 1000000;
-        std::vector<Frequency> u(d.max()+1);
+        std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+        assert(u.max_size() > static_cast<unsigned long long>(d.max()));
         for (int i = 0; i < N; ++i)
         {
             typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
-            u[v]++;
+            u[static_cast<std::size_t>(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<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<Frequency> u(d.max()+1);
+        std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+        assert(u.max_size() > static_cast<unsigned long long>(d.max()));
         for (int i = 0; i < N; ++i)
         {
             typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
-            u[v]++;
+            u[static_cast<std::size_t>(v)]++;
         }
         std::vector<double> prob = d.probabilities();
         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<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<Frequency> u(d.max()+1);
+        std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+        assert(u.max_size() > static_cast<unsigned long long>(d.max()));
         for (int i = 0; i < N; ++i)
         {
             typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
-            u[v]++;
+            u[static_cast<std::size_t>(v)]++;
         }
         std::vector<double> prob = d.probabilities();
         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<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<Frequency> u(d.max()+1);
+        std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+        assert(u.max_size() > static_cast<unsigned long long>(d.max()));
         for (int i = 0; i < N; ++i)
         {
             typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
-            u[v]++;
+            u[static_cast<std::size_t>(v)]++;
         }
         std::vector<double> prob = d.probabilities();
         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<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<Frequency> u(d.max()+1);
+        std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+        assert(u.max_size() > static_cast<unsigned long long>(d.max()));
         for (int i = 0; i < N; ++i)
         {
             typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
-            u[v]++;
+            u[static_cast<std::size_t>(v)]++;
         }
         std::vector<double> prob = d.probabilities();
         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<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<Frequency> u(d.max()+1);
+        std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+        assert(u.max_size() > static_cast<unsigned long long>(d.max()));
         for (int i = 0; i < N; ++i)
         {
             typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
-            u[v]++;
+            u[static_cast<std::size_t>(v)]++;
         }
         std::vector<double> prob = d.probabilities();
         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<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<Frequency> u(d.max()+1);
+        std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+        assert(u.max_size() > static_cast<unsigned long long>(d.max()));
         for (int i = 0; i < N; ++i)
         {
             typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
-            u[v]++;
+            u[static_cast<std::size_t>(v)]++;
         }
         std::vector<double> prob = d.probabilities();
         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<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<Frequency> u(d.max()+1);
+        std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+        assert(u.max_size() > static_cast<unsigned long long>(d.max()));
         for (int i = 0; i < N; ++i)
         {
             typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
-            u[v]++;
+            u[static_cast<std::size_t>(v)]++;
         }
         std::vector<double> prob = d.probabilities();
         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<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<Frequency> u(d.max()+1);
+        std::vector<Frequency> u(static_cast<std::size_t>(d.max()+1));
+        assert(u.max_size() > static_cast<unsigned long long>(d.max()));
         for (int i = 0; i < N; ++i)
         {
             typename D::result_type v = d(g);
             assert(d.min() <= v && v <= d.max());
-            u[v]++;
+            u[static_cast<std::size_t>(v)]++;
         }
         std::vector<double> prob = d.probabilities();
         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);
     }