diff --git a/libcxx/include/valarray b/libcxx/include/valarray
--- a/libcxx/include/valarray
+++ b/libcxx/include/valarray
@@ -413,7 +413,7 @@
 struct _UnaryOp
 {
     typedef typename _Op::__result_type __result_type;
-    typedef typename _A0::value_type value_type;
+    typedef typename decay<__result_type>::type value_type;
 
     _Op __op_;
     _A0 __a0_;
@@ -432,7 +432,7 @@
 struct _BinaryOp
 {
     typedef typename _Op::__result_type __result_type;
-    typedef typename _A0::value_type value_type;
+    typedef typename decay<__result_type>::type value_type;
 
     _Op __op_;
     _A0 __a0_;
@@ -443,7 +443,7 @@
         : __op_(__op), __a0_(__a0), __a1_(__a1) {}
 
     _LIBCPP_INLINE_VISIBILITY
-    value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
+    __result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __a0_.size();}
@@ -1087,7 +1087,7 @@
 struct _UnaryOp<_Op, valarray<_Tp> >
 {
     typedef typename _Op::__result_type __result_type;
-    typedef _Tp value_type;
+    typedef typename decay<__result_type>::type value_type;
 
     _Op __op_;
     const valarray<_Tp>& __a0_;
@@ -1106,7 +1106,7 @@
 struct _BinaryOp<_Op, valarray<_Tp>, _A1>
 {
     typedef typename _Op::__result_type __result_type;
-    typedef _Tp value_type;
+    typedef typename decay<__result_type>::type value_type;
 
     _Op __op_;
     const valarray<_Tp>& __a0_;
@@ -1117,7 +1117,7 @@
         : __op_(__op), __a0_(__a0), __a1_(__a1) {}
 
     _LIBCPP_INLINE_VISIBILITY
-    value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
+    __result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __a0_.size();}
@@ -1127,7 +1127,7 @@
 struct _BinaryOp<_Op, _A0, valarray<_Tp> >
 {
     typedef typename _Op::__result_type __result_type;
-    typedef _Tp value_type;
+    typedef typename decay<__result_type>::type value_type;
 
     _Op __op_;
     _A0 __a0_;
@@ -1138,7 +1138,7 @@
         : __op_(__op), __a0_(__a0), __a1_(__a1) {}
 
     _LIBCPP_INLINE_VISIBILITY
-    value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
+    __result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __a0_.size();}
@@ -1148,7 +1148,7 @@
 struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> >
 {
     typedef typename _Op::__result_type __result_type;
-    typedef _Tp value_type;
+    typedef typename decay<__result_type>::type value_type;
 
     _Op __op_;
     const valarray<_Tp>& __a0_;
@@ -1159,7 +1159,7 @@
         : __op_(__op), __a0_(__a0), __a1_(__a1) {}
 
     _LIBCPP_INLINE_VISIBILITY
-    value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
+    __result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
 
     _LIBCPP_INLINE_VISIBILITY
     size_t size() const {return __a0_.size();}
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_valarray.pass.cpp
@@ -27,14 +27,17 @@
         T a1[] = {1,  2,  3,  4,  0};
         T a2[] = {6,  7,  0,  9, 10};
         bool a3[] = {true,  true,  false,  true,  false};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = v1 && v2;
-        assert(v1.size() == v2.size());
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 && v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_valarray_value.pass.cpp
@@ -26,23 +26,31 @@
         typedef int T;
         T a1[] = {1,  2,  3,  4,  0};
         bool a3[] = {true,  true,  true,  true,  false};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<bool> v3 = v1 && 5;
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 && 5);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
     {
         typedef int T;
         T a1[] = {1,  2,  3,  4,  0};
         bool a3[] = {false,  false,  false,  false,  false};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<bool> v3 = v1 && 0;
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 && 0);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/and_value_valarray.pass.cpp
@@ -26,23 +26,31 @@
         typedef int T;
         T a2[] = {1,  2,  3,  4,  0};
         bool a3[] = {true,  true,  true,  true,  false};
-        const unsigned N = sizeof(a2)/sizeof(a2[0]);
+        const unsigned N = 5;
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = 5 && v2;
-        assert(v2.size() == v3.size());
-        for (std::size_t i = 0; i < v3.size(); ++i)
+        std::valarray<bool> v3a = +(5 && v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
     {
         typedef int T;
         T a2[] = {1,  2,  3,  4,  0};
         bool a3[] = {false,  false,  false,  false,  false};
-        const unsigned N = sizeof(a2)/sizeof(a2[0]);
+        const unsigned N = 5;
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = 0 && v2;
-        assert(v2.size() == v3.size());
-        for (std::size_t i = 0; i < v3.size(); ++i)
+        std::valarray<bool> v3a = +(0 && v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_valarray.pass.cpp
@@ -27,14 +27,17 @@
         T a1[] = {1,  2,  0,  4, 10};
         T a2[] = {6,  7,  0,  9, 10};
         bool a3[] = {false,  false,  true,  false,  true};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = v1 == v2;
-        assert(v1.size() == v2.size());
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 == v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_valarray_value.pass.cpp
@@ -26,12 +26,16 @@
         typedef int T;
         T a1[] = {1,  2,  3,  4,  0};
         bool a3[] = {false,  true,  false,  false,  false};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<bool> v3 = v1 == 2;
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 == 2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/equal_value_valarray.pass.cpp
@@ -26,12 +26,16 @@
         typedef int T;
         T a2[] = {1,  2,  3,  4,  0};
         bool a3[] = {false,  true,  false,  false,  false};
-        const unsigned N = sizeof(a2)/sizeof(a2[0]);
+        const unsigned N = 5;
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = 2 == v2;
-        assert(v2.size() == v3.size());
-        for (std::size_t i = 0; i < v3.size(); ++i)
+        std::valarray<bool> v3a = +(2 == v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_valarray.pass.cpp
@@ -27,14 +27,17 @@
         T a1[] = {1,  2,  0,  4, 10};
         T a2[] = {6,  7,  0,  2, 1};
         bool a3[] = {false,  false,  true,  true,  true};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = v1 >= v2;
-        assert(v1.size() == v2.size());
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 >= v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_valarray_value.pass.cpp
@@ -26,12 +26,16 @@
         typedef int T;
         T a1[] = {1,  2,  3,  4,  0};
         bool a3[] = {false,  true,  true,  true,  false};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<bool> v3 = v1 >= 2;
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 >= 2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_equal_value_valarray.pass.cpp
@@ -26,12 +26,16 @@
         typedef int T;
         T a2[] = {1,  2,  3,  4,  0};
         bool a3[] = {true,  true,  false,  false,  true};
-        const unsigned N = sizeof(a2)/sizeof(a2[0]);
+        const unsigned N = 5;
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = 2 >= v2;
-        assert(v2.size() == v3.size());
-        for (std::size_t i = 0; i < v3.size(); ++i)
+        std::valarray<bool> v3a = +(2 >= v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_valarray.pass.cpp
@@ -27,14 +27,17 @@
         T a1[] = {1,  2,  0,  4, 10};
         T a2[] = {6,  7,  0,  2, 1};
         bool a3[] = {false,  false,  false,  true,  true};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = v1 > v2;
-        assert(v1.size() == v2.size());
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 > v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_valarray_value.pass.cpp
@@ -26,12 +26,16 @@
         typedef int T;
         T a1[] = {1,  2,  3,  4,  0};
         bool a3[] = {false,  false,  true,  true,  false};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<bool> v3 = v1 > 2;
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 > 2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/greater_value_valarray.pass.cpp
@@ -26,12 +26,16 @@
         typedef int T;
         T a2[] = {1,  2,  3,  4,  0};
         bool a3[] = {true,  false,  false,  false,  true};
-        const unsigned N = sizeof(a2)/sizeof(a2[0]);
+        const unsigned N = 5;
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = 2 > v2;
-        assert(v2.size() == v3.size());
-        for (std::size_t i = 0; i < v3.size(); ++i)
+        std::valarray<bool> v3a = +(2 > v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_valarray.pass.cpp
@@ -27,14 +27,17 @@
         T a1[] = {1,  2,  0,  4, 10};
         T a2[] = {6,  7,  0,  2, 1};
         bool a3[] = {true,  true,  true,  false,  false};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = v1 <= v2;
-        assert(v1.size() == v2.size());
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 <= v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_valarray_value.pass.cpp
@@ -26,12 +26,16 @@
         typedef int T;
         T a1[] = {1,  2,  3,  4,  0};
         bool a3[] = {true,  true,  false,  false,  true};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<bool> v3 = v1 <= 2;
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 <= 2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_equal_value_valarray.pass.cpp
@@ -26,12 +26,16 @@
         typedef int T;
         T a2[] = {1,  2,  3,  4,  0};
         bool a3[] = {false,  true,  true,  true,  false};
-        const unsigned N = sizeof(a2)/sizeof(a2[0]);
+        const unsigned N = 5;
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = 2 <= v2;
-        assert(v2.size() == v3.size());
-        for (std::size_t i = 0; i < v3.size(); ++i)
+        std::valarray<bool> v3a = +(2 <= v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_valarray.pass.cpp
@@ -27,14 +27,17 @@
         T a1[] = {1,  2,  0,  4, 10};
         T a2[] = {6,  7,  0,  2, 1};
         bool a3[] = {true,  true,  false,  false,  false};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = v1 < v2;
-        assert(v1.size() == v2.size());
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 < v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_valarray_value.pass.cpp
@@ -26,12 +26,16 @@
         typedef int T;
         T a1[] = {1,  2,  3,  4,  0};
         bool a3[] = {true,  false,  false,  false,  true};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<bool> v3 = v1 < 2;
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 < 2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/less_value_valarray.pass.cpp
@@ -26,12 +26,16 @@
         typedef int T;
         T a2[] = {1,  2,  3,  4,  0};
         bool a3[] = {false,  false,  true,  true,  false};
-        const unsigned N = sizeof(a2)/sizeof(a2[0]);
+        const unsigned N = 5;
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = 2 < v2;
-        assert(v2.size() == v3.size());
-        for (std::size_t i = 0; i < v3.size(); ++i)
+        std::valarray<bool> v3a = +(2 < v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_valarray.pass.cpp
@@ -27,14 +27,17 @@
         T a1[] = {1,  2,  0,  4, 10};
         T a2[] = {6,  7,  0,  9, 10};
         bool a3[] = {true,  true,  false,  true,  false};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = v1 != v2;
-        assert(v1.size() == v2.size());
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 != v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_valarray_value.pass.cpp
@@ -26,12 +26,16 @@
         typedef int T;
         T a1[] = {1,  2,  3,  4,  0};
         bool a3[] = {true,  false,  true,  true,  true};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<bool> v3 = v1 != 2;
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 != 2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/not_equal_value_valarray.pass.cpp
@@ -26,12 +26,16 @@
         typedef int T;
         T a2[] = {1,  2,  3,  4,  0};
         bool a3[] = {true,  false,  true,  true,  true};
-        const unsigned N = sizeof(a2)/sizeof(a2[0]);
+        const unsigned N = 5;
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = 2 != v2;
-        assert(v2.size() == v3.size());
-        for (std::size_t i = 0; i < v3.size(); ++i)
+        std::valarray<bool> v3a = +(2 != v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_valarray.pass.cpp
@@ -27,14 +27,17 @@
         T a1[] = {1,  2,  0,  4,  0};
         T a2[] = {6,  7,  0,  9, 10};
         bool a3[] = {true,  true,  false,  true,  true};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = v1 || v2;
-        assert(v1.size() == v2.size());
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 || v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_valarray_value.pass.cpp
@@ -26,23 +26,31 @@
         typedef int T;
         T a1[] = {1,  2,  3,  4,  0};
         bool a3[] = {true,  true,  true,  true,  true};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<bool> v3 = v1 || 5;
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 || 5);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
     {
         typedef int T;
         T a1[] = {1,  2,  3,  4,  0};
         bool a3[] = {true,  true,  true,  true,  false};
-        const unsigned N = sizeof(a1)/sizeof(a1[0]);
+        const unsigned N = 5;
         std::valarray<T> v1(a1, N);
         std::valarray<bool> v3 = v1 || 0;
-        assert(v1.size() == v3.size());
-        for (std::size_t i = 0; i < v1.size(); ++i)
+        std::valarray<bool> v3a = +(v1 || 0);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;
diff --git a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp
--- a/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp
+++ b/libcxx/test/std/numerics/numarray/valarray.nonmembers/valarray.comparison/or_value_valarray.pass.cpp
@@ -26,23 +26,31 @@
         typedef int T;
         T a2[] = {1,  2,  3,  4,  0};
         bool a3[] = {true,  true,  true,  true,  true};
-        const unsigned N = sizeof(a2)/sizeof(a2[0]);
+        const unsigned N = 5;
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = 5 || v2;
-        assert(v2.size() == v3.size());
-        for (std::size_t i = 0; i < v3.size(); ++i)
+        std::valarray<bool> v3a = +(5 || v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
     {
         typedef int T;
         T a2[] = {1,  2,  3,  4,  0};
         bool a3[] = {true,  true,  true,  true,  false};
-        const unsigned N = sizeof(a2)/sizeof(a2[0]);
+        const unsigned N = 5;
         std::valarray<T> v2(a2, N);
         std::valarray<bool> v3 = 0 || v2;
-        assert(v2.size() == v3.size());
-        for (std::size_t i = 0; i < v3.size(); ++i)
+        std::valarray<bool> v3a = +(0 || v2);
+        assert(v3.size() == N);
+        assert(v3a.size() == N);
+        for (std::size_t i = 0; i < N; ++i) {
             assert(v3[i] == a3[i]);
+            assert(v3a[i] == a3[i]);
+        }
     }
 
   return 0;