[libcxx] [test] Initialize local doubles to NaN.

[STL_MSFT]

Summary

[libcxx] [test] Initialize local doubles to NaN.

Fixes MSVC "warning C4701: potentially uninitialized local variable 'meow' used".

[rsmith]

I don't know how the libc++ folks feel about this, but our usual policy in Clang and LLVM is that we don't add bogus initializers to shut up incorrect "maybe used uninitialized" compiler warnings, because these initializers prevent tools like MSan and valgrind from catching the bug if the variable ever is actually used uninitialized. For this reason, we turn off the portion of GCC's -Wuninitialized warning that has false positives too.

[STL_MSFT]

I'd be happy to deal with this in another way. Would you accept _MSC_VER-guarded pragmas to silence such warnings? I didn't see an easy way to rework the logic here so that the variables are obviously initialized on every codepath, which would be the ideal pragma-less solution.

[howard.hinnant]

When in doubt, I find initializing to nan a safe thing to do. Either the code is correct, or the nan will find the bug.

[STL_MSFT]

Now I'm using NaN instead of 0.0 for the initializations, as suggested by Howard.

[EricWF]

*disclaimer* I have no idea what I'm talking about.

Is there any reason why using signalling NaN would be better than quiet NaN in this case?

[STL_MSFT]

According to my equally vague understanding, a quiet NaN (if used in operations, instead of being overwritten with something valid) will silently propagate down to the assert, which will complain that it's not equal to whatever you were expecting. That would detect any unintentional use of the NaN-initialized value.

A signaling NaN will (I think) raise an FP exception when you try to do anything with it, which may not be treated similarly by your test harness. (I'm not a good person to answer this question, as C1XX has bug/limitations with returning signaling NaNs, to the point where this function in numeric_limits is essentially useless.)

[howard.hinnant]

A quiet nan is the right tool. A signaling nan is nothing more than a 40-year-old design flaw. A quiet nan is "sticky" in that if you try to compute with it, the result is quiet nan. But you can assign a valid number to something containing a quiet nan. So if your answer has nans in it, you know you didn't initialize something properly somewhere.

[EricWF]

I have no objections to this change. Howard seems to agree.

[EricWF]

r268285.

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

 #include <iostream>
 
 #include <random>
 #include <algorithm>
 #include <vector>
 #include <iterator>
 #include <numeric>
 #include <cassert>
+#include <limits>
 
 template <class T>
 inline
 T
 sqr(T x)
 {
     return x*x;
 }
int main()
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
             assert(d.min() <= v && v < d.max());
             u.push_back(v);
         }
         std::sort(u.begin(), u.end());
         int kp = -1;
-        double a;
-        double m;
-        double bk;
-        double c;
+        double a = std::numeric_limits<double>::quiet_NaN();
+        double m = std::numeric_limits<double>::quiet_NaN();
+        double bk = std::numeric_limits<double>::quiet_NaN();
+        double c = std::numeric_limits<double>::quiet_NaN();
         std::vector<double> areas(Np);
         double S = 0;
         for (int i = 0; i < areas.size(); ++i)
         {
             areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
             S += areas[i];
         }
         for (int i = 0; i < areas.size(); ++i)
int main()
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
             assert(d.min() <= v && v < d.max());
             u.push_back(v);
         }
         std::sort(u.begin(), u.end());
         int kp = -1;
-        double a;
-        double m;
-        double bk;
-        double c;
+        double a = std::numeric_limits<double>::quiet_NaN();
+        double m = std::numeric_limits<double>::quiet_NaN();
+        double bk = std::numeric_limits<double>::quiet_NaN();
+        double c = std::numeric_limits<double>::quiet_NaN();
         std::vector<double> areas(Np);
         double S = 0;
         for (int i = 0; i < areas.size(); ++i)
         {
             areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
             S += areas[i];
         }
         for (int i = 0; i < areas.size(); ++i)
