[libcxx-commits] [libcxx] r369429 - [libc++] Avoid implicit conversion warning in a <random> test

[Louis Dionne via libcxx-commits]

Author: ldionne
Date: Tue Aug 20 12:28:26 2019
New Revision: 369429

URL: http://llvm.org/viewvc/llvm-project?rev=369429&view=rev
Log:
[libc++] Avoid implicit conversion warning in a <random> test

By stashing the computation of `E::max() - E::min()` in a variable, we
avoid the warning introduced in r367497. Note that we use `auto` to
avoid having to deduce the type of the computation, which is not a
problem since Clang provides `auto` as an extension even in C++03 (and
we disable warnings related to using C++11 extensions in the test suite).

Modified:
    libcxx/trunk/test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp

Modified: libcxx/trunk/test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp?rev=369429&r1=369428&r2=369429&view=diff
==============================================================================
--- libcxx/trunk/test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp (original)
+++ libcxx/trunk/test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp Tue Aug 20 12:28:26 2019
@@ -19,85 +19,78 @@
 
 int main(int, char**)
 {
+    typedef std::minstd_rand0 E;
+    auto range = E::max() - E::min();
+
     {
-        typedef std::minstd_rand0 E;
         typedef float F;
         E r;
         F f = std::generate_canonical<F, 0>(r);
-        assert(f == truncate_fp((16807 - E::min()) / (E::max() - E::min() + F(1))));
+        assert(f == truncate_fp((16807 - E::min()) / (range + F(1))));
     }
     {
-        typedef std::minstd_rand0 E;
         typedef float F;
         E r;
         F f = std::generate_canonical<F, 1>(r);
-        assert(f == truncate_fp((16807 - E::min()) / (E::max() - E::min() + F(1))));
+        assert(f == truncate_fp((16807 - E::min()) / (range + F(1))));
     }
     {
-        typedef std::minstd_rand0 E;
         typedef float F;
         E r;
         F f = std::generate_canonical<F, std::numeric_limits<F>::digits - 1>(r);
-        assert(f == truncate_fp((16807 - E::min()) / (E::max() - E::min() + F(1))));
+        assert(f == truncate_fp((16807 - E::min()) / (range + F(1))));
     }
     {
-        typedef std::minstd_rand0 E;
         typedef float F;
         E r;
         F f = std::generate_canonical<F, std::numeric_limits<F>::digits>(r);
-        assert(f == truncate_fp((16807 - E::min()) / (E::max() - E::min() + F(1))));
+        assert(f == truncate_fp((16807 - E::min()) / (range + F(1))));
     }
     {
-        typedef std::minstd_rand0 E;
         typedef float F;
         E r;
         F f = std::generate_canonical<F, std::numeric_limits<F>::digits + 1>(r);
-        assert(f == truncate_fp((16807 - E::min()) / (E::max() - E::min() + F(1))));
+        assert(f == truncate_fp((16807 - E::min()) / (range + F(1))));
     }
 
     {
-        typedef std::minstd_rand0 E;
         typedef double F;
         E r;
         F f = std::generate_canonical<F, 0>(r);
-        assert(f == truncate_fp((16807 - E::min()) / (E::max() - E::min() + F(1))));
+        assert(f == truncate_fp((16807 - E::min()) / (range + F(1))));
     }
     {
-        typedef std::minstd_rand0 E;
         typedef double F;
         E r;
         F f = std::generate_canonical<F, 1>(r);
-        assert(f == truncate_fp((16807 - E::min()) / (E::max() - E::min() + F(1))));
+        assert(f == truncate_fp((16807 - E::min()) / (range + F(1))));
     }
     {
-        typedef std::minstd_rand0 E;
         typedef double F;
         E r;
         F f = std::generate_canonical<F, std::numeric_limits<F>::digits - 1>(r);
         assert(f == truncate_fp(
             (16807 - E::min() +
-            (282475249 - E::min()) * (E::max() - E::min() + F(1))) /
-            ((E::max() - E::min() + F(1)) * (E::max() - E::min() + F(1)))));
+            (282475249 - E::min()) * (range + F(1))) /
+            ((range + F(1)) * (range + F(1)))));
     }
     {
-        typedef std::minstd_rand0 E;
         typedef double F;
         E r;
         F f = std::generate_canonical<F, std::numeric_limits<F>::digits>(r);
         assert(f == truncate_fp(
             (16807 - E::min() +
-            (282475249 - E::min()) * (E::max() - E::min() + F(1))) /
-            ((E::max() - E::min() + F(1)) * (E::max() - E::min() + F(1)))));
+            (282475249 - E::min()) * (range + F(1))) /
+            ((range + F(1)) * (range + F(1)))));
     }
     {
-        typedef std::minstd_rand0 E;
         typedef double F;
         E r;
         F f = std::generate_canonical<F, std::numeric_limits<F>::digits + 1>(r);
         assert(f == truncate_fp(
             (16807 - E::min() +
-            (282475249 - E::min()) * (E::max() - E::min() + F(1))) /
-            ((E::max() - E::min() + F(1)) * (E::max() - E::min() + F(1)))));
+            (282475249 - E::min()) * (range + F(1))) /
+            ((range + F(1)) * (range + F(1)))));
     }
 
   return 0;