[libcxx] [test] Rename d to dbl in order to avoid shadowing distributions named d.

[STL_MSFT]

Summary

Rename d to dbl in order to avoid shadowing distributions named d.

This was almost always declared as double d, except in rand.dist.uni.real where it was D::result_type d (still of type double).

Fixes MSVC warning C4456 "declaration of 'd' hides previous local declaration".

[EricWF]

r272619.

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

int main()
             u.push_back(d(g));
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.p();
int main()
             u.push_back(d(g));
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.p();

test/std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bernoulli/eval_param.pass.cpp

int main()
             u.push_back(d(g, p));
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.p();
int main()
             u.push_back(d(g, p));
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.p();

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

int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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
//        assert(kurtosis == x_kurtosis);
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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
//        assert(kurtosis == x_kurtosis);
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
//        assert(kurtosis == x_kurtosis);
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
//        assert(kurtosis == x_kurtosis);
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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
//        assert(kurtosis == x_kurtosis);
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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
//        assert(kurtosis == x_kurtosis);
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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

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

int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.t() * p.p();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.t() * p.p();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.t() * p.p();

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

int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();

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

int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 - p.p()) / p.p();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 - p.p()) / p.p();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 - p.p()) / p.p();

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

int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();

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

int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.k() * (1 - p.p()) / p.p();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.k() * (1 - p.p()) / p.p();
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.k() * (1 - p.p()) / p.p();

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

int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.n();
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.n();
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.n();

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

int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.n();
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.n();
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.n();

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

int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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);
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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);
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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);
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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);
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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);

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

int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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);
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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);
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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);
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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);
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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);

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

int main()
         for (int i = 0; i < N; ++i)
             u.push_back(d(g));
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();

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

int main()
         for (int i = 0; i < N; ++i)
             u.push_back(d(g, p));
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.mean();

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

int main()
         for (int i = 0; i < N; ++i)
             u.push_back(d(g));
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = 0;
int main()
         for (int i = 0; i < N; ++i)
             u.push_back(d(g));
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = 0;
int main()
         for (int i = 0; i < N; ++i)
             u.push_back(d(g));
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = 0;

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

int main()
         for (int i = 0; i < N; ++i)
             u.push_back(d(g, p));
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = 0;
int main()
         for (int i = 0; i < N; ++i)
             u.push_back(d(g, p));
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = 0;
int main()
         for (int i = 0; i < N; ++i)
             u.push_back(d(g, p));
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = 0;

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

int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.lambda();
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.lambda();
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.lambda();

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

int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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/p.lambda();

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

int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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;
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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;
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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;
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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;

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

int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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;
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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;
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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;
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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;

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

int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.alpha() * d.beta();
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.alpha() * d.beta();
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.alpha() * d.beta();

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

int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.alpha() * p.beta();
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.alpha() * p.beta();
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.alpha() * p.beta();

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

int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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();

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

int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.mean();
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.mean();
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.mean();

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

int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.b() * std::tgamma(1 + 1/d.a());
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.b() * std::tgamma(1 + 1/d.a());
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.b() * std::tgamma(1 + 1/d.a());

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

int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.b() * std::tgamma(1 + 1/p.a());
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.b() * std::tgamma(1 + 1/p.a());
int main()
             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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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.b() * std::tgamma(1 + 1/p.a());

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