int main()
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
             assert(d.min() <= v && v < d.max());
             u.push_back(v);
         }
         std::sort(u.begin(), u.end());
         int kp = -1;
-        double a;
-        double m;
-        double bk;
-        double c;
+        double a = std::numeric_limits<double>::quiet_NaN();
+        double m = std::numeric_limits<double>::quiet_NaN();
+        double bk = std::numeric_limits<double>::quiet_NaN();
+        double c = std::numeric_limits<double>::quiet_NaN();
         std::vector<double> areas(Np);
         double S = 0;
         for (int i = 0; i < areas.size(); ++i)
         {
             areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
             S += areas[i];
         }
         for (int i = 0; i < areas.size(); ++i)
int main()
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
             assert(d.min() <= v && v < d.max());
             u.push_back(v);
         }
         std::sort(u.begin(), u.end());
         int kp = -1;
-        double a;
-        double m;
-        double bk;
-        double c;
+        double a = std::numeric_limits<double>::quiet_NaN();
+        double m = std::numeric_limits<double>::quiet_NaN();
+        double bk = std::numeric_limits<double>::quiet_NaN();
+        double c = std::numeric_limits<double>::quiet_NaN();
         std::vector<double> areas(Np);
         double S = 0;
         for (int i = 0; i < areas.size(); ++i)
         {
             areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
             S += areas[i];
         }
         for (int i = 0; i < areas.size(); ++i)
int main()
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
             assert(d.min() <= v && v < d.max());
             u.push_back(v);
         }
         std::sort(u.begin(), u.end());
         int kp = -1;
-        double a;
-        double m;
-        double bk;
-        double c;
+        double a = std::numeric_limits<double>::quiet_NaN();
+        double m = std::numeric_limits<double>::quiet_NaN();
+        double bk = std::numeric_limits<double>::quiet_NaN();
+        double c = std::numeric_limits<double>::quiet_NaN();
         std::vector<double> areas(Np);
         double S = 0;
         for (int i = 0; i < areas.size(); ++i)
         {
             areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
             S += areas[i];
         }
         for (int i = 0; i < areas.size(); ++i)
int main()
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g);
             assert(d.min() <= v && v < d.max());
             u.push_back(v);
         }
         std::sort(u.begin(), u.end());
         int kp = -1;
-        double a;
-        double m;
-        double bk;
-        double c;
+        double a = std::numeric_limits<double>::quiet_NaN();
+        double m = std::numeric_limits<double>::quiet_NaN();
+        double bk = std::numeric_limits<double>::quiet_NaN();
+        double c = std::numeric_limits<double>::quiet_NaN();
         std::vector<double> areas(Np);
         double S = 0;
         for (int i = 0; i < areas.size(); ++i)
         {
             areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
             S += areas[i];
         }
         for (int i = 0; i < areas.size(); ++i)

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

 // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
 
 #include <random>
 #include <vector>
 #include <iterator>
 #include <numeric>
 #include <algorithm>   // for sort
 #include <cassert>
+#include <limits>
 
 template <class T>
 inline
 T
 sqr(T x)
 {
     return x*x;
 }
int main()
         for (int i = 0; i < N; ++i)
         {
             D::result_type v = d(g, pa);
             assert(10 <= v && v < 17);
             u.push_back(v);
         }
         std::sort(u.begin(), u.end());
         int kp = -1;
-        double a;
-        double m;
-        double bk;
-        double c;
+        double a = std::numeric_limits<double>::quiet_NaN();
+        double m = std::numeric_limits<double>::quiet_NaN();
+        double bk = std::numeric_limits<double>::quiet_NaN();
+        double c = std::numeric_limits<double>::quiet_NaN();
         std::vector<double> areas(Np);
         double S = 0;
         for (int i = 0; i < areas.size(); ++i)
         {
             areas[i] = (p[i]+p[i+1])*(b[i+1]-b[i])/2;
             S += areas[i];
         }
         for (int i = 0; i < areas.size(); ++i)