// -*- C++ -*- //===----------------------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #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) noexcept; 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) noexcept; 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) noexcept; 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()); }; template valarray(const T(&)[cnt], size_t) -> valarray; 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; friend bool operator==(const slice& x, const slice& y); // since C++20 }; 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; void operator=(const valarray& val_arr) 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) noexcept; 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 <__algorithm/copy.h> #include <__algorithm/count.h> #include <__algorithm/fill.h> #include <__algorithm/max_element.h> #include <__algorithm/min.h> #include <__algorithm/min_element.h> #include <__algorithm/unwrap_iter.h> #include <__assert> // all public C++ headers provide the assertion handler #include <__config> #include <__functional/operations.h> #include <__memory/addressof.h> #include <__memory/allocator.h> #include <__memory/uninitialized_algorithms.h> #include <__type_traits/decay.h> #include <__type_traits/remove_reference.h> #include <__utility/move.h> #include <__utility/swap.h> #include #include #include #include // standard-mandated includes // [valarray.syn] #include #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) # pragma GCC system_header #endif _LIBCPP_PUSH_MACROS #include <__undef_macros> _LIBCPP_BEGIN_NAMESPACE_STD template class _LIBCPP_TEMPLATE_VIS valarray; class _LIBCPP_TEMPLATE_VIS 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_;} #if _LIBCPP_STD_VER >= 20 _LIBCPP_HIDE_FROM_ABI friend bool operator==(const slice& __x, const slice& __y) { return __x.start() == __y.start() && __x.size() == __y.size() && __x.stride() == __y.stride(); } #endif }; template class _LIBCPP_TEMPLATE_VIS slice_array; class _LIBCPP_EXPORTED_FROM_ABI gslice; template class _LIBCPP_TEMPLATE_VIS gslice_array; template class _LIBCPP_TEMPLATE_VIS mask_array; template class _LIBCPP_TEMPLATE_VIS indirect_array; template _LIBCPP_INLINE_VISIBILITY _Tp* begin(valarray<_Tp>& __v); template _LIBCPP_INLINE_VISIBILITY const _Tp* begin(const valarray<_Tp>& __v); template _LIBCPP_INLINE_VISIBILITY _Tp* end(valarray<_Tp>& __v); template _LIBCPP_INLINE_VISIBILITY const _Tp* end(const valarray<_Tp>& __v); template struct _UnaryOp { typedef typename _Op::__result_type __result_type; using value_type = __decay_t<__result_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; using value_type = __decay_t<__result_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 __result_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 { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return +__x;} }; template struct __bit_not { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return ~__x;} }; template struct __bit_shift_left { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x << __y;} }; template struct __bit_shift_right { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return __x >> __y;} }; template struct __apply_expr { private: _Fp __f_; public: typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY explicit __apply_expr(_Fp __f) : __f_(__f) {} _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return __f_(__x);} }; template struct __abs_expr { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return std::abs(__x);} }; template struct __acos_expr { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return std::acos(__x);} }; template struct __asin_expr { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return std::asin(__x);} }; template struct __atan_expr { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return std::atan(__x);} }; template struct __atan2_expr { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return std::atan2(__x, __y);} }; template struct __cos_expr { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return std::cos(__x);} }; template struct __cosh_expr { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return std::cosh(__x);} }; template struct __exp_expr { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return std::exp(__x);} }; template struct __log_expr { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return std::log(__x);} }; template struct __log10_expr { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return std::log10(__x);} }; template struct __pow_expr { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const {return std::pow(__x, __y);} }; template struct __sin_expr { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return std::sin(__x);} }; template struct __sinh_expr { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return std::sinh(__x);} }; template struct __sqrt_expr { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return std::sqrt(__x);} }; template struct __tan_expr { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return std::tan(__x);} }; template struct __tanh_expr { typedef _Tp __result_type; _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const {return std::tanh(__x);} }; template class __slice_expr { typedef __libcpp_remove_reference_t<_ValExpr> _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 __val_expr; template friend class _LIBCPP_TEMPLATE_VIS valarray; }; template class __mask_expr; template class __indirect_expr; template class __shift_expr { typedef __libcpp_remove_reference_t<_ValExpr> _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 _Np = 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_ >> _Np); __sn_ = __neg_n | static_cast(static_cast(-__n_) >> _Np); __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_) >> _Np; 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 __libcpp_remove_reference_t<_ValExpr> _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_TEMPLATE_VIS 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_(nullptr), __end_(nullptr) {} inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit valarray(size_t __n); _LIBCPP_INLINE_VISIBILITY valarray(const value_type& __x, size_t __n); valarray(const value_type* __p, size_t __n); valarray(const valarray& __v); #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY valarray(valarray&& __v) _NOEXCEPT; valarray(initializer_list __il); #endif // _LIBCPP_CXX03_LANG valarray(const slice_array& __sa); valarray(const gslice_array& __ga); valarray(const mask_array& __ma); valarray(const indirect_array& __ia); inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 ~valarray(); // assignment: valarray& operator=(const valarray& __v); #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY valarray& operator=(valarray&& __v) _NOEXCEPT; _LIBCPP_INLINE_VISIBILITY valarray& operator=(initializer_list); #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY valarray& operator=(const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator=(const slice_array& __sa); _LIBCPP_INLINE_VISIBILITY valarray& operator=(const gslice_array& __ga); _LIBCPP_INLINE_VISIBILITY valarray& operator=(const mask_array& __ma); _LIBCPP_INLINE_VISIBILITY valarray& operator=(const indirect_array& __ia); template _LIBCPP_INLINE_VISIBILITY valarray& operator=(const __val_expr<_ValExpr>& __v); // 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: _LIBCPP_INLINE_VISIBILITY __val_expr<__slice_expr > operator[](slice __s) const; _LIBCPP_INLINE_VISIBILITY slice_array operator[](slice __s); _LIBCPP_INLINE_VISIBILITY __val_expr<__indirect_expr > operator[](const gslice& __gs) const; _LIBCPP_INLINE_VISIBILITY gslice_array operator[](const gslice& __gs); #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY __val_expr<__indirect_expr > operator[](gslice&& __gs) const; _LIBCPP_INLINE_VISIBILITY gslice_array operator[](gslice&& __gs); #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY __val_expr<__mask_expr > operator[](const valarray& __vb) const; _LIBCPP_INLINE_VISIBILITY mask_array operator[](const valarray& __vb); #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY __val_expr<__mask_expr > operator[](valarray&& __vb) const; _LIBCPP_INLINE_VISIBILITY mask_array operator[](valarray&& __vb); #endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY __val_expr<__indirect_expr > operator[](const valarray& __vs) const; _LIBCPP_INLINE_VISIBILITY indirect_array operator[](const valarray& __vs); #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY __val_expr<__indirect_expr > operator[](valarray&& __vs) const; _LIBCPP_INLINE_VISIBILITY indirect_array operator[](valarray&& __vs); #endif // _LIBCPP_CXX03_LANG // unary operators: _LIBCPP_INLINE_VISIBILITY __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray&> > operator+() const; _LIBCPP_INLINE_VISIBILITY __val_expr<_UnaryOp, const valarray&> > operator-() const; _LIBCPP_INLINE_VISIBILITY __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray&> > operator~() const; _LIBCPP_INLINE_VISIBILITY __val_expr<_UnaryOp, const valarray&> > operator!() const; // computed assignment: _LIBCPP_INLINE_VISIBILITY valarray& operator*= (const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator/= (const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator%= (const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator+= (const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator-= (const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator^= (const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator&= (const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator|= (const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator<<=(const value_type& __x); _LIBCPP_INLINE_VISIBILITY valarray& operator>>=(const value_type& __x); template typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator*= (const _Expr& __v); template typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator/= (const _Expr& __v); template typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator%= (const _Expr& __v); template typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator+= (const _Expr& __v); template typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator-= (const _Expr& __v); template typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator^= (const _Expr& __v); template typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator|= (const _Expr& __v); template typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator&= (const _Expr& __v); template typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator<<= (const _Expr& __v); template typename enable_if < __is_val_expr<_Expr>::value, valarray& >::type _LIBCPP_INLINE_VISIBILITY operator>>= (const _Expr& __v); // member functions: _LIBCPP_INLINE_VISIBILITY void swap(valarray& __v) _NOEXCEPT; _LIBCPP_INLINE_VISIBILITY size_t size() const {return static_cast(__end_ - __begin_);} _LIBCPP_INLINE_VISIBILITY value_type sum() const; _LIBCPP_INLINE_VISIBILITY value_type min() const; _LIBCPP_INLINE_VISIBILITY 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_TEMPLATE_VIS valarray; template friend class _LIBCPP_TEMPLATE_VIS slice_array; template friend class _LIBCPP_TEMPLATE_VIS gslice_array; template friend class _LIBCPP_TEMPLATE_VIS mask_array; template friend class __mask_expr; template friend class _LIBCPP_TEMPLATE_VIS 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); _LIBCPP_INLINE_VISIBILITY void __clear(size_t __capacity); valarray& __assign_range(const value_type* __f, const value_type* __l); }; #if _LIBCPP_STD_VER >= 17 template valarray(const _Tp(&)[_Size], size_t) -> valarray<_Tp>; #endif extern template _LIBCPP_EXPORTED_FROM_ABI void valarray::resize(size_t, size_t); template struct _UnaryOp<_Op, valarray<_Tp> > { typedef typename _Op::__result_type __result_type; using value_type = __decay_t<__result_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; using value_type = __decay_t<__result_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 __result_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; using value_type = __decay_t<__result_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 __result_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; using value_type = __decay_t<__result_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 __result_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_TEMPLATE_VIS 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 _LIBCPP_INLINE_VISIBILITY operator=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator*=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator/=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator%=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator+=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator-=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator^=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator&=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator|=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator<<=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator>>=(const _Expr& __v) const; slice_array(slice_array const&) = default; _LIBCPP_INLINE_VISIBILITY const slice_array& operator=(const slice_array& __sa) const; _LIBCPP_INLINE_VISIBILITY void operator=(const value_type& __x) const; _LIBCPP_INLINE_VISIBILITY void operator=(const valarray& __va) 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 inline 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; return *this; } template template inline 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 void slice_array<_Tp>::operator=(const valarray& __va) const { value_type* __t = __vp_; for (size_t __i = 0; __i < __va.size(); ++__i, __t += __stride_) *__t = __va[__i]; } template template inline 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 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 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 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 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 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 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 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 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 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 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_EXPORTED_FROM_ABI 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_CXX03_LANG _LIBCPP_INLINE_VISIBILITY gslice(size_t __start, const valarray& __size, valarray&& __stride) : __size_(__size), __stride_(std::move(__stride)) {__init(__start);} _LIBCPP_INLINE_VISIBILITY gslice(size_t __start, valarray&& __size, const valarray& __stride) : __size_(std::move(__size)), __stride_(__stride) {__init(__start);} _LIBCPP_INLINE_VISIBILITY gslice(size_t __start, valarray&& __size, valarray&& __stride) : __size_(std::move(__size)), __stride_(std::move(__stride)) {__init(__start);} #endif // _LIBCPP_CXX03_LANG _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_TEMPLATE_VIS 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 _LIBCPP_INLINE_VISIBILITY operator=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator*=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator/=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator%=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator+=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator-=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator^=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator&=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator|=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator<<=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator>>=(const _Expr& __v) const; _LIBCPP_INLINE_VISIBILITY const gslice_array& operator=(const gslice_array& __ga) const; _LIBCPP_INLINE_VISIBILITY void operator=(const value_type& __x) const; gslice_array(const gslice_array&) = default; private: gslice_array(const gslice& __gs, const valarray& __v) : __vp_(const_cast(__v.__begin_)), __1d_(__gs.__1d_) {} #ifndef _LIBCPP_CXX03_LANG gslice_array(gslice&& __gs, const valarray& __v) : __vp_(const_cast(__v.__begin_)), __1d_(std::move(__gs.__1d_)) {} #endif // _LIBCPP_CXX03_LANG template friend class valarray; }; template template inline 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 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 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 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 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 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 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 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 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 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 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 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 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_TEMPLATE_VIS 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 _LIBCPP_INLINE_VISIBILITY operator=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator*=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator/=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator%=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator+=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator-=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator^=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator&=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator|=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator<<=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator>>=(const _Expr& __v) const; mask_array(const mask_array&) = default; _LIBCPP_INLINE_VISIBILITY const mask_array& operator=(const mask_array& __ma) const; _LIBCPP_INLINE_VISIBILITY void operator=(const value_type& __x) const; private: _LIBCPP_INLINE_VISIBILITY mask_array(const valarray& __vb, const valarray& __v) : __vp_(const_cast(__v.__begin_)), __1d_(static_cast(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 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 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 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 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 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 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 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 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 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 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 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 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]]; return *this; } template inline 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 __libcpp_remove_reference_t<_ValExpr> _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_(static_cast(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 __val_expr; template friend class valarray; }; // indirect_array template class _LIBCPP_TEMPLATE_VIS 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 _LIBCPP_INLINE_VISIBILITY operator=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator*=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator/=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator%=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator+=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator-=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator^=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator&=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator|=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator<<=(const _Expr& __v) const; template typename enable_if < __is_val_expr<_Expr>::value, void >::type _LIBCPP_INLINE_VISIBILITY operator>>=(const _Expr& __v) const; indirect_array(const indirect_array&) = default; _LIBCPP_INLINE_VISIBILITY const indirect_array& operator=(const indirect_array& __ia) const; _LIBCPP_INLINE_VISIBILITY void operator=(const value_type& __x) const; private: _LIBCPP_INLINE_VISIBILITY indirect_array(const valarray& __ia, const valarray& __v) : __vp_(const_cast(__v.__begin_)), __1d_(__ia) {} #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY indirect_array(valarray&& __ia, const valarray& __v) : __vp_(const_cast(__v.__begin_)), __1d_(std::move(__ia)) {} #endif // _LIBCPP_CXX03_LANG template friend class valarray; }; template template inline 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 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 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 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 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 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 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 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 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 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 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 inline const indirect_array<_Tp>& indirect_array<_Tp>::operator=(const indirect_array& __ia) const { typedef const size_t* _Ip; const value_type* __s = __ia.__vp_; for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ia.__1d_.__begin_; __i != __e; ++__i, ++__j) __vp_[*__i] = __s[*__j]; return *this; } template inline void indirect_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; } template class __indirect_expr { typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; public: typedef typename _RmExpr::value_type value_type; typedef value_type __result_type; private: _ValExpr __expr_; valarray __1d_; _LIBCPP_INLINE_VISIBILITY __indirect_expr(const valarray& __ia, const _RmExpr& __e) : __expr_(__e), __1d_(__ia) {} #ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY __indirect_expr(valarray&& __ia, const _RmExpr& __e) : __expr_(__e), __1d_(std::move(__ia)) {} #endif // _LIBCPP_CXX03_LANG 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 __val_expr; template friend class _LIBCPP_TEMPLATE_VIS valarray; }; template class __val_expr { typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; _ValExpr __expr_; public: typedef typename _RmExpr::value_type value_type; typedef typename _RmExpr::__result_type __result_type; _LIBCPP_INLINE_VISIBILITY explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {} _LIBCPP_INLINE_VISIBILITY __result_type operator[](size_t __i) const {return __expr_[__i];} _LIBCPP_INLINE_VISIBILITY __val_expr<__slice_expr<_ValExpr> > operator[](slice __s) const { typedef __slice_expr<_ValExpr> _NewExpr; return __val_expr< _NewExpr >(_NewExpr(__s, __expr_)); } _LIBCPP_INLINE_VISIBILITY __val_expr<__indirect_expr<_ValExpr> > operator[](const gslice& __gs) const { typedef __indirect_expr<_ValExpr> _NewExpr; return __val_expr<_NewExpr >(_NewExpr(__gs.__1d_, __expr_)); } _LIBCPP_INLINE_VISIBILITY __val_expr<__mask_expr<_ValExpr> > operator[](const valarray& __vb) const { typedef __mask_expr<_ValExpr> _NewExpr; return __val_expr< _NewExpr >( _NewExpr(__vb, __expr_)); } _LIBCPP_INLINE_VISIBILITY __val_expr<__indirect_expr<_ValExpr> > operator[](const valarray& __vs) const { typedef __indirect_expr<_ValExpr> _NewExpr; return __val_expr< _NewExpr >(_NewExpr(__vs, __expr_)); } _LIBCPP_INLINE_VISIBILITY __val_expr<_UnaryOp<__unary_plus, _ValExpr> > operator+() const { typedef _UnaryOp<__unary_plus, _ValExpr> _NewExpr; return __val_expr<_NewExpr>(_NewExpr(__unary_plus(), __expr_)); } _LIBCPP_INLINE_VISIBILITY __val_expr<_UnaryOp, _ValExpr> > operator-() const { typedef _UnaryOp, _ValExpr> _NewExpr; return __val_expr<_NewExpr>(_NewExpr(negate(), __expr_)); } _LIBCPP_INLINE_VISIBILITY __val_expr<_UnaryOp<__bit_not, _ValExpr> > operator~() const { typedef _UnaryOp<__bit_not, _ValExpr> _NewExpr; return __val_expr<_NewExpr>(_NewExpr(__bit_not(), __expr_)); } _LIBCPP_INLINE_VISIBILITY __val_expr<_UnaryOp, _ValExpr> > operator!() const { typedef _UnaryOp, _ValExpr> _NewExpr; return __val_expr<_NewExpr>(_NewExpr(logical_not(), __expr_)); } operator valarray<__result_type>() const; _LIBCPP_INLINE_VISIBILITY size_t size() const {return __expr_.size();} _LIBCPP_INLINE_VISIBILITY __result_type sum() const { size_t __n = __expr_.size(); __result_type __r = __n ? __expr_[0] : __result_type(); for (size_t __i = 1; __i < __n; ++__i) __r += __expr_[__i]; return __r; } _LIBCPP_INLINE_VISIBILITY __result_type min() const { size_t __n = size(); __result_type __r = __n ? (*this)[0] : __result_type(); for (size_t __i = 1; __i < __n; ++__i) { __result_type __x = __expr_[__i]; if (__x < __r) __r = __x; } return __r; } _LIBCPP_INLINE_VISIBILITY __result_type max() const { size_t __n = size(); __result_type __r = __n ? (*this)[0] : __result_type(); for (size_t __i = 1; __i < __n; ++__i) { __result_type __x = __expr_[__i]; if (__r < __x) __r = __x; } return __r; } _LIBCPP_INLINE_VISIBILITY __val_expr<__shift_expr<_ValExpr> > shift (int __i) const {return __val_expr<__shift_expr<_ValExpr> >(__shift_expr<_ValExpr>(__i, __expr_));} _LIBCPP_INLINE_VISIBILITY __val_expr<__cshift_expr<_ValExpr> > cshift(int __i) const {return __val_expr<__cshift_expr<_ValExpr> >(__cshift_expr<_ValExpr>(__i, __expr_));} _LIBCPP_INLINE_VISIBILITY __val_expr<_UnaryOp<__apply_expr, _ValExpr> > apply(value_type __f(value_type)) const { typedef __apply_expr _Op; typedef _UnaryOp<_Op, _ValExpr> _NewExpr; return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_)); } _LIBCPP_INLINE_VISIBILITY __val_expr<_UnaryOp<__apply_expr, _ValExpr> > apply(value_type __f(const value_type&)) const { typedef __apply_expr _Op; typedef _UnaryOp<_Op, _ValExpr> _NewExpr; return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_)); } }; template __val_expr<_ValExpr>::operator valarray<__val_expr::__result_type>() const { valarray<__result_type> __r; size_t __n = __expr_.size(); if (__n) { __r.__begin_ = __r.__end_ = allocator<__result_type>().allocate(__n); for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i) ::new ((void*)__r.__end_) __result_type(__expr_[__i]); } return __r; } // valarray template inline valarray<_Tp>::valarray(size_t __n) : __begin_(nullptr), __end_(nullptr) { if (__n) { __begin_ = __end_ = allocator().allocate(__n); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS try { #endif // _LIBCPP_HAS_NO_EXCEPTIONS for (size_t __n_left = __n; __n_left; --__n_left, ++__end_) ::new ((void*)__end_) value_type(); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS } catch (...) { __clear(__n); throw; } #endif // _LIBCPP_HAS_NO_EXCEPTIONS } } template inline valarray<_Tp>::valarray(const value_type& __x, size_t __n) : __begin_(nullptr), __end_(nullptr) { resize(__n, __x); } template valarray<_Tp>::valarray(const value_type* __p, size_t __n) : __begin_(nullptr), __end_(nullptr) { if (__n) { __begin_ = __end_ = allocator().allocate(__n); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS try { #endif // _LIBCPP_HAS_NO_EXCEPTIONS for (size_t __n_left = __n; __n_left; ++__end_, ++__p, --__n_left) ::new ((void*)__end_) value_type(*__p); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS } catch (...) { __clear(__n); throw; } #endif // _LIBCPP_HAS_NO_EXCEPTIONS } } template valarray<_Tp>::valarray(const valarray& __v) : __begin_(nullptr), __end_(nullptr) { if (__v.size()) { __begin_ = __end_ = allocator().allocate(__v.size()); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS try { #endif // _LIBCPP_HAS_NO_EXCEPTIONS for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p) ::new ((void*)__end_) value_type(*__p); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS } catch (...) { __clear(__v.size()); throw; } #endif // _LIBCPP_HAS_NO_EXCEPTIONS } } #ifndef _LIBCPP_CXX03_LANG template inline valarray<_Tp>::valarray(valarray&& __v) _NOEXCEPT : __begin_(__v.__begin_), __end_(__v.__end_) { __v.__begin_ = __v.__end_ = nullptr; } template valarray<_Tp>::valarray(initializer_list __il) : __begin_(nullptr), __end_(nullptr) { const size_t __n = __il.size(); if (__n) { __begin_ = __end_ = allocator().allocate(__n); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS try { #endif // _LIBCPP_HAS_NO_EXCEPTIONS size_t __n_left = __n; for (const value_type* __p = __il.begin(); __n_left; ++__end_, ++__p, --__n_left) ::new ((void*)__end_) value_type(*__p); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS } catch (...) { __clear(__n); throw; } #endif // _LIBCPP_HAS_NO_EXCEPTIONS } } #endif // _LIBCPP_CXX03_LANG template valarray<_Tp>::valarray(const slice_array& __sa) : __begin_(nullptr), __end_(nullptr) { const size_t __n = __sa.__size_; if (__n) { __begin_ = __end_ = allocator().allocate(__n); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS try { #endif // _LIBCPP_HAS_NO_EXCEPTIONS size_t __n_left = __n; for (const value_type* __p = __sa.__vp_; __n_left; ++__end_, __p += __sa.__stride_, --__n_left) ::new ((void*)__end_) value_type(*__p); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS } catch (...) { __clear(__n); throw; } #endif // _LIBCPP_HAS_NO_EXCEPTIONS } } template valarray<_Tp>::valarray(const gslice_array& __ga) : __begin_(nullptr), __end_(nullptr) { const size_t __n = __ga.__1d_.size(); if (__n) { __begin_ = __end_ = allocator().allocate(__n); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS try { #endif // _LIBCPP_HAS_NO_EXCEPTIONS typedef const size_t* _Ip; const value_type* __s = __ga.__vp_; for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__end_) ::new ((void*)__end_) value_type(__s[*__i]); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS } catch (...) { __clear(__n); throw; } #endif // _LIBCPP_HAS_NO_EXCEPTIONS } } template valarray<_Tp>::valarray(const mask_array& __ma) : __begin_(nullptr), __end_(nullptr) { const size_t __n = __ma.__1d_.size(); if (__n) { __begin_ = __end_ = allocator().allocate(__n); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS try { #endif // _LIBCPP_HAS_NO_EXCEPTIONS typedef const size_t* _Ip; const value_type* __s = __ma.__vp_; for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__end_) ::new ((void*)__end_) value_type(__s[*__i]); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS } catch (...) { __clear(__n); throw; } #endif // _LIBCPP_HAS_NO_EXCEPTIONS } } template valarray<_Tp>::valarray(const indirect_array& __ia) : __begin_(nullptr), __end_(nullptr) { const size_t __n = __ia.__1d_.size(); if (__n) { __begin_ = __end_ = allocator().allocate(__n); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS try { #endif // _LIBCPP_HAS_NO_EXCEPTIONS typedef const size_t* _Ip; const value_type* __s = __ia.__vp_; for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__end_) ::new ((void*)__end_) value_type(__s[*__i]); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS } catch (...) { __clear(__n); throw; } #endif // _LIBCPP_HAS_NO_EXCEPTIONS } } template inline valarray<_Tp>::~valarray() { __clear(size()); } template valarray<_Tp>& valarray<_Tp>::__assign_range(const value_type* __f, const value_type* __l) { size_t __n = __l - __f; if (size() != __n) { __clear(size()); __begin_ = allocator().allocate(__n); __end_ = __begin_ + __n; _VSTD::uninitialized_copy(__f, __l, __begin_); } else { _VSTD::copy(__f, __l, __begin_); } return *this; } template valarray<_Tp>& valarray<_Tp>::operator=(const valarray& __v) { if (this != _VSTD::addressof(__v)) return __assign_range(__v.__begin_, __v.__end_); return *this; } #ifndef _LIBCPP_CXX03_LANG template inline valarray<_Tp>& valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT { __clear(size()); __begin_ = __v.__begin_; __end_ = __v.__end_; __v.__begin_ = nullptr; __v.__end_ = nullptr; return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator=(initializer_list __il) { return __assign_range(__il.begin(), __il.end()); } #endif // _LIBCPP_CXX03_LANG template inline valarray<_Tp>& valarray<_Tp>::operator=(const value_type& __x) { _VSTD::fill(__begin_, __end_, __x); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator=(const slice_array& __sa) { value_type* __t = __begin_; const value_type* __s = __sa.__vp_; for (size_t __n = __sa.__size_; __n; --__n, __s += __sa.__stride_, ++__t) *__t = *__s; return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator=(const gslice_array& __ga) { typedef const size_t* _Ip; value_type* __t = __begin_; const value_type* __s = __ga.__vp_; for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__t) *__t = __s[*__i]; return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator=(const mask_array& __ma) { typedef const size_t* _Ip; value_type* __t = __begin_; const value_type* __s = __ma.__vp_; for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__t) *__t = __s[*__i]; return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator=(const indirect_array& __ia) { typedef const size_t* _Ip; value_type* __t = __begin_; const value_type* __s = __ia.__vp_; for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__t) *__t = __s[*__i]; return *this; } template template inline valarray<_Tp>& valarray<_Tp>::operator=(const __val_expr<_ValExpr>& __v) { size_t __n = __v.size(); if (size() != __n) resize(__n); value_type* __t = __begin_; for (size_t __i = 0; __i != __n; ++__t, ++__i) *__t = __result_type(__v[__i]); return *this; } template inline __val_expr<__slice_expr&> > valarray<_Tp>::operator[](slice __s) const { return __val_expr<__slice_expr >(__slice_expr(__s, *this)); } template inline slice_array<_Tp> valarray<_Tp>::operator[](slice __s) { return slice_array(__s, *this); } template inline __val_expr<__indirect_expr&> > valarray<_Tp>::operator[](const gslice& __gs) const { return __val_expr<__indirect_expr >(__indirect_expr(__gs.__1d_, *this)); } template inline gslice_array<_Tp> valarray<_Tp>::operator[](const gslice& __gs) { return gslice_array(__gs, *this); } #ifndef _LIBCPP_CXX03_LANG template inline __val_expr<__indirect_expr&> > valarray<_Tp>::operator[](gslice&& __gs) const { return __val_expr<__indirect_expr >(__indirect_expr(std::move(__gs.__1d_), *this)); } template inline gslice_array<_Tp> valarray<_Tp>::operator[](gslice&& __gs) { return gslice_array(std::move(__gs), *this); } #endif // _LIBCPP_CXX03_LANG template inline __val_expr<__mask_expr&> > valarray<_Tp>::operator[](const valarray& __vb) const { return __val_expr<__mask_expr >(__mask_expr(__vb, *this)); } template inline mask_array<_Tp> valarray<_Tp>::operator[](const valarray& __vb) { return mask_array(__vb, *this); } #ifndef _LIBCPP_CXX03_LANG template inline __val_expr<__mask_expr&> > valarray<_Tp>::operator[](valarray&& __vb) const { return __val_expr<__mask_expr >(__mask_expr(std::move(__vb), *this)); } template inline mask_array<_Tp> valarray<_Tp>::operator[](valarray&& __vb) { return mask_array(std::move(__vb), *this); } #endif // _LIBCPP_CXX03_LANG template inline __val_expr<__indirect_expr&> > valarray<_Tp>::operator[](const valarray& __vs) const { return __val_expr<__indirect_expr >(__indirect_expr(__vs, *this)); } template inline indirect_array<_Tp> valarray<_Tp>::operator[](const valarray& __vs) { return indirect_array(__vs, *this); } #ifndef _LIBCPP_CXX03_LANG template inline __val_expr<__indirect_expr&> > valarray<_Tp>::operator[](valarray&& __vs) const { return __val_expr<__indirect_expr >(__indirect_expr(std::move(__vs), *this)); } template inline indirect_array<_Tp> valarray<_Tp>::operator[](valarray&& __vs) { return indirect_array(std::move(__vs), *this); } #endif // _LIBCPP_CXX03_LANG template inline __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator+() const { using _Op = _UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&>; return __val_expr<_Op>(_Op(__unary_plus<_Tp>(), *this)); } template inline __val_expr<_UnaryOp, const valarray<_Tp>&> > valarray<_Tp>::operator-() const { using _Op = _UnaryOp, const valarray<_Tp>&>; return __val_expr<_Op>(_Op(negate<_Tp>(), *this)); } template inline __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator~() const { using _Op = _UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&>; return __val_expr<_Op>(_Op(__bit_not<_Tp>(), *this)); } template inline __val_expr<_UnaryOp, const valarray<_Tp>&> > valarray<_Tp>::operator!() const { using _Op = _UnaryOp, const valarray<_Tp>&>; return __val_expr<_Op>(_Op(logical_not<_Tp>(), *this)); } template inline valarray<_Tp>& valarray<_Tp>::operator*=(const value_type& __x) { for (value_type* __p = __begin_; __p != __end_; ++__p) *__p *= __x; return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator/=(const value_type& __x) { for (value_type* __p = __begin_; __p != __end_; ++__p) *__p /= __x; return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator%=(const value_type& __x) { for (value_type* __p = __begin_; __p != __end_; ++__p) *__p %= __x; return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator+=(const value_type& __x) { for (value_type* __p = __begin_; __p != __end_; ++__p) *__p += __x; return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator-=(const value_type& __x) { for (value_type* __p = __begin_; __p != __end_; ++__p) *__p -= __x; return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator^=(const value_type& __x) { for (value_type* __p = __begin_; __p != __end_; ++__p) *__p ^= __x; return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator&=(const value_type& __x) { for (value_type* __p = __begin_; __p != __end_; ++__p) *__p &= __x; return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator|=(const value_type& __x) { for (value_type* __p = __begin_; __p != __end_; ++__p) *__p |= __x; return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator<<=(const value_type& __x) { for (value_type* __p = __begin_; __p != __end_; ++__p) *__p <<= __x; return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator>>=(const value_type& __x) { for (value_type* __p = __begin_; __p != __end_; ++__p) *__p >>= __x; return *this; } template template inline typename enable_if < __is_val_expr<_Expr>::value, valarray<_Tp>& >::type valarray<_Tp>::operator*=(const _Expr& __v) { size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t *= __v[__i]; return *this; } template template inline typename enable_if < __is_val_expr<_Expr>::value, valarray<_Tp>& >::type valarray<_Tp>::operator/=(const _Expr& __v) { size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t /= __v[__i]; return *this; } template template inline typename enable_if < __is_val_expr<_Expr>::value, valarray<_Tp>& >::type valarray<_Tp>::operator%=(const _Expr& __v) { size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t %= __v[__i]; return *this; } template template inline typename enable_if < __is_val_expr<_Expr>::value, valarray<_Tp>& >::type valarray<_Tp>::operator+=(const _Expr& __v) { size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t += __v[__i]; return *this; } template template inline typename enable_if < __is_val_expr<_Expr>::value, valarray<_Tp>& >::type valarray<_Tp>::operator-=(const _Expr& __v) { size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t -= __v[__i]; return *this; } template template inline typename enable_if < __is_val_expr<_Expr>::value, valarray<_Tp>& >::type valarray<_Tp>::operator^=(const _Expr& __v) { size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t ^= __v[__i]; return *this; } template template inline typename enable_if < __is_val_expr<_Expr>::value, valarray<_Tp>& >::type valarray<_Tp>::operator|=(const _Expr& __v) { size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t |= __v[__i]; return *this; } template template inline typename enable_if < __is_val_expr<_Expr>::value, valarray<_Tp>& >::type valarray<_Tp>::operator&=(const _Expr& __v) { size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t &= __v[__i]; return *this; } template template inline typename enable_if < __is_val_expr<_Expr>::value, valarray<_Tp>& >::type valarray<_Tp>::operator<<=(const _Expr& __v) { size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t <<= __v[__i]; return *this; } template template inline typename enable_if < __is_val_expr<_Expr>::value, valarray<_Tp>& >::type valarray<_Tp>::operator>>=(const _Expr& __v) { size_t __i = 0; for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i) *__t >>= __v[__i]; return *this; } template inline void valarray<_Tp>::swap(valarray& __v) _NOEXCEPT { _VSTD::swap(__begin_, __v.__begin_); _VSTD::swap(__end_, __v.__end_); } template inline _Tp valarray<_Tp>::sum() const { if (__begin_ == __end_) return value_type(); const value_type* __p = __begin_; _Tp __r = *__p; for (++__p; __p != __end_; ++__p) __r += *__p; return __r; } template inline _Tp valarray<_Tp>::min() const { if (__begin_ == __end_) return value_type(); return *_VSTD::min_element(__begin_, __end_); } template inline _Tp valarray<_Tp>::max() const { if (__begin_ == __end_) return value_type(); return *_VSTD::max_element(__begin_, __end_); } template valarray<_Tp> valarray<_Tp>::shift(int __i) const { valarray __r; size_t __n = size(); if (__n) { __r.__begin_ = __r.__end_ = allocator().allocate(__n); const value_type* __sb; value_type* __tb; value_type* __te; if (__i >= 0) { __i = _VSTD::min(__i, static_cast(__n)); __sb = __begin_ + __i; __tb = __r.__begin_; __te = __r.__begin_ + (__n - __i); } else { __i = _VSTD::min(-__i, static_cast(__n)); __sb = __begin_; __tb = __r.__begin_ + __i; __te = __r.__begin_ + __n; } for (; __r.__end_ != __tb; ++__r.__end_) ::new ((void*)__r.__end_) value_type(); for (; __r.__end_ != __te; ++__r.__end_, ++__sb) ::new ((void*)__r.__end_) value_type(*__sb); for (__te = __r.__begin_ + __n; __r.__end_ != __te; ++__r.__end_) ::new ((void*)__r.__end_) value_type(); } return __r; } template valarray<_Tp> valarray<_Tp>::cshift(int __i) const { valarray __r; size_t __n = size(); if (__n) { __r.__begin_ = __r.__end_ = allocator().allocate(__n); __i %= static_cast(__n); const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i; for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s) ::new ((void*)__r.__end_) value_type(*__s); for (const value_type* __s = __begin_; __s != __m; ++__r.__end_, ++__s) ::new ((void*)__r.__end_) value_type(*__s); } return __r; } template valarray<_Tp> valarray<_Tp>::apply(value_type __f(value_type)) const { valarray __r; size_t __n = size(); if (__n) { __r.__begin_ = __r.__end_ = allocator().allocate(__n); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new ((void*)__r.__end_) value_type(__f(*__p)); } return __r; } template valarray<_Tp> valarray<_Tp>::apply(value_type __f(const value_type&)) const { valarray __r; size_t __n = size(); if (__n) { __r.__begin_ = __r.__end_ = allocator().allocate(__n); for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) ::new ((void*)__r.__end_) value_type(__f(*__p)); } return __r; } template inline void valarray<_Tp>::__clear(size_t __capacity) { if (__begin_ != nullptr) { while (__end_ != __begin_) (--__end_)->~value_type(); allocator().deallocate(__begin_, __capacity); __begin_ = __end_ = nullptr; } } template void valarray<_Tp>::resize(size_t __n, value_type __x) { __clear(size()); if (__n) { __begin_ = __end_ = allocator().allocate(__n); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS try { #endif // _LIBCPP_HAS_NO_EXCEPTIONS for (size_t __n_left = __n; __n_left; --__n_left, ++__end_) ::new ((void*)__end_) value_type(__x); #ifndef _LIBCPP_HAS_NO_EXCEPTIONS } catch (...) { __clear(__n); throw; } #endif // _LIBCPP_HAS_NO_EXCEPTIONS } } template inline _LIBCPP_INLINE_VISIBILITY void swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT { __x.swap(__y); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp, _Expr1, _Expr2> > >::type operator*(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(multiplies(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, _Expr, __scalar_expr > > >::type operator*(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(multiplies(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, __scalar_expr, _Expr> > >::type operator*(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(multiplies(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp, _Expr1, _Expr2> > >::type operator/(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(divides(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, _Expr, __scalar_expr > > >::type operator/(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(divides(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, __scalar_expr, _Expr> > >::type operator/(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(divides(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp, _Expr1, _Expr2> > >::type operator%(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(modulus(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, _Expr, __scalar_expr > > >::type operator%(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(modulus(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, __scalar_expr, _Expr> > >::type operator%(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(modulus(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp, _Expr1, _Expr2> > >::type operator+(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(plus(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, _Expr, __scalar_expr > > >::type operator+(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(plus(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, __scalar_expr, _Expr> > >::type operator+(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(plus(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp, _Expr1, _Expr2> > >::type operator-(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(minus(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, _Expr, __scalar_expr > > >::type operator-(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(minus(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, __scalar_expr, _Expr> > >::type operator-(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(minus(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp, _Expr1, _Expr2> > >::type operator^(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(bit_xor(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, _Expr, __scalar_expr > > >::type operator^(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(bit_xor(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, __scalar_expr, _Expr> > >::type operator^(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(bit_xor(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp, _Expr1, _Expr2> > >::type operator&(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(bit_and(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, _Expr, __scalar_expr > > >::type operator&(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(bit_and(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, __scalar_expr, _Expr> > >::type operator&(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(bit_and(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp, _Expr1, _Expr2> > >::type operator|(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(bit_or(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, _Expr, __scalar_expr > > >::type operator|(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(bit_or(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, __scalar_expr, _Expr> > >::type operator|(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(bit_or(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<__bit_shift_left, _Expr1, _Expr2> > >::type operator<<(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp<__bit_shift_left, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(__bit_shift_left(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<__bit_shift_left, _Expr, __scalar_expr > > >::type operator<<(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp<__bit_shift_left, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(__bit_shift_left(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<__bit_shift_left, __scalar_expr, _Expr> > >::type operator<<(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp<__bit_shift_left, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__bit_shift_left(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<__bit_shift_right, _Expr1, _Expr2> > >::type operator>>(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp<__bit_shift_right, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(__bit_shift_right(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<__bit_shift_right, _Expr, __scalar_expr > > >::type operator>>(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp<__bit_shift_right, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(__bit_shift_right(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<__bit_shift_right, __scalar_expr, _Expr> > >::type operator>>(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp<__bit_shift_right, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__bit_shift_right(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp, _Expr1, _Expr2> > >::type operator&&(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(logical_and(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, _Expr, __scalar_expr > > >::type operator&&(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(logical_and(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, __scalar_expr, _Expr> > >::type operator&&(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(logical_and(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp, _Expr1, _Expr2> > >::type operator||(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(logical_or(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, _Expr, __scalar_expr > > >::type operator||(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(logical_or(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, __scalar_expr, _Expr> > >::type operator||(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(logical_or(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp, _Expr1, _Expr2> > >::type operator==(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(equal_to(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, _Expr, __scalar_expr > > >::type operator==(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(equal_to(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, __scalar_expr, _Expr> > >::type operator==(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(equal_to(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp, _Expr1, _Expr2> > >::type operator!=(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(not_equal_to(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, _Expr, __scalar_expr > > >::type operator!=(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(not_equal_to(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, __scalar_expr, _Expr> > >::type operator!=(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(not_equal_to(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp, _Expr1, _Expr2> > >::type operator<(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(less(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, _Expr, __scalar_expr > > >::type operator<(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(less(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, __scalar_expr, _Expr> > >::type operator<(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(less(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp, _Expr1, _Expr2> > >::type operator>(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(greater(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, _Expr, __scalar_expr > > >::type operator>(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(greater(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, __scalar_expr, _Expr> > >::type operator>(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(greater(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp, _Expr1, _Expr2> > >::type operator<=(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(less_equal(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, _Expr, __scalar_expr > > >::type operator<=(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(less_equal(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, __scalar_expr, _Expr> > >::type operator<=(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(less_equal(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp, _Expr1, _Expr2> > >::type operator>=(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(greater_equal(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, _Expr, __scalar_expr > > >::type operator>=(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(greater_equal(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp, __scalar_expr, _Expr> > >::type operator>=(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(greater_equal(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__abs_expr, _Expr> > >::type abs(const _Expr& __x) { typedef typename _Expr::value_type value_type; typedef _UnaryOp<__abs_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__abs_expr(), __x)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__acos_expr, _Expr> > >::type acos(const _Expr& __x) { typedef typename _Expr::value_type value_type; typedef _UnaryOp<__acos_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__acos_expr(), __x)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__asin_expr, _Expr> > >::type asin(const _Expr& __x) { typedef typename _Expr::value_type value_type; typedef _UnaryOp<__asin_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__asin_expr(), __x)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__atan_expr, _Expr> > >::type atan(const _Expr& __x) { typedef typename _Expr::value_type value_type; typedef _UnaryOp<__atan_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__atan_expr(), __x)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<__atan2_expr, _Expr1, _Expr2> > >::type atan2(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp<__atan2_expr, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(__atan2_expr(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<__atan2_expr, _Expr, __scalar_expr > > >::type atan2(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp<__atan2_expr, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(__atan2_expr(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<__atan2_expr, __scalar_expr, _Expr> > >::type atan2(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp<__atan2_expr, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__atan2_expr(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__cos_expr, _Expr> > >::type cos(const _Expr& __x) { typedef typename _Expr::value_type value_type; typedef _UnaryOp<__cos_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__cos_expr(), __x)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__cosh_expr, _Expr> > >::type cosh(const _Expr& __x) { typedef typename _Expr::value_type value_type; typedef _UnaryOp<__cosh_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__cosh_expr(), __x)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__exp_expr, _Expr> > >::type exp(const _Expr& __x) { typedef typename _Expr::value_type value_type; typedef _UnaryOp<__exp_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__exp_expr(), __x)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__log_expr, _Expr> > >::type log(const _Expr& __x) { typedef typename _Expr::value_type value_type; typedef _UnaryOp<__log_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__log_expr(), __x)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__log10_expr, _Expr> > >::type log10(const _Expr& __x) { typedef typename _Expr::value_type value_type; typedef _UnaryOp<__log10_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__log10_expr(), __x)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, __val_expr<_BinaryOp<__pow_expr, _Expr1, _Expr2> > >::type pow(const _Expr1& __x, const _Expr2& __y) { typedef typename _Expr1::value_type value_type; typedef _BinaryOp<__pow_expr, _Expr1, _Expr2> _Op; return __val_expr<_Op>(_Op(__pow_expr(), __x, __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<__pow_expr, _Expr, __scalar_expr > > >::type pow(const _Expr& __x, const typename _Expr::value_type& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp<__pow_expr, _Expr, __scalar_expr > _Op; return __val_expr<_Op>(_Op(__pow_expr(), __x, __scalar_expr(__y, __x.size()))); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_BinaryOp<__pow_expr, __scalar_expr, _Expr> > >::type pow(const typename _Expr::value_type& __x, const _Expr& __y) { typedef typename _Expr::value_type value_type; typedef _BinaryOp<__pow_expr, __scalar_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__pow_expr(), __scalar_expr(__x, __y.size()), __y)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__sin_expr, _Expr> > >::type sin(const _Expr& __x) { typedef typename _Expr::value_type value_type; typedef _UnaryOp<__sin_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__sin_expr(), __x)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__sinh_expr, _Expr> > >::type sinh(const _Expr& __x) { typedef typename _Expr::value_type value_type; typedef _UnaryOp<__sinh_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__sinh_expr(), __x)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__sqrt_expr, _Expr> > >::type sqrt(const _Expr& __x) { typedef typename _Expr::value_type value_type; typedef _UnaryOp<__sqrt_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__sqrt_expr(), __x)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__tan_expr, _Expr> > >::type tan(const _Expr& __x) { typedef typename _Expr::value_type value_type; typedef _UnaryOp<__tan_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__tan_expr(), __x)); } template inline _LIBCPP_INLINE_VISIBILITY typename enable_if < __is_val_expr<_Expr>::value, __val_expr<_UnaryOp<__tanh_expr, _Expr> > >::type tanh(const _Expr& __x) { typedef typename _Expr::value_type value_type; typedef _UnaryOp<__tanh_expr, _Expr> _Op; return __val_expr<_Op>(_Op(__tanh_expr(), __x)); } template inline _LIBCPP_INLINE_VISIBILITY _Tp* begin(valarray<_Tp>& __v) { return __v.__begin_; } template inline _LIBCPP_INLINE_VISIBILITY const _Tp* begin(const valarray<_Tp>& __v) { return __v.__begin_; } template inline _LIBCPP_INLINE_VISIBILITY _Tp* end(valarray<_Tp>& __v) { return __v.__end_; } template inline _LIBCPP_INLINE_VISIBILITY const _Tp* end(const valarray<_Tp>& __v) { return __v.__end_; } _LIBCPP_END_NAMESPACE_STD _LIBCPP_POP_MACROS #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 # include # include # include # include # include # include # include #endif #endif // _LIBCPP_VALARRAY