From 1f3de5c76e4947afccca350da24859e52f6aa83f Mon Sep 17 00:00:00 2001 From: Alon Zakai Date: Mon, 17 Jan 2011 15:36:26 -0800 Subject: libcxx test; support for linking in test runner; failure in clang_0_1.test_libcxx --- tests/libcxx/include/valarray | 4742 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 4742 insertions(+) create mode 100644 tests/libcxx/include/valarray (limited to 'tests/libcxx/include/valarray') diff --git a/tests/libcxx/include/valarray b/tests/libcxx/include/valarray new file mode 100644 index 00000000..32e34a3e --- /dev/null +++ b/tests/libcxx/include/valarray @@ -0,0 +1,4742 @@ +// -*- C++ -*- +//===-------------------------- valarray ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_VALARRAY +#define _LIBCPP_VALARRAY + +/* + valarray synopsis + +namespace std +{ + +template +class valarray +{ +public: + typedef T value_type; + + // construct/destroy: + valarray(); + explicit valarray(size_t n); + valarray(const value_type& x, size_t n); + valarray(const value_type* px, size_t n); + valarray(const valarray& v); + valarray(valarray&& v); + valarray(const slice_array& sa); + valarray(const gslice_array& ga); + valarray(const mask_array& ma); + valarray(const indirect_array& ia); + valarray(initializer_list il); + ~valarray(); + + // assignment: + valarray& operator=(const valarray& v); + valarray& operator=(valarray&& v); + valarray& operator=(initializer_list il); + valarray& operator=(const value_type& x); + valarray& operator=(const slice_array& sa); + valarray& operator=(const gslice_array& ga); + valarray& operator=(const mask_array& ma); + valarray& operator=(const indirect_array& ia); + + // element access: + const value_type& operator[](size_t i) const; + value_type& operator[](size_t i); + + // subset operations: + valarray operator[](slice s) const; + slice_array operator[](slice s); + valarray operator[](const gslice& gs) const; + gslice_array operator[](const gslice& gs); + valarray operator[](const valarray& vb) const; + mask_array operator[](const valarray& vb); + valarray operator[](const valarray& vs) const; + indirect_array operator[](const valarray& vs); + + // unary operators: + valarray operator+() const; + valarray operator-() const; + valarray operator~() const; + valarray operator!() const; + + // computed assignment: + valarray& operator*= (const value_type& x); + valarray& operator/= (const value_type& x); + valarray& operator%= (const value_type& x); + valarray& operator+= (const value_type& x); + valarray& operator-= (const value_type& x); + valarray& operator^= (const value_type& x); + valarray& operator&= (const value_type& x); + valarray& operator|= (const value_type& x); + valarray& operator<<=(const value_type& x); + valarray& operator>>=(const value_type& x); + + valarray& operator*= (const valarray& v); + valarray& operator/= (const valarray& v); + valarray& operator%= (const valarray& v); + valarray& operator+= (const valarray& v); + valarray& operator-= (const valarray& v); + valarray& operator^= (const valarray& v); + valarray& operator|= (const valarray& v); + valarray& operator&= (const valarray& v); + valarray& operator<<=(const valarray& v); + valarray& operator>>=(const valarray& v); + + // member functions: + void swap(valarray& v); + + size_t size() const; + + value_type sum() const; + value_type min() const; + value_type max() const; + + valarray shift (int i) const; + valarray cshift(int i) const; + valarray apply(value_type f(value_type)) const; + valarray apply(value_type f(const value_type&)) const; + void resize(size_t n, value_type x = value_type()); +}; + +class slice +{ +public: + slice(); + slice(size_t start, size_t size, size_t stride); + + size_t start() const; + size_t size() const; + size_t stride() const; +}; + +template +class slice_array +{ +public: + typedef T value_type; + + const slice_array& operator=(const slice_array& sa) const; + void operator= (const valarray& v) const; + void operator*= (const valarray& v) const; + void operator/= (const valarray& v) const; + void operator%= (const valarray& v) const; + void operator+= (const valarray& v) const; + void operator-= (const valarray& v) const; + void operator^= (const valarray& v) const; + void operator&= (const valarray& v) const; + void operator|= (const valarray& v) const; + void operator<<=(const valarray& v) const; + void operator>>=(const valarray& v) const; + + void operator=(const value_type& x) const; + + slice_array() = delete; +}; + +class gslice +{ +public: + gslice(); + gslice(size_t start, const valarray& size, + const valarray& stride); + + size_t start() const; + valarray size() const; + valarray stride() const; +}; + +template +class gslice_array +{ +public: + typedef T value_type; + + void operator= (const valarray& v) const; + void operator*= (const valarray& v) const; + void operator/= (const valarray& v) const; + void operator%= (const valarray& v) const; + void operator+= (const valarray& v) const; + void operator-= (const valarray& v) const; + void operator^= (const valarray& v) const; + void operator&= (const valarray& v) const; + void operator|= (const valarray& v) const; + void operator<<=(const valarray& v) const; + void operator>>=(const valarray& v) const; + + gslice_array(const gslice_array& ga); + ~gslice_array(); + const gslice_array& operator=(const gslice_array& ga) const; + void operator=(const value_type& x) const; + + gslice_array() = delete; +}; + +template +class mask_array +{ +public: + typedef T value_type; + + void operator= (const valarray& v) const; + void operator*= (const valarray& v) const; + void operator/= (const valarray& v) const; + void operator%= (const valarray& v) const; + void operator+= (const valarray& v) const; + void operator-= (const valarray& v) const; + void operator^= (const valarray& v) const; + void operator&= (const valarray& v) const; + void operator|= (const valarray& v) const; + void operator<<=(const valarray& v) const; + void operator>>=(const valarray& v) const; + + mask_array(const mask_array& ma); + ~mask_array(); + const mask_array& operator=(const mask_array& ma) const; + void operator=(const value_type& x) const; + + mask_array() = delete; +}; + +template +class indirect_array +{ +public: + typedef T value_type; + + void operator= (const valarray& v) const; + void operator*= (const valarray& v) const; + void operator/= (const valarray& v) const; + void operator%= (const valarray& v) const; + void operator+= (const valarray& v) const; + void operator-= (const valarray& v) const; + void operator^= (const valarray& v) const; + void operator&= (const valarray& v) const; + void operator|= (const valarray& v) const; + void operator<<=(const valarray& v) const; + void operator>>=(const valarray& v) const; + + indirect_array(const indirect_array& ia); + ~indirect_array(); + const indirect_array& operator=(const indirect_array& ia) const; + void operator=(const value_type& x) const; + + indirect_array() = delete; +}; + +template void swap(valarray& x, valarray& y); + +template valarray operator* (const valarray& x, const valarray& y); +template valarray operator* (const valarray& x, const T& y); +template valarray operator* (const T& x, const valarray& y); + +template valarray operator/ (const valarray& x, const valarray& y); +template valarray operator/ (const valarray& x, const T& y); +template valarray operator/ (const T& x, const valarray& y); + +template valarray operator% (const valarray& x, const valarray& y); +template valarray operator% (const valarray& x, const T& y); +template valarray operator% (const T& x, const valarray& y); + +template valarray operator+ (const valarray& x, const valarray& y); +template valarray operator+ (const valarray& x, const T& y); +template valarray operator+ (const T& x, const valarray& y); + +template valarray operator- (const valarray& x, const valarray& y); +template valarray operator- (const valarray& x, const T& y); +template valarray operator- (const T& x, const valarray& y); + +template valarray operator^ (const valarray& x, const valarray& y); +template valarray operator^ (const valarray& x, const T& y); +template valarray operator^ (const T& x, const valarray& y); + +template valarray operator& (const valarray& x, const valarray& y); +template valarray operator& (const valarray& x, const T& y); +template valarray operator& (const T& x, const valarray& y); + +template valarray operator| (const valarray& x, const valarray& y); +template valarray operator| (const valarray& x, const T& y); +template valarray operator| (const T& x, const valarray& y); + +template valarray operator<<(const valarray& x, const valarray& y); +template valarray operator<<(const valarray& x, const T& y); +template valarray operator<<(const T& x, const valarray& y); + +template valarray operator>>(const valarray& x, const valarray& y); +template valarray operator>>(const valarray& x, const T& y); +template valarray operator>>(const T& x, const valarray& y); + +template valarray operator&&(const valarray& x, const valarray& y); +template valarray operator&&(const valarray& x, const T& y); +template valarray operator&&(const T& x, const valarray& y); + +template valarray operator||(const valarray& x, const valarray& y); +template valarray operator||(const valarray& x, const T& y); +template valarray operator||(const T& x, const valarray& y); + +template valarray operator==(const valarray& x, const valarray& y); +template valarray operator==(const valarray& x, const T& y); +template valarray operator==(const T& x, const valarray& y); + +template valarray operator!=(const valarray& x, const valarray& y); +template valarray operator!=(const valarray& x, const T& y); +template valarray operator!=(const T& x, const valarray& y); + +template valarray operator< (const valarray& x, const valarray& y); +template valarray operator< (const valarray& x, const T& y); +template valarray operator< (const T& x, const valarray& y); + +template valarray operator> (const valarray& x, const valarray& y); +template valarray operator> (const valarray& x, const T& y); +template valarray operator> (const T& x, const valarray& y); + +template valarray operator<=(const valarray& x, const valarray& y); +template valarray operator<=(const valarray& x, const T& y); +template valarray operator<=(const T& x, const valarray& y); + +template valarray operator>=(const valarray& x, const valarray& y); +template valarray operator>=(const valarray& x, const T& y); +template valarray operator>=(const T& x, const valarray& y); + +template valarray abs (const valarray& x); +template valarray acos (const valarray& x); +template valarray asin (const valarray& x); +template valarray atan (const valarray& x); + +template valarray atan2(const valarray& x, const valarray& y); +template valarray atan2(const valarray& x, const T& y); +template valarray atan2(const T& x, const valarray& y); + +template valarray cos (const valarray& x); +template valarray cosh (const valarray& x); +template valarray exp (const valarray& x); +template valarray log (const valarray& x); +template valarray log10(const valarray& x); + +template valarray pow(const valarray& x, const valarray& y); +template valarray pow(const valarray& x, const T& y); +template valarray pow(const T& x, const valarray& y); + +template valarray sin (const valarray& x); +template valarray sinh (const valarray& x); +template valarray sqrt (const valarray& x); +template valarray tan (const valarray& x); +template valarray tanh (const valarray& x); + +template unspecified1 begin(valarray& v); +template unspecified2 begin(const valarray& v); +template unspecified1 end(valarray& v); +template unspecified2 end(const valarray& v); + +} // std + +*/ + +#include <__config> +#include +#include +#include +#include +#include + +#pragma GCC system_header + +_LIBCPP_BEGIN_NAMESPACE_STD + +template class valarray; + +class _LIBCPP_VISIBLE slice +{ + size_t __start_; + size_t __size_; + size_t __stride_; +public: + _LIBCPP_INLINE_VISIBILITY + slice() + : __start_(0), + __size_(0), + __stride_(0) + {} + + _LIBCPP_INLINE_VISIBILITY + slice(size_t __start, size_t __size, size_t __stride) + : __start_(__start), + __size_(__size), + __stride_(__stride) + {} + + _LIBCPP_INLINE_VISIBILITY size_t start() const {return __start_;} + _LIBCPP_INLINE_VISIBILITY size_t size() const {return __size_;} + _LIBCPP_INLINE_VISIBILITY size_t stride() const {return __stride_;} +}; + +template class slice_array; +class gslice; +template class gslice_array; +template class mask_array; +template class indirect_array; + +template +_Tp* +begin(valarray<_Tp>& __v); + +template +const _Tp* +begin(const valarray<_Tp>& __v); + +template +_Tp* +end(valarray<_Tp>& __v); + +template +const _Tp* +end(const valarray<_Tp>& __v); + +template +struct _UnaryOp +{ + typedef typename _Op::result_type result_type; + typedef typename _A0::value_type value_type; + + _Op __op_; + _A0 __a0_; + + _LIBCPP_INLINE_VISIBILITY + _UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {} + + _LIBCPP_INLINE_VISIBILITY + result_type operator[](size_t __i) const {return __op_(__a0_[__i]);} + + _LIBCPP_INLINE_VISIBILITY + size_t size() const {return __a0_.size();} +}; + +template +struct _BinaryOp +{ + typedef typename _Op::result_type result_type; + typedef typename _A0::value_type value_type; + + _Op __op_; + _A0 __a0_; + _A1 __a1_; + + _LIBCPP_INLINE_VISIBILITY + _BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1) + : __op_(__op), __a0_(__a0), __a1_(__a1) {} + + _LIBCPP_INLINE_VISIBILITY + value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);} + + _LIBCPP_INLINE_VISIBILITY + size_t size() const {return __a0_.size();} +}; + +template +class __scalar_expr +{ +public: + typedef _Tp value_type; + typedef const _Tp& result_type; +private: + const value_type& __t_; + size_t __s_; +public: + _LIBCPP_INLINE_VISIBILITY + explicit __scalar_expr(const value_type& __t, size_t __s) : __t_(__t), __s_(__s) {} + + _LIBCPP_INLINE_VISIBILITY + result_type operator[](size_t) const {return __t_;} + + _LIBCPP_INLINE_VISIBILITY + size_t size() const {return __s_;} +}; + +template +struct __unary_plus : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return +__x;} +}; + +template +struct __bit_not : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return ~__x;} +}; + +template +struct __bit_shift_left : binary_function<_Tp, _Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x, const _Tp& __y) const + {return __x << __y;} +}; + +template +struct __bit_shift_right : binary_function<_Tp, _Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x, const _Tp& __y) const + {return __x >> __y;} +}; + +template +struct __apply_expr : unary_function<_Tp, _Tp> +{ +private: + _F __f_; +public: + _LIBCPP_INLINE_VISIBILITY + explicit __apply_expr(_F __f) : __f_(__f) {} + + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return __f_(__x);} +}; + +template +struct __abs_expr : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return abs(__x);} +}; + +template +struct __acos_expr : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return acos(__x);} +}; + +template +struct __asin_expr : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return asin(__x);} +}; + +template +struct __atan_expr : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return atan(__x);} +}; + +template +struct __atan2_expr : binary_function<_Tp, _Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x, const _Tp& __y) const + {return atan2(__x, __y);} +}; + +template +struct __cos_expr : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return cos(__x);} +}; + +template +struct __cosh_expr : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return cosh(__x);} +}; + +template +struct __exp_expr : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return exp(__x);} +}; + +template +struct __log_expr : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return log(__x);} +}; + +template +struct __log10_expr : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return log10(__x);} +}; + +template +struct __pow_expr : binary_function<_Tp, _Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x, const _Tp& __y) const + {return pow(__x, __y);} +}; + +template +struct __sin_expr : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return sin(__x);} +}; + +template +struct __sinh_expr : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return sinh(__x);} +}; + +template +struct __sqrt_expr : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return sqrt(__x);} +}; + +template +struct __tan_expr : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return tan(__x);} +}; + +template +struct __tanh_expr : unary_function<_Tp, _Tp> +{ + _LIBCPP_INLINE_VISIBILITY + _Tp operator()(const _Tp& __x) const + {return tanh(__x);} +}; + +template +class __slice_expr +{ + typedef typename remove_reference<_ValExpr>::type _RmExpr; +public: + typedef typename _RmExpr::value_type value_type; + typedef value_type result_type; + +private: + _ValExpr __expr_; + size_t __start_; + size_t __size_; + size_t __stride_; + + _LIBCPP_INLINE_VISIBILITY + __slice_expr(const slice& __sl, const _RmExpr& __e) + : __expr_(__e), + __start_(__sl.start()), + __size_(__sl.size()), + __stride_(__sl.stride()) + {} +public: + + _LIBCPP_INLINE_VISIBILITY + result_type operator[](size_t __i) const + {return __expr_[__start_ + __i * __stride_];} + + _LIBCPP_INLINE_VISIBILITY + size_t size() const {return __size_;} + + template friend class _LIBCPP_VISIBLE valarray; +}; + +template +class __mask_expr; + +template +class __indirect_expr; + +template +class __shift_expr +{ + typedef typename remove_reference<_ValExpr>::type _RmExpr; +public: + typedef typename _RmExpr::value_type value_type; + typedef value_type result_type; + +private: + _ValExpr __expr_; + size_t __size_; + ptrdiff_t __ul_; + ptrdiff_t __sn_; + ptrdiff_t __n_; + static const ptrdiff_t _N = static_cast( + sizeof(ptrdiff_t) * __CHAR_BIT__ - 1); + + _LIBCPP_INLINE_VISIBILITY + __shift_expr(int __n, const _RmExpr& __e) + : __expr_(__e), + __size_(__e.size()), + __n_(__n) + { + ptrdiff_t __neg_n = static_cast(__n_ >> _N); + __sn_ = __neg_n | static_cast(static_cast(-__n_) >> _N); + __ul_ = ((__size_ - __n_) & ~__neg_n) | ((__n_ + 1) & __neg_n); + } +public: + + _LIBCPP_INLINE_VISIBILITY + result_type operator[](size_t __j) const + { + ptrdiff_t __i = static_cast(__j); + ptrdiff_t __m = (__sn_ * __i - __ul_) >> _N; + return (__expr_[(__i + __n_) & __m] & __m) | (value_type() & ~__m); + } + + _LIBCPP_INLINE_VISIBILITY + size_t size() const {return __size_;} + + template friend class __val_expr; +}; + +template +class __cshift_expr +{ + typedef typename remove_reference<_ValExpr>::type _RmExpr; +public: + typedef typename _RmExpr::value_type value_type; + typedef value_type result_type; + +private: + _ValExpr __expr_; + size_t __size_; + size_t __m_; + size_t __o1_; + size_t __o2_; + + _LIBCPP_INLINE_VISIBILITY + __cshift_expr(int __n, const _RmExpr& __e) + : __expr_(__e), + __size_(__e.size()) + { + __n %= static_cast(__size_); + if (__n >= 0) + { + __m_ = __size_ - __n; + __o1_ = __n; + __o2_ = __n - __size_; + } + else + { + __m_ = -__n; + __o1_ = __n + __size_; + __o2_ = __n; + } + } +public: + + _LIBCPP_INLINE_VISIBILITY + result_type operator[](size_t __i) const + { + if (__i < __m_) + return __expr_[__i + __o1_]; + return __expr_[__i + __o2_]; + } + + _LIBCPP_INLINE_VISIBILITY + size_t size() const {return __size_;} + + template friend class __val_expr; +}; + +template +class __val_expr; + +template +struct __is_val_expr : false_type {}; + +template +struct __is_val_expr<__val_expr<_ValExpr> > : true_type {}; + +template +struct __is_val_expr > : true_type {}; + +template +class _LIBCPP_VISIBLE valarray +{ +public: + typedef _Tp value_type; + typedef _Tp result_type; + +private: + value_type* __begin_; + value_type* __end_; + +public: + // construct/destroy: + _LIBCPP_INLINE_VISIBILITY + valarray() : __begin_(0), __end_(0) {} + explicit valarray(size_t __n); + valarray(const value_type& __x, size_t __n); + valarray(const value_type* __p, size_t __n); + valarray(const valarray& __v); +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + valarray(valarray&& __v); + valarray(initializer_list __il); +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES + valarray(const slice_array& __sa); + valarray(const gslice_array& __ga); + valarray(const mask_array& __ma); + valarray(const indirect_array& __ia); + ~valarray(); + + // assignment: + valarray& operator=(const valarray& __v); +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + valarray& operator=(valarray&& __v); + valarray& operator=(initializer_list); +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES + valarray& operator=(const value_type& __x); + valarray& operator=(const slice_array& __sa); + valarray& operator=(const gslice_array& __ga); + valarray& operator=(const mask_array& __ma); + valarray& operator=(const indirect_array& __ia); + + // element access: + _LIBCPP_INLINE_VISIBILITY + const value_type& operator[](size_t __i) const {return __begin_[__i];} + + _LIBCPP_INLINE_VISIBILITY + value_type& operator[](size_t __i) {return __begin_[__i];} + + // subset operations: + __val_expr<__slice_expr > operator[](slice __s) const; + slice_array operator[](slice __s); + __val_expr<__indirect_expr > operator[](const gslice& __gs) const; + gslice_array operator[](const gslice& __gs); +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + __val_expr<__indirect_expr > operator[](gslice&& __gs) const; + gslice_array operator[](gslice&& __gs); +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES + __val_expr<__mask_expr > operator[](const valarray& __vb) const; + mask_array operator[](const valarray& __vb); +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + __val_expr<__mask_expr > operator[](valarray&& __vb) const; + mask_array operator[](valarray&& __vb); +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES + __val_expr<__indirect_expr > operator[](const valarray& __vs) const; + indirect_array operator[](const valarray& __vs); +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + __val_expr<__indirect_expr > operator[](valarray&& __vs) const; + indirect_array operator[](valarray&& __vs); +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES + + // unary operators: + valarray operator+() const; + valarray operator-() const; + valarray operator~() const; + valarray operator!() const; + + // computed assignment: + valarray& operator*= (const value_type& __x); + valarray& operator/= (const value_type& __x); + valarray& operator%= (const value_type& __x); + valarray& operator+= (const value_type& __x); + valarray& operator-= (const value_type& __x); + valarray& operator^= (const value_type& __x); + valarray& operator&= (const value_type& __x); + valarray& operator|= (const value_type& __x); + valarray& operator<<=(const value_type& __x); + valarray& operator>>=(const value_type& __x); + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + valarray& + >::type + operator*= (const _Expr& __v); + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + valarray& + >::type + operator/= (const _Expr& __v); + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + valarray& + >::type + operator%= (const _Expr& __v); + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + valarray& + >::type + operator+= (const _Expr& __v); + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + valarray& + >::type + operator-= (const _Expr& __v); + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + valarray& + >::type + operator^= (const _Expr& __v); + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + valarray& + >::type + operator|= (const _Expr& __v); + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + valarray& + >::type + operator&= (const _Expr& __v); + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + valarray& + >::type + operator<<= (const _Expr& __v); + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + valarray& + >::type + operator>>= (const _Expr& __v); + + // member functions: + void swap(valarray& __v); + + _LIBCPP_INLINE_VISIBILITY + size_t size() const {return __end_ - __begin_;} + + value_type sum() const; + value_type min() const; + value_type max() const; + + valarray shift (int __i) const; + valarray cshift(int __i) const; + valarray apply(value_type __f(value_type)) const; + valarray apply(value_type __f(const value_type&)) const; + void resize(size_t __n, value_type __x = value_type()); + +private: + template friend class _LIBCPP_VISIBLE valarray; + template friend class _LIBCPP_VISIBLE slice_array; + template friend class _LIBCPP_VISIBLE gslice_array; + template friend class _LIBCPP_VISIBLE mask_array; + template friend class __mask_expr; + template friend class _LIBCPP_VISIBLE indirect_array; + template friend class __indirect_expr; + template friend class __val_expr; + + template + friend + _Up* + begin(valarray<_Up>& __v); + + template + friend + const _Up* + begin(const valarray<_Up>& __v); + + template + friend + _Up* + end(valarray<_Up>& __v); + + template + friend + const _Up* + end(const valarray<_Up>& __v); +}; + +template +struct _UnaryOp<_Op, valarray<_Tp> > +{ + typedef typename _Op::result_type result_type; + typedef _Tp value_type; + + _Op __op_; + const valarray<_Tp>& __a0_; + + _LIBCPP_INLINE_VISIBILITY + _UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {} + + _LIBCPP_INLINE_VISIBILITY + result_type operator[](size_t __i) const {return __op_(__a0_[__i]);} + + _LIBCPP_INLINE_VISIBILITY + size_t size() const {return __a0_.size();} +}; + +template +struct _BinaryOp<_Op, valarray<_Tp>, _A1> +{ + typedef typename _Op::result_type result_type; + typedef _Tp value_type; + + _Op __op_; + const valarray<_Tp>& __a0_; + _A1 __a1_; + + _LIBCPP_INLINE_VISIBILITY + _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1) + : __op_(__op), __a0_(__a0), __a1_(__a1) {} + + _LIBCPP_INLINE_VISIBILITY + value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);} + + _LIBCPP_INLINE_VISIBILITY + size_t size() const {return __a0_.size();} +}; + +template +struct _BinaryOp<_Op, _A0, valarray<_Tp> > +{ + typedef typename _Op::result_type result_type; + typedef _Tp value_type; + + _Op __op_; + _A0 __a0_; + const valarray<_Tp>& __a1_; + + _LIBCPP_INLINE_VISIBILITY + _BinaryOp(const _Op& __op, const _A0& __a0, const 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]);} + + _LIBCPP_INLINE_VISIBILITY + size_t size() const {return __a0_.size();} +}; + +template +struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> > +{ + typedef typename _Op::result_type result_type; + typedef _Tp value_type; + + _Op __op_; + const valarray<_Tp>& __a0_; + const valarray<_Tp>& __a1_; + + _LIBCPP_INLINE_VISIBILITY + _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const 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]);} + + _LIBCPP_INLINE_VISIBILITY + size_t size() const {return __a0_.size();} +}; + +// slice_array + +template +class _LIBCPP_VISIBLE slice_array +{ +public: + typedef _Tp value_type; + +private: + value_type* __vp_; + size_t __size_; + size_t __stride_; + +public: + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator*=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator/=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator%=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator+=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator-=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator^=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator&=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator|=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator<<=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator>>=(const _Expr& __v) const; + + const slice_array& operator=(const slice_array& __sa) const; + + void operator=(const value_type& __x) const; + +private: + _LIBCPP_INLINE_VISIBILITY + slice_array(const slice& __sl, const valarray& __v) + : __vp_(const_cast(__v.__begin_ + __sl.start())), + __size_(__sl.size()), + __stride_(__sl.stride()) + {} + + template friend class valarray; + template friend class sliceExpr; +}; + +template +inline _LIBCPP_INLINE_VISIBILITY +const slice_array<_Tp>& +slice_array<_Tp>::operator=(const slice_array& __sa) const +{ + value_type* __t = __vp_; + const value_type* __s = __sa.__vp_; + for (size_t __n = __size_; __n; --__n, __t += __stride_, __s += __sa.__stride_) + *__t = *__s; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +slice_array<_Tp>::operator=(const _Expr& __v) const +{ + value_type* __t = __vp_; + for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) + *__t = __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +slice_array<_Tp>::operator*=(const _Expr& __v) const +{ + value_type* __t = __vp_; + for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) + *__t *= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +slice_array<_Tp>::operator/=(const _Expr& __v) const +{ + value_type* __t = __vp_; + for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) + *__t /= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +slice_array<_Tp>::operator%=(const _Expr& __v) const +{ + value_type* __t = __vp_; + for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) + *__t %= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +slice_array<_Tp>::operator+=(const _Expr& __v) const +{ + value_type* __t = __vp_; + for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) + *__t += __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +slice_array<_Tp>::operator-=(const _Expr& __v) const +{ + value_type* __t = __vp_; + for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) + *__t -= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +slice_array<_Tp>::operator^=(const _Expr& __v) const +{ + value_type* __t = __vp_; + for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) + *__t ^= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +slice_array<_Tp>::operator&=(const _Expr& __v) const +{ + value_type* __t = __vp_; + for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) + *__t &= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +slice_array<_Tp>::operator|=(const _Expr& __v) const +{ + value_type* __t = __vp_; + for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) + *__t |= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +slice_array<_Tp>::operator<<=(const _Expr& __v) const +{ + value_type* __t = __vp_; + for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) + *__t <<= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +slice_array<_Tp>::operator>>=(const _Expr& __v) const +{ + value_type* __t = __vp_; + for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) + *__t >>= __v[__i]; +} + +template +inline _LIBCPP_INLINE_VISIBILITY +void +slice_array<_Tp>::operator=(const value_type& __x) const +{ + value_type* __t = __vp_; + for (size_t __n = __size_; __n; --__n, __t += __stride_) + *__t = __x; +} + +// gslice + +class _LIBCPP_VISIBLE gslice +{ + valarray __size_; + valarray __stride_; + valarray __1d_; + +public: + _LIBCPP_INLINE_VISIBILITY + gslice() {} + + _LIBCPP_INLINE_VISIBILITY + gslice(size_t __start, const valarray& __size, + const valarray& __stride) + : __size_(__size), + __stride_(__stride) + {__init(__start);} + +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + + _LIBCPP_INLINE_VISIBILITY + gslice(size_t __start, const valarray& __size, + valarray&& __stride) + : __size_(__size), + __stride_(move(__stride)) + {__init(__start);} + + _LIBCPP_INLINE_VISIBILITY + gslice(size_t __start, valarray&& __size, + const valarray& __stride) + : __size_(move(__size)), + __stride_(__stride) + {__init(__start);} + + _LIBCPP_INLINE_VISIBILITY + gslice(size_t __start, valarray&& __size, + valarray&& __stride) + : __size_(move(__size)), + __stride_(move(__stride)) + {__init(__start);} + +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES + +// gslice(const gslice&) = default; +// gslice(gslice&&) = default; +// gslice& operator=(const gslice&) = default; +// gslice& operator=(gslice&&) = default; + + _LIBCPP_INLINE_VISIBILITY + size_t start() const {return __1d_.size() ? __1d_[0] : 0;} + + _LIBCPP_INLINE_VISIBILITY + valarray size() const {return __size_;} + + _LIBCPP_INLINE_VISIBILITY + valarray stride() const {return __stride_;} + +private: + void __init(size_t __start); + + template friend class gslice_array; + template friend class valarray; + template friend class __val_expr; +}; + +// gslice_array + +template +class _LIBCPP_VISIBLE gslice_array +{ +public: + typedef _Tp value_type; + +private: + value_type* __vp_; + valarray __1d_; + +public: + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator*=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator/=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator%=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator+=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator-=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator^=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator&=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator|=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator<<=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator>>=(const _Expr& __v) const; + + const gslice_array& operator=(const gslice_array& __ga) const; + + void operator=(const value_type& __x) const; + +// gslice_array(const gslice_array&) = default; +// gslice_array(gslice_array&&) = default; +// gslice_array& operator=(const gslice_array&) = default; +// gslice_array& operator=(gslice_array&&) = default; + +private: + _LIBCPP_INLINE_VISIBILITY + gslice_array(const gslice& __gs, const valarray& __v) + : __vp_(const_cast(__v.__begin_)), + __1d_(__gs.__1d_) + {} + +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + + _LIBCPP_INLINE_VISIBILITY + gslice_array(gslice&& __gs, const valarray& __v) + : __vp_(const_cast(__v.__begin_)), + __1d_(move(__gs.__1d_)) + {} + +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES + + template friend class valarray; +}; + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +gslice_array<_Tp>::operator=(const _Expr& __v) const +{ + typedef const size_t* _Ip; + size_t __j = 0; + for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) + __vp_[*__i] = __v[__j]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +gslice_array<_Tp>::operator*=(const _Expr& __v) const +{ + typedef const size_t* _Ip; + size_t __j = 0; + for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) + __vp_[*__i] *= __v[__j]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +gslice_array<_Tp>::operator/=(const _Expr& __v) const +{ + typedef const size_t* _Ip; + size_t __j = 0; + for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) + __vp_[*__i] /= __v[__j]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +gslice_array<_Tp>::operator%=(const _Expr& __v) const +{ + typedef const size_t* _Ip; + size_t __j = 0; + for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) + __vp_[*__i] %= __v[__j]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +gslice_array<_Tp>::operator+=(const _Expr& __v) const +{ + typedef const size_t* _Ip; + size_t __j = 0; + for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) + __vp_[*__i] += __v[__j]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +gslice_array<_Tp>::operator-=(const _Expr& __v) const +{ + typedef const size_t* _Ip; + size_t __j = 0; + for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) + __vp_[*__i] -= __v[__j]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +gslice_array<_Tp>::operator^=(const _Expr& __v) const +{ + typedef const size_t* _Ip; + size_t __j = 0; + for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) + __vp_[*__i] ^= __v[__j]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +gslice_array<_Tp>::operator&=(const _Expr& __v) const +{ + typedef const size_t* _Ip; + size_t __j = 0; + for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) + __vp_[*__i] &= __v[__j]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +gslice_array<_Tp>::operator|=(const _Expr& __v) const +{ + typedef const size_t* _Ip; + size_t __j = 0; + for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) + __vp_[*__i] |= __v[__j]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +gslice_array<_Tp>::operator<<=(const _Expr& __v) const +{ + typedef const size_t* _Ip; + size_t __j = 0; + for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) + __vp_[*__i] <<= __v[__j]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +gslice_array<_Tp>::operator>>=(const _Expr& __v) const +{ + typedef const size_t* _Ip; + size_t __j = 0; + for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) + __vp_[*__i] >>= __v[__j]; +} + +template +inline _LIBCPP_INLINE_VISIBILITY +const gslice_array<_Tp>& +gslice_array<_Tp>::operator=(const gslice_array& __ga) const +{ + typedef const size_t* _Ip; + const value_type* __s = __ga.__vp_; + for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ga.__1d_.__begin_; + __i != __e; ++__i, ++__j) + __vp_[*__i] = __s[*__j]; + return *this; +} + +template +inline _LIBCPP_INLINE_VISIBILITY +void +gslice_array<_Tp>::operator=(const value_type& __x) const +{ + typedef const size_t* _Ip; + for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i) + __vp_[*__i] = __x; +} + +// mask_array + +template +class _LIBCPP_VISIBLE mask_array +{ +public: + typedef _Tp value_type; + +private: + value_type* __vp_; + valarray __1d_; + +public: + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator*=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator/=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator%=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator+=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator-=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator^=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator&=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator|=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator<<=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator>>=(const _Expr& __v) const; + + const mask_array& operator=(const mask_array& __ma) const; + + void operator=(const value_type& __x) const; + +// mask_array(const mask_array&) = default; +// mask_array(mask_array&&) = default; +// mask_array& operator=(const mask_array&) = default; +// mask_array& operator=(mask_array&&) = default; + +private: + _LIBCPP_INLINE_VISIBILITY + mask_array(const valarray& __vb, const valarray& __v) + : __vp_(const_cast(__v.__begin_)), + __1d_(count(__vb.__begin_, __vb.__end_, true)) + { + size_t __j = 0; + for (size_t __i = 0; __i < __vb.size(); ++__i) + if (__vb[__i]) + __1d_[__j++] = __i; + } + + template friend class valarray; +}; + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +mask_array<_Tp>::operator=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] = __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +mask_array<_Tp>::operator*=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] *= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +mask_array<_Tp>::operator/=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] /= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +mask_array<_Tp>::operator%=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] %= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +mask_array<_Tp>::operator+=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] += __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +mask_array<_Tp>::operator-=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] -= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +mask_array<_Tp>::operator^=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] ^= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +mask_array<_Tp>::operator&=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] &= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +mask_array<_Tp>::operator|=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] |= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +mask_array<_Tp>::operator<<=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] <<= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +mask_array<_Tp>::operator>>=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] >>= __v[__i]; +} + +template +inline _LIBCPP_INLINE_VISIBILITY +const mask_array<_Tp>& +mask_array<_Tp>::operator=(const mask_array& __ma) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] = __ma.__vp_[__1d_[__i]]; +} + +template +inline _LIBCPP_INLINE_VISIBILITY +void +mask_array<_Tp>::operator=(const value_type& __x) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] = __x; +} + +template +class __mask_expr +{ + typedef typename remove_reference<_ValExpr>::type _RmExpr; +public: + typedef typename _RmExpr::value_type value_type; + typedef value_type result_type; + +private: + _ValExpr __expr_; + valarray __1d_; + + _LIBCPP_INLINE_VISIBILITY + __mask_expr(const valarray& __vb, const _RmExpr& __e) + : __expr_(__e), + __1d_(count(__vb.__begin_, __vb.__end_, true)) + { + size_t __j = 0; + for (size_t __i = 0; __i < __vb.size(); ++__i) + if (__vb[__i]) + __1d_[__j++] = __i; + } + +public: + _LIBCPP_INLINE_VISIBILITY + result_type operator[](size_t __i) const + {return __expr_[__1d_[__i]];} + + _LIBCPP_INLINE_VISIBILITY + size_t size() const {return __1d_.size();} + + template friend class valarray; +}; + +// indirect_array + +template +class _LIBCPP_VISIBLE indirect_array +{ +public: + typedef _Tp value_type; + +private: + value_type* __vp_; + valarray __1d_; + +public: + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator*=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator/=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator%=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator+=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator-=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator^=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator&=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator|=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator<<=(const _Expr& __v) const; + + template + typename enable_if + < + __is_val_expr<_Expr>::value, + void + >::type + operator>>=(const _Expr& __v) const; + + const indirect_array& operator=(const indirect_array& __ia) const; + + void operator=(const value_type& __x) const; + +// indirect_array(const indirect_array&) = default; +// indirect_array(indirect_array&&) = default; +// indirect_array& operator=(const indirect_array&) = default; +// indirect_array& operator=(indirect_array&&) = default; + +private: + _LIBCPP_INLINE_VISIBILITY + indirect_array(const valarray& __ia, const valarray& __v) + : __vp_(const_cast(__v.__begin_)), + __1d_(__ia) + {} + +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + + _LIBCPP_INLINE_VISIBILITY + indirect_array(valarray&& __ia, const valarray& __v) + : __vp_(const_cast(__v.__begin_)), + __1d_(move(__ia)) + {} + +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES + + template friend class valarray; +}; + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +indirect_array<_Tp>::operator=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] = __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +indirect_array<_Tp>::operator*=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] *= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +indirect_array<_Tp>::operator/=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] /= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +indirect_array<_Tp>::operator%=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] %= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +indirect_array<_Tp>::operator+=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] += __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +indirect_array<_Tp>::operator-=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] -= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +indirect_array<_Tp>::operator^=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] ^= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +indirect_array<_Tp>::operator&=(const _Expr& __v) const +{ + size_t __n = __1d_.size(); + for (size_t __i = 0; __i < __n; ++__i) + __vp_[__1d_[__i]] &= __v[__i]; +} + +template +template +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_val_expr<_Expr>::value, + void +>::type +indirect_array<_Tp>::operator|=(const _Expr& __v) const +{