From 469d18c06446259aaaa8ec57f1548b1a42691512 Mon Sep 17 00:00:00 2001 From: Arthur O'Dwyer Date: Mon, 31 May 2021 11:33:51 -0400 Subject: [PATCH] [libc++] Fix result-type and value_type computation in . The `operator[]` of `_UnaryOp` and `_BinaryOp` returns the result of calling `__op_`, so its return type should be `__result_type`, not e.g. `_A0::value_type`. However, `_UnaryOp::value_type` also should never have been `_A0::value_type`; it needs to be the correct type for the result of the unary op, e.g. `bool` when the op is `logical_not`. This turns out to matter when multiple operators are nested, e.g. `+(v == v)` needs to have a `value_type` of `bool`, not `int`, even when `v` is of type `valarray`. Differential Revision: https://reviews.llvm.org/D103416 --- libcxx/include/valarray | 20 ++++++++++---------- .../and_valarray_valarray.pass.cpp | 11 +++++++---- .../valarray.comparison/and_valarray_value.pass.cpp | 20 ++++++++++++++------ .../valarray.comparison/and_value_valarray.pass.cpp | 20 ++++++++++++++------ .../equal_valarray_valarray.pass.cpp | 11 +++++++---- .../equal_valarray_value.pass.cpp | 10 +++++++--- .../equal_value_valarray.pass.cpp | 10 +++++++--- .../greater_equal_valarray_valarray.pass.cpp | 11 +++++++---- .../greater_equal_valarray_value.pass.cpp | 10 +++++++--- .../greater_equal_value_valarray.pass.cpp | 10 +++++++--- .../greater_valarray_valarray.pass.cpp | 11 +++++++---- .../greater_valarray_value.pass.cpp | 10 +++++++--- .../greater_value_valarray.pass.cpp | 10 +++++++--- .../less_equal_valarray_valarray.pass.cpp | 11 +++++++---- .../less_equal_valarray_value.pass.cpp | 10 +++++++--- .../less_equal_value_valarray.pass.cpp | 10 +++++++--- .../less_valarray_valarray.pass.cpp | 11 +++++++---- .../valarray.comparison/less_valarray_value.pass.cpp | 10 +++++++--- .../valarray.comparison/less_value_valarray.pass.cpp | 10 +++++++--- .../not_equal_valarray_valarray.pass.cpp | 11 +++++++---- .../not_equal_valarray_value.pass.cpp | 10 +++++++--- .../not_equal_value_valarray.pass.cpp | 10 +++++++--- .../or_valarray_valarray.pass.cpp | 11 +++++++---- .../valarray.comparison/or_valarray_value.pass.cpp | 20 ++++++++++++++------ .../valarray.comparison/or_value_valarray.pass.cpp | 20 ++++++++++++++------ 25 files changed, 206 insertions(+), 102 deletions(-) diff --git a/libcxx/include/valarray b/libcxx/include/valarray index 1eb25fd..6e25514 100644 --- a/libcxx/include/valarray +++ b/libcxx/include/valarray @@ -413,7 +413,7 @@ template 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 @@ template 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 @@ struct _BinaryOp : __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 @@ template 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 @@ template 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 @@ struct _BinaryOp<_Op, valarray<_Tp>, _A1> : __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 @@ template 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 @@ struct _BinaryOp<_Op, _A0, valarray<_Tp> > : __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 @@ template 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 @@ struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> > : __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 index 0f3b3b2..ab423e7 100644 --- 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 @@ int main(int, char**) 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 v1(a1, N); std::valarray v2(a2, N); std::valarray 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 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 index 36fc3fa..a2abf63 100644 --- 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 @@ int main(int, char**) 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 v1(a1, N); std::valarray v3 = v1 && 5; - assert(v1.size() == v3.size()); - for (std::size_t i = 0; i < v1.size(); ++i) + std::valarray 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 v1(a1, N); std::valarray v3 = v1 && 0; - assert(v1.size() == v3.size()); - for (std::size_t i = 0; i < v1.size(); ++i) + std::valarray 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 index ec4c86e..549c396 100644 --- 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 @@ int main(int, char**) 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 v2(a2, N); std::valarray v3 = 5 && v2; - assert(v2.size() == v3.size()); - for (std::size_t i = 0; i < v3.size(); ++i) + std::valarray 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 v2(a2, N); std::valarray v3 = 0 && v2; - assert(v2.size() == v3.size()); - for (std::size_t i = 0; i < v3.size(); ++i) + std::valarray 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 index ef3ed72..b33d47a 100644 --- 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 @@ int main(int, char**) 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 v1(a1, N); std::valarray v2(a2, N); std::valarray 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 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 index ecc98d6..0a36e2d 100644 --- 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 @@ int main(int, char**) 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 v1(a1, N); std::valarray v3 = v1 == 2; - assert(v1.size() == v3.size()); - for (std::size_t i = 0; i < v1.size(); ++i) + std::valarray 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 index c3e077e..ad3a2a0 100644 --- 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 @@ int main(int, char**) 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 v2(a2, N); std::valarray v3 = 2 == v2; - assert(v2.size() == v3.size()); - for (std::size_t i = 0; i < v3.size(); ++i) + std::valarray 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 index 64db931..700ed40 100644 --- 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 @@ int main(int, char**) 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 v1(a1, N); std::valarray v2(a2, N); std::valarray 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 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 index dac04a3..705a4e9 100644 --- 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 @@ int main(int, char**) 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 v1(a1, N); std::valarray v3 = v1 >= 2; - assert(v1.size() == v3.size()); - for (std::size_t i = 0; i < v1.size(); ++i) + std::valarray 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 index c9c693c..d5c3019 100644 --- 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 @@ int main(int, char**) 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 v2(a2, N); std::valarray v3 = 2 >= v2; - assert(v2.size() == v3.size()); - for (std::size_t i = 0; i < v3.size(); ++i) + std::valarray 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 index 512f8e6..2bb72a0 100644 --- 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 @@ int main(int, char**) 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 v1(a1, N); std::valarray v2(a2, N); std::valarray 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 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 index 9da362f..204e097 100644 --- 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 @@ int main(int, char**) 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 v1(a1, N); std::valarray v3 = v1 > 2; - assert(v1.size() == v3.size()); - for (std::size_t i = 0; i < v1.size(); ++i) + std::valarray 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 index 4682896..ced1977 100644 --- 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 @@ int main(int, char**) 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 v2(a2, N); std::valarray v3 = 2 > v2; - assert(v2.size() == v3.size()); - for (std::size_t i = 0; i < v3.size(); ++i) + std::valarray 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 index 8a4ffef..77fbb68 100644 --- 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 @@ int main(int, char**) 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 v1(a1, N); std::valarray v2(a2, N); std::valarray 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 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 index c7118b6..7b4fc6f 100644 --- 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 @@ int main(int, char**) 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 v1(a1, N); std::valarray v3 = v1 <= 2; - assert(v1.size() == v3.size()); - for (std::size_t i = 0; i < v1.size(); ++i) + std::valarray 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 index 76d9290..5822ebe 100644 --- 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 @@ int main(int, char**) 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 v2(a2, N); std::valarray v3 = 2 <= v2; - assert(v2.size() == v3.size()); - for (std::size_t i = 0; i < v3.size(); ++i) + std::valarray 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 index 59210bc..374375a 100644 --- 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 @@ int main(int, char**) 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 v1(a1, N); std::valarray v2(a2, N); std::valarray 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 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 index f800228..7e325a5 100644 --- 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 @@ int main(int, char**) 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 v1(a1, N); std::valarray v3 = v1 < 2; - assert(v1.size() == v3.size()); - for (std::size_t i = 0; i < v1.size(); ++i) + std::valarray 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 index 8edd643..ac1f661 100644 --- 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 @@ int main(int, char**) 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 v2(a2, N); std::valarray v3 = 2 < v2; - assert(v2.size() == v3.size()); - for (std::size_t i = 0; i < v3.size(); ++i) + std::valarray 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 index c3e2c19..e5832e1 100644 --- 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 @@ int main(int, char**) 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 v1(a1, N); std::valarray v2(a2, N); std::valarray 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 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 index 05a8c2f..0199647 100644 --- 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 @@ int main(int, char**) 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 v1(a1, N); std::valarray v3 = v1 != 2; - assert(v1.size() == v3.size()); - for (std::size_t i = 0; i < v1.size(); ++i) + std::valarray 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 index 4c9fb80..6980448 100644 --- 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 @@ int main(int, char**) 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 v2(a2, N); std::valarray v3 = 2 != v2; - assert(v2.size() == v3.size()); - for (std::size_t i = 0; i < v3.size(); ++i) + std::valarray 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 index 48b287e..f5e1188 100644 --- 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 @@ int main(int, char**) 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 v1(a1, N); std::valarray v2(a2, N); std::valarray 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 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 index 029e497..3fa9ff5 100644 --- 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 @@ int main(int, char**) 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 v1(a1, N); std::valarray v3 = v1 || 5; - assert(v1.size() == v3.size()); - for (std::size_t i = 0; i < v1.size(); ++i) + std::valarray 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 v1(a1, N); std::valarray v3 = v1 || 0; - assert(v1.size() == v3.size()); - for (std::size_t i = 0; i < v1.size(); ++i) + std::valarray 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 index ff5e6c8..8ae29be 100644 --- 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 @@ int main(int, char**) 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 v2(a2, N); std::valarray v3 = 5 || v2; - assert(v2.size() == v3.size()); - for (std::size_t i = 0; i < v3.size(); ++i) + std::valarray 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 v2(a2, N); std::valarray v3 = 0 || v2; - assert(v2.size() == v3.size()); - for (std::size_t i = 0; i < v3.size(); ++i) + std::valarray 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; -- 2.7.4