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_;
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_;
: __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();}
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_;
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_;
: __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();}
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_;
: __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();}
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_;
: __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();}
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;