int main()
             {
                 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 d = (*j - mean);
-                    double d2 = sqr(d);
+                    double dbl = (*j - mean);
+                    double d2 = sqr(dbl);
                     var += d2;
-                    skew += d * 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;
int main()
             {
                 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 d = (*j - mean);
-                    double d2 = sqr(d);
+                    double dbl = (*j - mean);
+                    double d2 = sqr(dbl);
                     var += d2;
-                    skew += d * 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;
int main()
             {
                 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 d = (*j - mean);
-                    double d2 = sqr(d);
+                    double dbl = (*j - mean);
+                    double d2 = sqr(dbl);
                     var += d2;
-                    skew += d * 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;
int main()
             {
                 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 d = (*j - mean);
-                    double d2 = sqr(d);
+                    double dbl = (*j - mean);
+                    double d2 = sqr(dbl);
                     var += d2;
-                    skew += d * 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;
int main()
             {
                 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 d = (*j - mean);
-                    double d2 = sqr(d);
+                    double dbl = (*j - mean);
+                    double d2 = sqr(dbl);
                     var += d2;
-                    skew += d * 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;
int main()
             {
                 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 d = (*j - mean);
-                    double d2 = sqr(d);
+                    double dbl = (*j - mean);
+                    double d2 = sqr(dbl);
                     var += d2;
-                    skew += d * 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;
int main()
             {
                 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 d = (*j - mean);
-                    double d2 = sqr(d);
+                    double dbl = (*j - mean);
+                    double d2 = sqr(dbl);
                     var += d2;
-                    skew += d * 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;
int main()
             {
                 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 d = (*j - mean);
-                    double d2 = sqr(d);
+                    double dbl = (*j - mean);
+                    double d2 = sqr(dbl);
                     var += d2;
-                    skew += d * 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;
int main()
             {
                 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 d = (*j - mean);
-                    double d2 = sqr(d);
+                    double dbl = (*j - mean);
+                    double d2 = sqr(dbl);
                     var += d2;
-                    skew += d * 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;
int main()
             {
                 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 d = (*j - mean);
-                    double d2 = sqr(d);
+                    double dbl = (*j - mean);
+                    double d2 = sqr(dbl);
                     var += d2;
-                    skew += d * 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;
int main()
             {
                 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 d = (*j - mean);
-                    double d2 = sqr(d);
+                    double dbl = (*j - mean);
+                    double d2 = sqr(dbl);
                     var += d2;
-                    skew += d * 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;

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

int main()
             {
                 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 d = (*j - mean);
-                    double d2 = sqr(d);
+                    double dbl = (*j - mean);
+                    double d2 = sqr(dbl);
                     var += d2;
-                    skew += d * 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;

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

int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = ((double)d.a() + d.b()) / 2;
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = ((double)d.a() + d.b()) / 2;
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = ((double)d.a() + d.b()) / 2;
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = ((double)d.a() + d.b()) / 2;
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = ((double)d.a() + d.b()) / 2;
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = ((double)d.a() + d.b()) / 2;
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = ((double)d.a() + d.b()) / 2;
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = ((double)d.a() + d.b()) / 2;
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = ((double)d.a() + d.b()) / 2;
int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = ((double)d.a() + d.b()) / 2;

test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval_param.pass.cpp

int main()
         }
         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 d = (u[i] - mean);
-            double d2 = sqr(d);
+            double dbl = (u[i] - mean);
+            double d2 = sqr(dbl);
             var += d2;
-            skew += d * 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 = ((double)p.a() + p.b()) / 2;

test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp

int main()
         }
         D::result_type mean = std::accumulate(u.begin(), u.end(),
                                               D::result_type(0)) / u.size();
         D::result_type var = 0;
         D::result_type skew = 0;
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
         D::result_type dev = std::sqrt(var);
         skew /= u.size() * dev * var;
         kurtosis /= u.size() * var * var;
         kurtosis -= 3;
         D::result_type x_mean = (d.a() + d.b()) / 2;
int main()
         }
         D::result_type mean = std::accumulate(u.begin(), u.end(),
                                               D::result_type(0)) / u.size();
         D::result_type var = 0;
         D::result_type skew = 0;
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
         D::result_type dev = std::sqrt(var);
         skew /= u.size() * dev * var;
         kurtosis /= u.size() * var * var;
         kurtosis -= 3;
         D::result_type x_mean = (d.a() + d.b()) / 2;
int main()
         }
         D::result_type mean = std::accumulate(u.begin(), u.end(),
                                               D::result_type(0)) / u.size();
         D::result_type var = 0;
         D::result_type skew = 0;
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
         D::result_type dev = std::sqrt(var);
         skew /= u.size() * dev * var;
         kurtosis /= u.size() * var * var;
         kurtosis -= 3;
         D::result_type x_mean = (d.a() + d.b()) / 2;
int main()
         }
         D::result_type mean = std::accumulate(u.begin(), u.end(),
                                               D::result_type(0)) / u.size();
         D::result_type var = 0;
         D::result_type skew = 0;
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
         D::result_type dev = std::sqrt(var);
         skew /= u.size() * dev * var;
         kurtosis /= u.size() * var * var;
         kurtosis -= 3;
         D::result_type x_mean = (d.a() + d.b()) / 2;
int main()
         }
         D::result_type mean = std::accumulate(u.begin(), u.end(),
                                               D::result_type(0)) / u.size();
         D::result_type var = 0;
         D::result_type skew = 0;
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
         D::result_type dev = std::sqrt(var);
         skew /= u.size() * dev * var;
         kurtosis /= u.size() * var * var;
         kurtosis -= 3;
         D::result_type x_mean = (d.a() + d.b()) / 2;
int main()
         }
         D::result_type mean = std::accumulate(u.begin(), u.end(),
                                               D::result_type(0)) / u.size();
         D::result_type var = 0;
         D::result_type skew = 0;
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
         D::result_type dev = std::sqrt(var);
         skew /= u.size() * dev * var;
         kurtosis /= u.size() * var * var;
         kurtosis -= 3;
         D::result_type x_mean = (d.a() + d.b()) / 2;
int main()
         }
         D::result_type mean = std::accumulate(u.begin(), u.end(),
                                               D::result_type(0)) / u.size();
         D::result_type var = 0;
         D::result_type skew = 0;
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
         D::result_type dev = std::sqrt(var);
         skew /= u.size() * dev * var;
         kurtosis /= u.size() * var * var;
         kurtosis -= 3;
         D::result_type x_mean = (d.a() + d.b()) / 2;
int main()
         }
         D::result_type mean = std::accumulate(u.begin(), u.end(),
                                               D::result_type(0)) / u.size();
         D::result_type var = 0;
         D::result_type skew = 0;
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
         D::result_type dev = std::sqrt(var);
         skew /= u.size() * dev * var;
         kurtosis /= u.size() * var * var;
         kurtosis -= 3;
         D::result_type x_mean = (d.a() + d.b()) / 2;
int main()
         }
         D::result_type mean = std::accumulate(u.begin(), u.end(),
                                               D::result_type(0)) / u.size();
         D::result_type var = 0;
         D::result_type skew = 0;
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
         D::result_type dev = std::sqrt(var);
         skew /= u.size() * dev * var;
         kurtosis /= u.size() * var * var;
         kurtosis -= 3;
         D::result_type x_mean = (d.a() + d.b()) / 2;
int main()
         }
         D::result_type mean = std::accumulate(u.begin(), u.end(),
                                               D::result_type(0)) / u.size();
         D::result_type var = 0;
         D::result_type skew = 0;
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
         D::result_type dev = std::sqrt(var);
         skew /= u.size() * dev * var;
         kurtosis /= u.size() * var * var;
         kurtosis -= 3;
         D::result_type x_mean = (d.a() + d.b()) / 2;
int main()
         }
         D::result_type mean = std::accumulate(u.begin(), u.end(),
                                               D::result_type(0)) / u.size();
         D::result_type var = 0;
         D::result_type skew = 0;
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
         D::result_type dev = std::sqrt(var);
         skew /= u.size() * dev * var;
         kurtosis /= u.size() * var * var;
         kurtosis -= 3;
         D::result_type x_mean = (d.a() + d.b()) / 2;

test/std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval_param.pass.cpp

int main()
         }
         D::result_type mean = std::accumulate(u.begin(), u.end(),
                                               D::result_type(0)) / u.size();
         D::result_type var = 0;
         D::result_type skew = 0;
         D::result_type kurtosis = 0;
         for (int i = 0; i < u.size(); ++i)
         {
-            D::result_type d = (u[i] - mean);
-            D::result_type d2 = sqr(d);
+            D::result_type dbl = (u[i] - mean);
+            D::result_type d2 = sqr(dbl);
             var += d2;
-            skew += d * d2;
+            skew += dbl * d2;
             kurtosis += d2 * d2;
         }
         var /= u.size();
         D::result_type dev = std::sqrt(var);
         skew /= u.size() * dev * var;
         kurtosis /= u.size() * var * var;
         kurtosis -= 3;
         D::result_type x_mean = (p.a() + p.b()) / 2;