| // -*- C++ -*- |
| //===-------------------------- valarray ----------------------------------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is dual licensed under the MIT and the University of Illinois Open |
| // Source Licenses. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef _LIBCPP_VALARRAY |
| #define _LIBCPP_VALARRAY |
| |
| /* |
| valarray synopsis |
| |
| namespace std |
| { |
| |
| template<class T> |
| 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<value_type>& sa); |
| valarray(const gslice_array<value_type>& ga); |
| valarray(const mask_array<value_type>& ma); |
| valarray(const indirect_array<value_type>& ia); |
| valarray(initializer_list<value_type> il); |
| ~valarray(); |
| |
| // assignment: |
| valarray& operator=(const valarray& v); |
| valarray& operator=(valarray&& v) noexcept; |
| valarray& operator=(initializer_list<value_type> il); |
| valarray& operator=(const value_type& x); |
| valarray& operator=(const slice_array<value_type>& sa); |
| valarray& operator=(const gslice_array<value_type>& ga); |
| valarray& operator=(const mask_array<value_type>& ma); |
| valarray& operator=(const indirect_array<value_type>& 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<value_type> operator[](slice s); |
| valarray operator[](const gslice& gs) const; |
| gslice_array<value_type> operator[](const gslice& gs); |
| valarray operator[](const valarray<bool>& vb) const; |
| mask_array<value_type> operator[](const valarray<bool>& vb); |
| valarray operator[](const valarray<size_t>& vs) const; |
| indirect_array<value_type> operator[](const valarray<size_t>& vs); |
| |
| // unary operators: |
| valarray operator+() const; |
| valarray operator-() const; |
| valarray operator~() const; |
| valarray<bool> 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()); |
| }; |
| |
| class slice |
| { |
| public: |
| slice(); |
| slice(size_t start, size_t size, size_t stride); |
| |
| size_t start() const; |
| size_t size() const; |
| size_t stride() const; |
| }; |
| |
| template <class T> |
| class slice_array |
| { |
| public: |
| typedef T value_type; |
| |
| const slice_array& operator=(const slice_array& sa) const; |
| void operator= (const valarray<value_type>& v) const; |
| void operator*= (const valarray<value_type>& v) const; |
| void operator/= (const valarray<value_type>& v) const; |
| void operator%= (const valarray<value_type>& v) const; |
| void operator+= (const valarray<value_type>& v) const; |
| void operator-= (const valarray<value_type>& v) const; |
| void operator^= (const valarray<value_type>& v) const; |
| void operator&= (const valarray<value_type>& v) const; |
| void operator|= (const valarray<value_type>& v) const; |
| void operator<<=(const valarray<value_type>& v) const; |
| void operator>>=(const valarray<value_type>& v) const; |
| |
| void operator=(const value_type& x) const; |
| |
| slice_array() = delete; |
| }; |
| |
| class gslice |
| { |
| public: |
| gslice(); |
| gslice(size_t start, const valarray<size_t>& size, |
| const valarray<size_t>& stride); |
| |
| size_t start() const; |
| valarray<size_t> size() const; |
| valarray<size_t> stride() const; |
| }; |
| |
| template <class T> |
| class gslice_array |
| { |
| public: |
| typedef T value_type; |
| |
| void operator= (const valarray<value_type>& v) const; |
| void operator*= (const valarray<value_type>& v) const; |
| void operator/= (const valarray<value_type>& v) const; |
| void operator%= (const valarray<value_type>& v) const; |
| void operator+= (const valarray<value_type>& v) const; |
| void operator-= (const valarray<value_type>& v) const; |
| void operator^= (const valarray<value_type>& v) const; |
| void operator&= (const valarray<value_type>& v) const; |
| void operator|= (const valarray<value_type>& v) const; |
| void operator<<=(const valarray<value_type>& v) const; |
| void operator>>=(const valarray<value_type>& 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 T> |
| class mask_array |
| { |
| public: |
| typedef T value_type; |
| |
| void operator= (const valarray<value_type>& v) const; |
| void operator*= (const valarray<value_type>& v) const; |
| void operator/= (const valarray<value_type>& v) const; |
| void operator%= (const valarray<value_type>& v) const; |
| void operator+= (const valarray<value_type>& v) const; |
| void operator-= (const valarray<value_type>& v) const; |
| void operator^= (const valarray<value_type>& v) const; |
| void operator&= (const valarray<value_type>& v) const; |
| void operator|= (const valarray<value_type>& v) const; |
| void operator<<=(const valarray<value_type>& v) const; |
| void operator>>=(const valarray<value_type>& 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 T> |
| class indirect_array |
| { |
| public: |
| typedef T value_type; |
| |
| void operator= (const valarray<value_type>& v) const; |
| void operator*= (const valarray<value_type>& v) const; |
| void operator/= (const valarray<value_type>& v) const; |
| void operator%= (const valarray<value_type>& v) const; |
| void operator+= (const valarray<value_type>& v) const; |
| void operator-= (const valarray<value_type>& v) const; |
| void operator^= (const valarray<value_type>& v) const; |
| void operator&= (const valarray<value_type>& v) const; |
| void operator|= (const valarray<value_type>& v) const; |
| void operator<<=(const valarray<value_type>& v) const; |
| void operator>>=(const valarray<value_type>& 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<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept; |
| |
| template<class T> valarray<T> operator* (const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<T> operator* (const valarray<T>& x, const T& y); |
| template<class T> valarray<T> operator* (const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<T> operator/ (const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<T> operator/ (const valarray<T>& x, const T& y); |
| template<class T> valarray<T> operator/ (const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<T> operator% (const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<T> operator% (const valarray<T>& x, const T& y); |
| template<class T> valarray<T> operator% (const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<T> operator+ (const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<T> operator+ (const valarray<T>& x, const T& y); |
| template<class T> valarray<T> operator+ (const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<T> operator- (const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<T> operator- (const valarray<T>& x, const T& y); |
| template<class T> valarray<T> operator- (const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<T> operator^ (const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<T> operator^ (const valarray<T>& x, const T& y); |
| template<class T> valarray<T> operator^ (const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<T> operator& (const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<T> operator& (const valarray<T>& x, const T& y); |
| template<class T> valarray<T> operator& (const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<T> operator| (const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<T> operator| (const valarray<T>& x, const T& y); |
| template<class T> valarray<T> operator| (const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<T> operator<<(const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<T> operator<<(const valarray<T>& x, const T& y); |
| template<class T> valarray<T> operator<<(const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<T> operator>>(const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<T> operator>>(const valarray<T>& x, const T& y); |
| template<class T> valarray<T> operator>>(const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<bool> operator&&(const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<bool> operator&&(const valarray<T>& x, const T& y); |
| template<class T> valarray<bool> operator&&(const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<bool> operator||(const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<bool> operator||(const valarray<T>& x, const T& y); |
| template<class T> valarray<bool> operator||(const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<bool> operator==(const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<bool> operator==(const valarray<T>& x, const T& y); |
| template<class T> valarray<bool> operator==(const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<bool> operator!=(const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<bool> operator!=(const valarray<T>& x, const T& y); |
| template<class T> valarray<bool> operator!=(const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<bool> operator< (const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<bool> operator< (const valarray<T>& x, const T& y); |
| template<class T> valarray<bool> operator< (const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<bool> operator> (const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<bool> operator> (const valarray<T>& x, const T& y); |
| template<class T> valarray<bool> operator> (const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<bool> operator<=(const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<bool> operator<=(const valarray<T>& x, const T& y); |
| template<class T> valarray<bool> operator<=(const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<bool> operator>=(const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<bool> operator>=(const valarray<T>& x, const T& y); |
| template<class T> valarray<bool> operator>=(const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<T> abs (const valarray<T>& x); |
| template<class T> valarray<T> acos (const valarray<T>& x); |
| template<class T> valarray<T> asin (const valarray<T>& x); |
| template<class T> valarray<T> atan (const valarray<T>& x); |
| |
| template<class T> valarray<T> atan2(const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<T> atan2(const valarray<T>& x, const T& y); |
| template<class T> valarray<T> atan2(const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<T> cos (const valarray<T>& x); |
| template<class T> valarray<T> cosh (const valarray<T>& x); |
| template<class T> valarray<T> exp (const valarray<T>& x); |
| template<class T> valarray<T> log (const valarray<T>& x); |
| template<class T> valarray<T> log10(const valarray<T>& x); |
| |
| template<class T> valarray<T> pow(const valarray<T>& x, const valarray<T>& y); |
| template<class T> valarray<T> pow(const valarray<T>& x, const T& y); |
| template<class T> valarray<T> pow(const T& x, const valarray<T>& y); |
| |
| template<class T> valarray<T> sin (const valarray<T>& x); |
| template<class T> valarray<T> sinh (const valarray<T>& x); |
| template<class T> valarray<T> sqrt (const valarray<T>& x); |
| template<class T> valarray<T> tan (const valarray<T>& x); |
| template<class T> valarray<T> tanh (const valarray<T>& x); |
| |
| template <class T> unspecified1 begin(valarray<T>& v); |
| template <class T> unspecified2 begin(const valarray<T>& v); |
| template <class T> unspecified1 end(valarray<T>& v); |
| template <class T> unspecified2 end(const valarray<T>& v); |
| |
| } // std |
| |
| */ |
| |
| #include <__config> |
| #include <cstddef> |
| #include <cmath> |
| #include <initializer_list> |
| #include <algorithm> |
| #include <functional> |
| #include <new> |
| |
| #include <__undef_min_max> |
| #include <__undef___deallocate> |
| |
| #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
| #pragma GCC system_header |
| #endif |
| |
| _LIBCPP_BEGIN_NAMESPACE_STD |
| |
| template<class _Tp> class _LIBCPP_TYPE_VIS_ONLY valarray; |
| |
| class _LIBCPP_TYPE_VIS_ONLY slice |
| { |
| size_t __start_; |
| size_t __size_; |
| size_t __stride_; |
| public: |
| _LIBCPP_INLINE_VISIBILITY |
| slice() |
| : __start_(0), |
| __size_(0), |
| __stride_(0) |
| {} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| slice(size_t __start, size_t __size, size_t __stride) |
| : __start_(__start), |
| __size_(__size), |
| __stride_(__stride) |
| {} |
| |
| _LIBCPP_INLINE_VISIBILITY size_t start() const {return __start_;} |
| _LIBCPP_INLINE_VISIBILITY size_t size() const {return __size_;} |
| _LIBCPP_INLINE_VISIBILITY size_t stride() const {return __stride_;} |
| }; |
| |
| template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY slice_array; |
| class _LIBCPP_TYPE_VIS gslice; |
| template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY gslice_array; |
| template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY mask_array; |
| template <class _Tp> class _LIBCPP_TYPE_VIS_ONLY indirect_array; |
| |
| template <class _Tp> |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp* |
| begin(valarray<_Tp>& __v); |
| |
| template <class _Tp> |
| _LIBCPP_INLINE_VISIBILITY |
| const _Tp* |
| begin(const valarray<_Tp>& __v); |
| |
| template <class _Tp> |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp* |
| end(valarray<_Tp>& __v); |
| |
| template <class _Tp> |
| _LIBCPP_INLINE_VISIBILITY |
| const _Tp* |
| end(const valarray<_Tp>& __v); |
| |
| template <class _Op, class _A0> |
| struct _UnaryOp |
| { |
| typedef typename _Op::result_type result_type; |
| typedef typename _A0::value_type value_type; |
| |
| _Op __op_; |
| _A0 __a0_; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| _UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| result_type operator[](size_t __i) const {return __op_(__a0_[__i]);} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| size_t size() const {return __a0_.size();} |
| }; |
| |
| template <class _Op, class _A0, class _A1> |
| struct _BinaryOp |
| { |
| typedef typename _Op::result_type result_type; |
| typedef typename _A0::value_type value_type; |
| |
| _Op __op_; |
| _A0 __a0_; |
| _A1 __a1_; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| _BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1) |
| : __op_(__op), __a0_(__a0), __a1_(__a1) {} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| size_t size() const {return __a0_.size();} |
| }; |
| |
| template <class _Tp> |
| 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 <class _Tp> |
| struct __unary_plus : unary_function<_Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return +__x;} |
| }; |
| |
| template <class _Tp> |
| struct __bit_not : unary_function<_Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return ~__x;} |
| }; |
| |
| template <class _Tp> |
| struct __bit_shift_left : binary_function<_Tp, _Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x, const _Tp& __y) const |
| {return __x << __y;} |
| }; |
| |
| template <class _Tp> |
| struct __bit_shift_right : binary_function<_Tp, _Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x, const _Tp& __y) const |
| {return __x >> __y;} |
| }; |
| |
| template <class _Tp, class _Fp> |
| struct __apply_expr : unary_function<_Tp, _Tp> |
| { |
| private: |
| _Fp __f_; |
| public: |
| _LIBCPP_INLINE_VISIBILITY |
| explicit __apply_expr(_Fp __f) : __f_(__f) {} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return __f_(__x);} |
| }; |
| |
| template <class _Tp> |
| struct __abs_expr : unary_function<_Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return abs(__x);} |
| }; |
| |
| template <class _Tp> |
| struct __acos_expr : unary_function<_Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return acos(__x);} |
| }; |
| |
| template <class _Tp> |
| struct __asin_expr : unary_function<_Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return asin(__x);} |
| }; |
| |
| template <class _Tp> |
| struct __atan_expr : unary_function<_Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return atan(__x);} |
| }; |
| |
| template <class _Tp> |
| struct __atan2_expr : binary_function<_Tp, _Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x, const _Tp& __y) const |
| {return atan2(__x, __y);} |
| }; |
| |
| template <class _Tp> |
| struct __cos_expr : unary_function<_Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return cos(__x);} |
| }; |
| |
| template <class _Tp> |
| struct __cosh_expr : unary_function<_Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return cosh(__x);} |
| }; |
| |
| template <class _Tp> |
| struct __exp_expr : unary_function<_Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return exp(__x);} |
| }; |
| |
| template <class _Tp> |
| struct __log_expr : unary_function<_Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return log(__x);} |
| }; |
| |
| template <class _Tp> |
| struct __log10_expr : unary_function<_Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return log10(__x);} |
| }; |
| |
| template <class _Tp> |
| struct __pow_expr : binary_function<_Tp, _Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x, const _Tp& __y) const |
| {return pow(__x, __y);} |
| }; |
| |
| template <class _Tp> |
| struct __sin_expr : unary_function<_Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return sin(__x);} |
| }; |
| |
| template <class _Tp> |
| struct __sinh_expr : unary_function<_Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return sinh(__x);} |
| }; |
| |
| template <class _Tp> |
| struct __sqrt_expr : unary_function<_Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return sqrt(__x);} |
| }; |
| |
| template <class _Tp> |
| struct __tan_expr : unary_function<_Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return tan(__x);} |
| }; |
| |
| template <class _Tp> |
| struct __tanh_expr : unary_function<_Tp, _Tp> |
| { |
| _LIBCPP_INLINE_VISIBILITY |
| _Tp operator()(const _Tp& __x) const |
| {return tanh(__x);} |
| }; |
| |
| template <class _ValExpr> |
| class __slice_expr |
| { |
| typedef typename remove_reference<_ValExpr>::type _RmExpr; |
| public: |
| typedef typename _RmExpr::value_type value_type; |
| typedef value_type result_type; |
| |
| private: |
| _ValExpr __expr_; |
| size_t __start_; |
| size_t __size_; |
| size_t __stride_; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| __slice_expr(const slice& __sl, const _RmExpr& __e) |
| : __expr_(__e), |
| __start_(__sl.start()), |
| __size_(__sl.size()), |
| __stride_(__sl.stride()) |
| {} |
| public: |
| |
| _LIBCPP_INLINE_VISIBILITY |
| result_type operator[](size_t __i) const |
| {return __expr_[__start_ + __i * __stride_];} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| size_t size() const {return __size_;} |
| |
| template <class> friend class _LIBCPP_TYPE_VIS_ONLY valarray; |
| }; |
| |
| template <class _ValExpr> |
| class __mask_expr; |
| |
| template <class _ValExpr> |
| class __indirect_expr; |
| |
| template <class _ValExpr> |
| class __shift_expr |
| { |
| typedef typename remove_reference<_ValExpr>::type _RmExpr; |
| public: |
| typedef typename _RmExpr::value_type value_type; |
| typedef value_type result_type; |
| |
| private: |
| _ValExpr __expr_; |
| size_t __size_; |
| ptrdiff_t __ul_; |
| ptrdiff_t __sn_; |
| ptrdiff_t __n_; |
| static const ptrdiff_t _Np = static_cast<ptrdiff_t>( |
| 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<ptrdiff_t>(__n_ >> _Np); |
| __sn_ = __neg_n | static_cast<ptrdiff_t>(static_cast<size_t>(-__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<ptrdiff_t>(__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 <class> friend class __val_expr; |
| }; |
| |
| template <class _ValExpr> |
| class __cshift_expr |
| { |
| typedef typename remove_reference<_ValExpr>::type _RmExpr; |
| public: |
| typedef typename _RmExpr::value_type value_type; |
| typedef value_type result_type; |
| |
| private: |
| _ValExpr __expr_; |
| size_t __size_; |
| size_t __m_; |
| size_t __o1_; |
| size_t __o2_; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| __cshift_expr(int __n, const _RmExpr& __e) |
| : __expr_(__e), |
| __size_(__e.size()) |
| { |
| __n %= static_cast<int>(__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 <class> friend class __val_expr; |
| }; |
| |
| template<class _ValExpr> |
| class __val_expr; |
| |
| template<class _ValExpr> |
| struct __is_val_expr : false_type {}; |
| |
| template<class _ValExpr> |
| struct __is_val_expr<__val_expr<_ValExpr> > : true_type {}; |
| |
| template<class _Tp> |
| struct __is_val_expr<valarray<_Tp> > : true_type {}; |
| |
| template<class _Tp> |
| class _LIBCPP_TYPE_VIS_ONLY valarray |
| { |
| public: |
| typedef _Tp value_type; |
| typedef _Tp result_type; |
| |
| private: |
| value_type* __begin_; |
| value_type* __end_; |
| |
| public: |
| // construct/destroy: |
| _LIBCPP_INLINE_VISIBILITY |
| valarray() : __begin_(0), __end_(0) {} |
| _LIBCPP_INLINE_VISIBILITY |
| inline 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_HAS_NO_RVALUE_REFERENCES |
| _LIBCPP_INLINE_VISIBILITY |
| valarray(valarray&& __v) _NOEXCEPT; |
| #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS |
| valarray(initializer_list<value_type> __il); |
| #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS |
| valarray(const slice_array<value_type>& __sa); |
| valarray(const gslice_array<value_type>& __ga); |
| valarray(const mask_array<value_type>& __ma); |
| valarray(const indirect_array<value_type>& __ia); |
| inline _LIBCPP_INLINE_VISIBILITY |
| ~valarray(); |
| |
| // assignment: |
| valarray& operator=(const valarray& __v); |
| #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| _LIBCPP_INLINE_VISIBILITY |
| valarray& operator=(valarray&& __v) _NOEXCEPT; |
| #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS |
| _LIBCPP_INLINE_VISIBILITY |
| valarray& operator=(initializer_list<value_type>); |
| #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS |
| _LIBCPP_INLINE_VISIBILITY |
| valarray& operator=(const value_type& __x); |
| _LIBCPP_INLINE_VISIBILITY |
| valarray& operator=(const slice_array<value_type>& __sa); |
| _LIBCPP_INLINE_VISIBILITY |
| valarray& operator=(const gslice_array<value_type>& __ga); |
| _LIBCPP_INLINE_VISIBILITY |
| valarray& operator=(const mask_array<value_type>& __ma); |
| _LIBCPP_INLINE_VISIBILITY |
| valarray& operator=(const indirect_array<value_type>& __ia); |
| template <class _ValExpr> |
| _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<const valarray&> > operator[](slice __s) const; |
| _LIBCPP_INLINE_VISIBILITY |
| slice_array<value_type> operator[](slice __s); |
| _LIBCPP_INLINE_VISIBILITY |
| __val_expr<__indirect_expr<const valarray&> > operator[](const gslice& __gs) const; |
| _LIBCPP_INLINE_VISIBILITY |
| gslice_array<value_type> operator[](const gslice& __gs); |
| #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| _LIBCPP_INLINE_VISIBILITY |
| __val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const; |
| _LIBCPP_INLINE_VISIBILITY |
| gslice_array<value_type> operator[](gslice&& __gs); |
| #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| _LIBCPP_INLINE_VISIBILITY |
| __val_expr<__mask_expr<const valarray&> > operator[](const valarray<bool>& __vb) const; |
| _LIBCPP_INLINE_VISIBILITY |
| mask_array<value_type> operator[](const valarray<bool>& __vb); |
| #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| _LIBCPP_INLINE_VISIBILITY |
| __val_expr<__mask_expr<const valarray&> > operator[](valarray<bool>&& __vb) const; |
| _LIBCPP_INLINE_VISIBILITY |
| mask_array<value_type> operator[](valarray<bool>&& __vb); |
| #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| _LIBCPP_INLINE_VISIBILITY |
| __val_expr<__indirect_expr<const valarray&> > operator[](const valarray<size_t>& __vs) const; |
| _LIBCPP_INLINE_VISIBILITY |
| indirect_array<value_type> operator[](const valarray<size_t>& __vs); |
| #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| _LIBCPP_INLINE_VISIBILITY |
| __val_expr<__indirect_expr<const valarray&> > operator[](valarray<size_t>&& __vs) const; |
| _LIBCPP_INLINE_VISIBILITY |
| indirect_array<value_type> operator[](valarray<size_t>&& __vs); |
| #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| // unary operators: |
| valarray operator+() const; |
| valarray operator-() const; |
| valarray operator~() const; |
| valarray<bool> 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 <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| valarray& |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator*= (const _Expr& __v); |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| valarray& |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator/= (const _Expr& __v); |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| valarray& |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator%= (const _Expr& __v); |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| valarray& |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator+= (const _Expr& __v); |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| valarray& |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator-= (const _Expr& __v); |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| valarray& |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator^= (const _Expr& __v); |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| valarray& |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator|= (const _Expr& __v); |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| valarray& |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator&= (const _Expr& __v); |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| valarray& |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator<<= (const _Expr& __v); |
| |
| template <class _Expr> |
| 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<size_t>(__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 <class> friend class _LIBCPP_TYPE_VIS_ONLY valarray; |
| template <class> friend class _LIBCPP_TYPE_VIS_ONLY slice_array; |
| template <class> friend class _LIBCPP_TYPE_VIS_ONLY gslice_array; |
| template <class> friend class _LIBCPP_TYPE_VIS_ONLY mask_array; |
| template <class> friend class __mask_expr; |
| template <class> friend class _LIBCPP_TYPE_VIS_ONLY indirect_array; |
| template <class> friend class __indirect_expr; |
| template <class> friend class __val_expr; |
| |
| template <class _Up> |
| friend |
| _Up* |
| begin(valarray<_Up>& __v); |
| |
| template <class _Up> |
| friend |
| const _Up* |
| begin(const valarray<_Up>& __v); |
| |
| template <class _Up> |
| friend |
| _Up* |
| end(valarray<_Up>& __v); |
| |
| template <class _Up> |
| friend |
| const _Up* |
| end(const valarray<_Up>& __v); |
| }; |
| |
| _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS valarray<size_t>::valarray(size_t)) |
| _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS valarray<size_t>::~valarray()) |
| _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void valarray<size_t>::resize(size_t, size_t)) |
| |
| template <class _Op, class _Tp> |
| struct _UnaryOp<_Op, valarray<_Tp> > |
| { |
| typedef typename _Op::result_type result_type; |
| typedef _Tp value_type; |
| |
| _Op __op_; |
| const valarray<_Tp>& __a0_; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| _UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| result_type operator[](size_t __i) const {return __op_(__a0_[__i]);} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| size_t size() const {return __a0_.size();} |
| }; |
| |
| template <class _Op, class _Tp, class _A1> |
| struct _BinaryOp<_Op, valarray<_Tp>, _A1> |
| { |
| typedef typename _Op::result_type result_type; |
| typedef _Tp value_type; |
| |
| _Op __op_; |
| const valarray<_Tp>& __a0_; |
| _A1 __a1_; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1) |
| : __op_(__op), __a0_(__a0), __a1_(__a1) {} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| size_t size() const {return __a0_.size();} |
| }; |
| |
| template <class _Op, class _A0, class _Tp> |
| struct _BinaryOp<_Op, _A0, valarray<_Tp> > |
| { |
| typedef typename _Op::result_type result_type; |
| typedef _Tp value_type; |
| |
| _Op __op_; |
| _A0 __a0_; |
| const valarray<_Tp>& __a1_; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| _BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1) |
| : __op_(__op), __a0_(__a0), __a1_(__a1) {} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| size_t size() const {return __a0_.size();} |
| }; |
| |
| template <class _Op, class _Tp> |
| struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> > |
| { |
| typedef typename _Op::result_type result_type; |
| typedef _Tp value_type; |
| |
| _Op __op_; |
| const valarray<_Tp>& __a0_; |
| const valarray<_Tp>& __a1_; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1) |
| : __op_(__op), __a0_(__a0), __a1_(__a1) {} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| size_t size() const {return __a0_.size();} |
| }; |
| |
| // slice_array |
| |
| template <class _Tp> |
| class _LIBCPP_TYPE_VIS_ONLY slice_array |
| { |
| public: |
| typedef _Tp value_type; |
| |
| private: |
| value_type* __vp_; |
| size_t __size_; |
| size_t __stride_; |
| |
| public: |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator*=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator/=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator%=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator+=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator-=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator^=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator&=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator|=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator<<=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator>>=(const _Expr& __v) const; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| const slice_array& operator=(const slice_array& __sa) const; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| void operator=(const value_type& __x) const; |
| |
| private: |
| _LIBCPP_INLINE_VISIBILITY |
| slice_array(const slice& __sl, const valarray<value_type>& __v) |
| : __vp_(const_cast<value_type*>(__v.__begin_ + __sl.start())), |
| __size_(__sl.size()), |
| __stride_(__sl.stride()) |
| {} |
| |
| template <class> friend class valarray; |
| template <class> friend class sliceExpr; |
| }; |
| |
| template <class _Tp> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| 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_TYPE_VIS gslice |
| { |
| valarray<size_t> __size_; |
| valarray<size_t> __stride_; |
| valarray<size_t> __1d_; |
| |
| public: |
| _LIBCPP_INLINE_VISIBILITY |
| gslice() {} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| gslice(size_t __start, const valarray<size_t>& __size, |
| const valarray<size_t>& __stride) |
| : __size_(__size), |
| __stride_(__stride) |
| {__init(__start);} |
| |
| #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| _LIBCPP_INLINE_VISIBILITY |
| gslice(size_t __start, const valarray<size_t>& __size, |
| valarray<size_t>&& __stride) |
| : __size_(__size), |
| __stride_(move(__stride)) |
| {__init(__start);} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| gslice(size_t __start, valarray<size_t>&& __size, |
| const valarray<size_t>& __stride) |
| : __size_(move(__size)), |
| __stride_(__stride) |
| {__init(__start);} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| gslice(size_t __start, valarray<size_t>&& __size, |
| valarray<size_t>&& __stride) |
| : __size_(move(__size)), |
| __stride_(move(__stride)) |
| {__init(__start);} |
| |
| #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| // gslice(const gslice&) = default; |
| // gslice(gslice&&) = default; |
| // gslice& operator=(const gslice&) = default; |
| // gslice& operator=(gslice&&) = default; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| size_t start() const {return __1d_.size() ? __1d_[0] : 0;} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| valarray<size_t> size() const {return __size_;} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| valarray<size_t> stride() const {return __stride_;} |
| |
| private: |
| void __init(size_t __start); |
| |
| template <class> friend class gslice_array; |
| template <class> friend class valarray; |
| template <class> friend class __val_expr; |
| }; |
| |
| // gslice_array |
| |
| template <class _Tp> |
| class _LIBCPP_TYPE_VIS_ONLY gslice_array |
| { |
| public: |
| typedef _Tp value_type; |
| |
| private: |
| value_type* __vp_; |
| valarray<size_t> __1d_; |
| |
| public: |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator*=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator/=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator%=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator+=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator-=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator^=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator&=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator|=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator<<=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| 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; |
| // gslice_array(gslice_array&&) = default; |
| // gslice_array& operator=(const gslice_array&) = default; |
| // gslice_array& operator=(gslice_array&&) = default; |
| |
| private: |
| gslice_array(const gslice& __gs, const valarray<value_type>& __v) |
| : __vp_(const_cast<value_type*>(__v.__begin_)), |
| __1d_(__gs.__1d_) |
| {} |
| |
| #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| gslice_array(gslice&& __gs, const valarray<value_type>& __v) |
| : __vp_(const_cast<value_type*>(__v.__begin_)), |
| __1d_(move(__gs.__1d_)) |
| {} |
| #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| template <class> friend class valarray; |
| }; |
| |
| template <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| 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 <class _Tp> |
| 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 _Tp> |
| class _LIBCPP_TYPE_VIS_ONLY mask_array |
| { |
| public: |
| typedef _Tp value_type; |
| |
| private: |
| value_type* __vp_; |
| valarray<size_t> __1d_; |
| |
| public: |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator*=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator/=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator%=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator+=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator-=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator^=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator&=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator|=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator<<=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator>>=(const _Expr& __v) const; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| const mask_array& operator=(const mask_array& __ma) const; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| void operator=(const value_type& __x) const; |
| |
| // mask_array(const mask_array&) = default; |
| // mask_array(mask_array&&) = default; |
| // mask_array& operator=(const mask_array&) = default; |
| // mask_array& operator=(mask_array&&) = default; |
| |
| private: |
| _LIBCPP_INLINE_VISIBILITY |
| mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v) |
| : __vp_(const_cast<value_type*>(__v.__begin_)), |
| __1d_(static_cast<size_t>(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 <class> friend class valarray; |
| }; |
| |
| template <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| 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 <class _Tp> |
| 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 _ValExpr> |
| class __mask_expr |
| { |
| typedef typename remove_reference<_ValExpr>::type _RmExpr; |
| public: |
| typedef typename _RmExpr::value_type value_type; |
| typedef value_type result_type; |
| |
| private: |
| _ValExpr __expr_; |
| valarray<size_t> __1d_; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| __mask_expr(const valarray<bool>& __vb, const _RmExpr& __e) |
| : __expr_(__e), |
| __1d_(static_cast<size_t>(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 <class> friend class valarray; |
| }; |
| |
| // indirect_array |
| |
| template <class _Tp> |
| class _LIBCPP_TYPE_VIS_ONLY indirect_array |
| { |
| public: |
| typedef _Tp value_type; |
| |
| private: |
| value_type* __vp_; |
| valarray<size_t> __1d_; |
| |
| public: |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator*=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator/=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator%=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator+=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator-=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator^=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator&=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator|=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator<<=(const _Expr& __v) const; |
| |
| template <class _Expr> |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| void |
| >::type |
| _LIBCPP_INLINE_VISIBILITY |
| operator>>=(const _Expr& __v) const; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| const indirect_array& operator=(const indirect_array& __ia) const; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| void operator=(const value_type& __x) const; |
| |
| // indirect_array(const indirect_array&) = default; |
| // indirect_array(indirect_array&&) = default; |
| // indirect_array& operator=(const indirect_array&) = default; |
| // indirect_array& operator=(indirect_array&&) = default; |
| |
| private: |
| _LIBCPP_INLINE_VISIBILITY |
| indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v) |
| : __vp_(const_cast<value_type*>(__v.__begin_)), |
| __1d_(__ia) |
| {} |
| |
| #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| _LIBCPP_INLINE_VISIBILITY |
| indirect_array(valarray<size_t>&& __ia, const valarray<value_type>& __v) |
| : __vp_(const_cast<value_type*>(__v.__begin_)), |
| __1d_(move(__ia)) |
| {} |
| |
| #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| template <class> friend class valarray; |
| }; |
| |
| template <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| 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 <class _Tp> |
| 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 _ValExpr> |
| class __indirect_expr |
| { |
| typedef typename remove_reference<_ValExpr>::type _RmExpr; |
| public: |
| typedef typename _RmExpr::value_type value_type; |
| typedef value_type result_type; |
| |
| private: |
| _ValExpr __expr_; |
| valarray<size_t> __1d_; |
| |
| _LIBCPP_INLINE_VISIBILITY |
| __indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e) |
| : __expr_(__e), |
| __1d_(__ia) |
| {} |
| |
| #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| _LIBCPP_INLINE_VISIBILITY |
| __indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e) |
| : __expr_(__e), |
| __1d_(move(__ia)) |
| {} |
| |
| #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| 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 <class> friend class _LIBCPP_TYPE_VIS_ONLY valarray; |
| }; |
| |
| template<class _ValExpr> |
| class __val_expr |
| { |
| typedef typename remove_reference<_ValExpr>::type _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 |
| {return __val_expr<__slice_expr<_ValExpr> >(__expr_, __s);} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| __val_expr<__indirect_expr<_ValExpr> > operator[](const gslice& __gs) const |
| {return __val_expr<__indirect_expr<_ValExpr> >(__expr_, __gs.__1d_);} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| __val_expr<__mask_expr<_ValExpr> > operator[](const valarray<bool>& __vb) const |
| {return __val_expr<__mask_expr<_ValExpr> >(__expr_, __vb);} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| __val_expr<__indirect_expr<_ValExpr> > operator[](const valarray<size_t>& __vs) const |
| {return __val_expr<__indirect_expr<_ValExpr> >(__expr_, __vs);} |
| |
| _LIBCPP_INLINE_VISIBILITY |
| __val_expr<_UnaryOp<__unary_plus<value_type>, _ValExpr> > |
| operator+() const |
| { |
| typedef _UnaryOp<__unary_plus<value_type>, _ValExpr> _NewExpr; |
| return __val_expr<_NewExpr>(_NewExpr(__unary_plus<value_type>(), __expr_)); |
| } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| __val_expr<_UnaryOp<negate<value_type>, _ValExpr> > |
| operator-() const |
| { |
| typedef _UnaryOp<negate<value_type>, _ValExpr> _NewExpr; |
| return __val_expr<_NewExpr>(_NewExpr(negate<value_type>(), __expr_)); |
| } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| __val_expr<_UnaryOp<__bit_not<value_type>, _ValExpr> > |
| operator~() const |
| { |
| typedef _UnaryOp<__bit_not<value_type>, _ValExpr> _NewExpr; |
| return __val_expr<_NewExpr>(_NewExpr(__bit_not<value_type>(), __expr_)); |
| } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| __val_expr<_UnaryOp<logical_not<value_type>, _ValExpr> > |
| operator!() const |
| { |
| typedef _UnaryOp<logical_not<value_type>, _ValExpr> _NewExpr; |
| return __val_expr<_NewExpr>(_NewExpr(logical_not<value_type>(), __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<value_type, value_type(*)(value_type)>, _ValExpr> > |
| apply(value_type __f(value_type)) const |
| { |
| typedef __apply_expr<value_type, value_type(*)(value_type)> _Op; |
| typedef _UnaryOp<_Op, _ValExpr> _NewExpr; |
| return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_)); |
| } |
| |
| _LIBCPP_INLINE_VISIBILITY |
| __val_expr<_UnaryOp<__apply_expr<value_type, value_type(*)(const value_type&)>, _ValExpr> > |
| apply(value_type __f(const value_type&)) const |
| { |
| typedef __apply_expr<value_type, value_type(*)(const value_type&)> _Op; |
| typedef _UnaryOp<_Op, _ValExpr> _NewExpr; |
| return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_)); |
| } |
| }; |
| |
| template<class _ValExpr> |
| __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_ = |
| static_cast<result_type*>(_VSTD::__allocate(__n * sizeof(result_type))); |
| for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i) |
| ::new (__r.__end_) result_type(__expr_[__i]); |
| } |
| return __r; |
| } |
| |
| // valarray |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>::valarray(size_t __n) |
| : __begin_(0), |
| __end_(0) |
| { |
| resize(__n); |
| } |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>::valarray(const value_type& __x, size_t __n) |
| : __begin_(0), |
| __end_(0) |
| { |
| resize(__n, __x); |
| } |
| |
| template <class _Tp> |
| valarray<_Tp>::valarray(const value_type* __p, size_t __n) |
| : __begin_(0), |
| __end_(0) |
| { |
| if (__n) |
| { |
| __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| try |
| { |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| for (; __n; ++__end_, ++__p, --__n) |
| ::new (__end_) value_type(*__p); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| } |
| catch (...) |
| { |
| resize(0); |
| throw; |
| } |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| } |
| } |
| |
| template <class _Tp> |
| valarray<_Tp>::valarray(const valarray& __v) |
| : __begin_(0), |
| __end_(0) |
| { |
| if (__v.size()) |
| { |
| __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__v.size() * sizeof(value_type))); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| try |
| { |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p) |
| ::new (__end_) value_type(*__p); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| } |
| catch (...) |
| { |
| resize(0); |
| throw; |
| } |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| } |
| } |
| |
| #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>::valarray(valarray&& __v) _NOEXCEPT |
| : __begin_(__v.__begin_), |
| __end_(__v.__end_) |
| { |
| __v.__begin_ = __v.__end_ = nullptr; |
| } |
| |
| #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS |
| |
| template <class _Tp> |
| valarray<_Tp>::valarray(initializer_list<value_type> __il) |
| : __begin_(0), |
| __end_(0) |
| { |
| size_t __n = __il.size(); |
| if (__n) |
| { |
| __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| try |
| { |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| for (const value_type* __p = __il.begin(); __n; ++__end_, ++__p, --__n) |
| ::new (__end_) value_type(*__p); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| } |
| catch (...) |
| { |
| resize(0); |
| throw; |
| } |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| } |
| } |
| |
| #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS |
| |
| template <class _Tp> |
| valarray<_Tp>::valarray(const slice_array<value_type>& __sa) |
| : __begin_(0), |
| __end_(0) |
| { |
| size_t __n = __sa.__size_; |
| if (__n) |
| { |
| __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| try |
| { |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| for (const value_type* __p = __sa.__vp_; __n; ++__end_, __p += __sa.__stride_, --__n) |
| ::new (__end_) value_type(*__p); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| } |
| catch (...) |
| { |
| resize(0); |
| throw; |
| } |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| } |
| } |
| |
| template <class _Tp> |
| valarray<_Tp>::valarray(const gslice_array<value_type>& __ga) |
| : __begin_(0), |
| __end_(0) |
| { |
| size_t __n = __ga.__1d_.size(); |
| if (__n) |
| { |
| __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| try |
| { |
| #endif // _LIBCPP_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 (__end_) value_type(__s[*__i]); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| } |
| catch (...) |
| { |
| resize(0); |
| throw; |
| } |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| } |
| } |
| |
| template <class _Tp> |
| valarray<_Tp>::valarray(const mask_array<value_type>& __ma) |
| : __begin_(0), |
| __end_(0) |
| { |
| size_t __n = __ma.__1d_.size(); |
| if (__n) |
| { |
| __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| try |
| { |
| #endif // _LIBCPP_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 (__end_) value_type(__s[*__i]); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| } |
| catch (...) |
| { |
| resize(0); |
| throw; |
| } |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| } |
| } |
| |
| template <class _Tp> |
| valarray<_Tp>::valarray(const indirect_array<value_type>& __ia) |
| : __begin_(0), |
| __end_(0) |
| { |
| size_t __n = __ia.__1d_.size(); |
| if (__n) |
| { |
| __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| try |
| { |
| #endif // _LIBCPP_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 (__end_) value_type(__s[*__i]); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| } |
| catch (...) |
| { |
| resize(0); |
| throw; |
| } |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| } |
| } |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>::~valarray() |
| { |
| resize(0); |
| } |
| |
| template <class _Tp> |
| valarray<_Tp>& |
| valarray<_Tp>::operator=(const valarray& __v) |
| { |
| if (this != &__v) |
| { |
| if (size() != __v.size()) |
| resize(__v.size()); |
| _VSTD::copy(__v.__begin_, __v.__end_, __begin_); |
| } |
| return *this; |
| } |
| |
| #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT |
| { |
| resize(0); |
| __begin_ = __v.__begin_; |
| __end_ = __v.__end_; |
| __v.__begin_ = nullptr; |
| __v.__end_ = nullptr; |
| return *this; |
| } |
| |
| #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator=(initializer_list<value_type> __il) |
| { |
| if (size() != __il.size()) |
| resize(__il.size()); |
| _VSTD::copy(__il.begin(), __il.end(), __begin_); |
| return *this; |
| } |
| |
| #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator=(const value_type& __x) |
| { |
| _VSTD::fill(__begin_, __end_, __x); |
| return *this; |
| } |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator=(const slice_array<value_type>& __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 <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator=(const gslice_array<value_type>& __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 <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator=(const mask_array<value_type>& __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 <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator=(const indirect_array<value_type>& __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 <class _Tp> |
| template <class _ValExpr> |
| 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 <class _Tp> |
| inline |
| __val_expr<__slice_expr<const valarray<_Tp>&> > |
| valarray<_Tp>::operator[](slice __s) const |
| { |
| return __val_expr<__slice_expr<const valarray&> >(__slice_expr<const valarray&>(__s, *this)); |
| } |
| |
| template <class _Tp> |
| inline |
| slice_array<_Tp> |
| valarray<_Tp>::operator[](slice __s) |
| { |
| return slice_array<value_type>(__s, *this); |
| } |
| |
| template <class _Tp> |
| inline |
| __val_expr<__indirect_expr<const valarray<_Tp>&> > |
| valarray<_Tp>::operator[](const gslice& __gs) const |
| { |
| return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__gs.__1d_, *this)); |
| } |
| |
| template <class _Tp> |
| inline |
| gslice_array<_Tp> |
| valarray<_Tp>::operator[](const gslice& __gs) |
| { |
| return gslice_array<value_type>(__gs, *this); |
| } |
| |
| #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| template <class _Tp> |
| inline |
| __val_expr<__indirect_expr<const valarray<_Tp>&> > |
| valarray<_Tp>::operator[](gslice&& __gs) const |
| { |
| return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(move(__gs.__1d_), *this)); |
| } |
| |
| template <class _Tp> |
| inline |
| gslice_array<_Tp> |
| valarray<_Tp>::operator[](gslice&& __gs) |
| { |
| return gslice_array<value_type>(move(__gs), *this); |
| } |
| |
| #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| template <class _Tp> |
| inline |
| __val_expr<__mask_expr<const valarray<_Tp>&> > |
| valarray<_Tp>::operator[](const valarray<bool>& __vb) const |
| { |
| return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(__vb, *this)); |
| } |
| |
| template <class _Tp> |
| inline |
| mask_array<_Tp> |
| valarray<_Tp>::operator[](const valarray<bool>& __vb) |
| { |
| return mask_array<value_type>(__vb, *this); |
| } |
| |
| #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| template <class _Tp> |
| inline |
| __val_expr<__mask_expr<const valarray<_Tp>&> > |
| valarray<_Tp>::operator[](valarray<bool>&& __vb) const |
| { |
| return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(move(__vb), *this)); |
| } |
| |
| template <class _Tp> |
| inline |
| mask_array<_Tp> |
| valarray<_Tp>::operator[](valarray<bool>&& __vb) |
| { |
| return mask_array<value_type>(move(__vb), *this); |
| } |
| |
| #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| template <class _Tp> |
| inline |
| __val_expr<__indirect_expr<const valarray<_Tp>&> > |
| valarray<_Tp>::operator[](const valarray<size_t>& __vs) const |
| { |
| return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__vs, *this)); |
| } |
| |
| template <class _Tp> |
| inline |
| indirect_array<_Tp> |
| valarray<_Tp>::operator[](const valarray<size_t>& __vs) |
| { |
| return indirect_array<value_type>(__vs, *this); |
| } |
| |
| #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| template <class _Tp> |
| inline |
| __val_expr<__indirect_expr<const valarray<_Tp>&> > |
| valarray<_Tp>::operator[](valarray<size_t>&& __vs) const |
| { |
| return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(move(__vs), *this)); |
| } |
| |
| template <class _Tp> |
| inline |
| indirect_array<_Tp> |
| valarray<_Tp>::operator[](valarray<size_t>&& __vs) |
| { |
| return indirect_array<value_type>(move(__vs), *this); |
| } |
| |
| #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES |
| |
| template <class _Tp> |
| valarray<_Tp> |
| valarray<_Tp>::operator+() const |
| { |
| valarray<value_type> __r; |
| size_t __n = size(); |
| if (__n) |
| { |
| __r.__begin_ = |
| __r.__end_ = |
| static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); |
| for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) |
| ::new (__r.__end_) value_type(+*__p); |
| } |
| return __r; |
| } |
| |
| template <class _Tp> |
| valarray<_Tp> |
| valarray<_Tp>::operator-() const |
| { |
| valarray<value_type> __r; |
| size_t __n = size(); |
| if (__n) |
| { |
| __r.__begin_ = |
| __r.__end_ = |
| static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); |
| for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) |
| ::new (__r.__end_) value_type(-*__p); |
| } |
| return __r; |
| } |
| |
| template <class _Tp> |
| valarray<_Tp> |
| valarray<_Tp>::operator~() const |
| { |
| valarray<value_type> __r; |
| size_t __n = size(); |
| if (__n) |
| { |
| __r.__begin_ = |
| __r.__end_ = |
| static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); |
| for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) |
| ::new (__r.__end_) value_type(~*__p); |
| } |
| return __r; |
| } |
| |
| template <class _Tp> |
| valarray<bool> |
| valarray<_Tp>::operator!() const |
| { |
| valarray<bool> __r; |
| size_t __n = size(); |
| if (__n) |
| { |
| __r.__begin_ = |
| __r.__end_ = |
| static_cast<bool*>(_VSTD::__allocate(__n * sizeof(bool))); |
| for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) |
| ::new (__r.__end_) bool(!*__p); |
| } |
| return __r; |
| } |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator*=(const value_type& __x) |
| { |
| for (value_type* __p = __begin_; __p != __end_; ++__p) |
| *__p *= __x; |
| return *this; |
| } |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator/=(const value_type& __x) |
| { |
| for (value_type* __p = __begin_; __p != __end_; ++__p) |
| *__p /= __x; |
| return *this; |
| } |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator%=(const value_type& __x) |
| { |
| for (value_type* __p = __begin_; __p != __end_; ++__p) |
| *__p %= __x; |
| return *this; |
| } |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator+=(const value_type& __x) |
| { |
| for (value_type* __p = __begin_; __p != __end_; ++__p) |
| *__p += __x; |
| return *this; |
| } |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator-=(const value_type& __x) |
| { |
| for (value_type* __p = __begin_; __p != __end_; ++__p) |
| *__p -= __x; |
| return *this; |
| } |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator^=(const value_type& __x) |
| { |
| for (value_type* __p = __begin_; __p != __end_; ++__p) |
| *__p ^= __x; |
| return *this; |
| } |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator&=(const value_type& __x) |
| { |
| for (value_type* __p = __begin_; __p != __end_; ++__p) |
| *__p &= __x; |
| return *this; |
| } |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator|=(const value_type& __x) |
| { |
| for (value_type* __p = __begin_; __p != __end_; ++__p) |
| *__p |= __x; |
| return *this; |
| } |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator<<=(const value_type& __x) |
| { |
| for (value_type* __p = __begin_; __p != __end_; ++__p) |
| *__p <<= __x; |
| return *this; |
| } |
| |
| template <class _Tp> |
| inline |
| valarray<_Tp>& |
| valarray<_Tp>::operator>>=(const value_type& __x) |
| { |
| for (value_type* __p = __begin_; __p != __end_; ++__p) |
| *__p >>= __x; |
| return *this; |
| } |
| |
| template <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| template <class _Expr> |
| 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 <class _Tp> |
| inline |
| void |
| valarray<_Tp>::swap(valarray& __v) _NOEXCEPT |
| { |
| _VSTD::swap(__begin_, __v.__begin_); |
| _VSTD::swap(__end_, __v.__end_); |
| } |
| |
| template <class _Tp> |
| 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 <class _Tp> |
| inline |
| _Tp |
| valarray<_Tp>::min() const |
| { |
| if (__begin_ == __end_) |
| return value_type(); |
| return *_VSTD::min_element(__begin_, __end_); |
| } |
| |
| template <class _Tp> |
| inline |
| _Tp |
| valarray<_Tp>::max() const |
| { |
| if (__begin_ == __end_) |
| return value_type(); |
| return *_VSTD::max_element(__begin_, __end_); |
| } |
| |
| template <class _Tp> |
| valarray<_Tp> |
| valarray<_Tp>::shift(int __i) const |
| { |
| valarray<value_type> __r; |
| size_t __n = size(); |
| if (__n) |
| { |
| __r.__begin_ = |
| __r.__end_ = |
| static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); |
| const value_type* __sb; |
| value_type* __tb; |
| value_type* __te; |
| if (__i >= 0) |
| { |
| __i = _VSTD::min(__i, static_cast<int>(__n)); |
| __sb = __begin_ + __i; |
| __tb = __r.__begin_; |
| __te = __r.__begin_ + (__n - __i); |
| } |
| else |
| { |
| __i = _VSTD::min(-__i, static_cast<int>(__n)); |
| __sb = __begin_; |
| __tb = __r.__begin_ + __i; |
| __te = __r.__begin_ + __n; |
| } |
| for (; __r.__end_ != __tb; ++__r.__end_) |
| ::new (__r.__end_) value_type(); |
| for (; __r.__end_ != __te; ++__r.__end_, ++__sb) |
| ::new (__r.__end_) value_type(*__sb); |
| for (__te = __r.__begin_ + __n; __r.__end_ != __te; ++__r.__end_) |
| ::new (__r.__end_) value_type(); |
| } |
| return __r; |
| } |
| |
| template <class _Tp> |
| valarray<_Tp> |
| valarray<_Tp>::cshift(int __i) const |
| { |
| valarray<value_type> __r; |
| size_t __n = size(); |
| if (__n) |
| { |
| __r.__begin_ = |
| __r.__end_ = |
| static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); |
| __i %= static_cast<int>(__n); |
| const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i; |
| for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s) |
| ::new (__r.__end_) value_type(*__s); |
| for (const value_type* __s = __begin_; __s != __m; ++__r.__end_, ++__s) |
| ::new (__r.__end_) value_type(*__s); |
| } |
| return __r; |
| } |
| |
| template <class _Tp> |
| valarray<_Tp> |
| valarray<_Tp>::apply(value_type __f(value_type)) const |
| { |
| valarray<value_type> __r; |
| size_t __n = size(); |
| if (__n) |
| { |
| __r.__begin_ = |
| __r.__end_ = |
| static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); |
| for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) |
| ::new (__r.__end_) value_type(__f(*__p)); |
| } |
| return __r; |
| } |
| |
| template <class _Tp> |
| valarray<_Tp> |
| valarray<_Tp>::apply(value_type __f(const value_type&)) const |
| { |
| valarray<value_type> __r; |
| size_t __n = size(); |
| if (__n) |
| { |
| __r.__begin_ = |
| __r.__end_ = |
| static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); |
| for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) |
| ::new (__r.__end_) value_type(__f(*__p)); |
| } |
| return __r; |
| } |
| |
| template <class _Tp> |
| void |
| valarray<_Tp>::resize(size_t __n, value_type __x) |
| { |
| if (__begin_ != nullptr) |
| { |
| while (__end_ != __begin_) |
| (--__end_)->~value_type(); |
| _VSTD::__deallocate(__begin_); |
| __begin_ = __end_ = nullptr; |
| } |
| if (__n) |
| { |
| __begin_ = __end_ = static_cast<value_type*>(_VSTD::__allocate(__n * sizeof(value_type))); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| try |
| { |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| for (; __n; --__n, ++__end_) |
| ::new (__end_) value_type(__x); |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| } |
| catch (...) |
| { |
| resize(0); |
| throw; |
| } |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| } |
| } |
| |
| template<class _Tp> |
| inline _LIBCPP_INLINE_VISIBILITY |
| void |
| swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT |
| { |
| __x.swap(__y); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<multiplies<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator*(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<multiplies<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator*(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<multiplies<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(multiplies<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator*(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<multiplies<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(multiplies<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<divides<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator/(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<divides<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(divides<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<divides<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator/(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<divides<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(divides<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<divides<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator/(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<divides<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(divides<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<modulus<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator%(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<modulus<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<modulus<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator%(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<modulus<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(modulus<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<modulus<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator%(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<modulus<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(modulus<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<plus<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator+(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<plus<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(plus<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<plus<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator+(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<plus<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(plus<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<plus<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator+(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<plus<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(plus<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<minus<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator-(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<minus<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(minus<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<minus<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator-(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<minus<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(minus<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<minus<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator-(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<minus<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(minus<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<bit_xor<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator^(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<bit_xor<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator^(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<bit_xor<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(bit_xor<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator^(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<bit_xor<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(bit_xor<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<bit_and<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator&(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<bit_and<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator&(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<bit_and<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(bit_and<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator&(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<bit_and<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(bit_and<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<bit_or<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator|(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<bit_or<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator|(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<bit_or<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(bit_or<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator|(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<bit_or<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(bit_or<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<__bit_shift_left<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator<<(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<__bit_shift_left<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator<<(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<__bit_shift_left<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator<<(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<__bit_shift_left<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<__bit_shift_right<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator>>(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<__bit_shift_right<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator>>(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<__bit_shift_right<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator>>(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<__bit_shift_right<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<logical_and<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator&&(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<logical_and<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator&&(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<logical_and<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(logical_and<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator&&(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<logical_and<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(logical_and<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<logical_or<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator||(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<logical_or<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator||(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<logical_or<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(logical_or<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator||(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<logical_or<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(logical_or<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator==(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<equal_to<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator==(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(equal_to<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator==(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(equal_to<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<not_equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator!=(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<not_equal_to<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator!=(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<not_equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(not_equal_to<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator!=(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<not_equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(not_equal_to<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<less<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator<(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<less<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(less<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<less<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator<(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<less<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(less<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<less<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator<(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<less<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(less<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<greater<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator>(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<greater<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(greater<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<greater<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator>(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<greater<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(greater<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<greater<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator>(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<greater<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(greater<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<less_equal<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator<=(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<less_equal<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator<=(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<less_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(less_equal<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator<=(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<less_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(less_equal<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<greater_equal<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| operator>=(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<greater_equal<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| operator>=(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<greater_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(greater_equal<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| operator>=(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<greater_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(greater_equal<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| abs(const _Expr& __x) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _UnaryOp<__abs_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__abs_expr<value_type>(), __x)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| acos(const _Expr& __x) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _UnaryOp<__acos_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__acos_expr<value_type>(), __x)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| asin(const _Expr& __x) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _UnaryOp<__asin_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__asin_expr<value_type>(), __x)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| atan(const _Expr& __x) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _UnaryOp<__atan_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__atan_expr<value_type>(), __x)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| atan2(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<__atan2_expr<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| atan2(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<__atan2_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| atan2(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<__atan2_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| cos(const _Expr& __x) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _UnaryOp<__cos_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__cos_expr<value_type>(), __x)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| cosh(const _Expr& __x) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _UnaryOp<__cosh_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__cosh_expr<value_type>(), __x)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| exp(const _Expr& __x) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _UnaryOp<__exp_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__exp_expr<value_type>(), __x)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| log(const _Expr& __x) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _UnaryOp<__log_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__log_expr<value_type>(), __x)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| log10(const _Expr& __x) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _UnaryOp<__log10_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__log10_expr<value_type>(), __x)); |
| } |
| |
| template<class _Expr1, class _Expr2> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, |
| __val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> > |
| >::type |
| pow(const _Expr1& __x, const _Expr2& __y) |
| { |
| typedef typename _Expr1::value_type value_type; |
| typedef _BinaryOp<__pow_expr<value_type>, _Expr1, _Expr2> _Op; |
| return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, |
| _Expr, __scalar_expr<typename _Expr::value_type> > > |
| >::type |
| pow(const _Expr& __x, const typename _Expr::value_type& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<__pow_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op; |
| return __val_expr<_Op>(_Op(__pow_expr<value_type>(), |
| __x, __scalar_expr<value_type>(__y, __x.size()))); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, |
| __scalar_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| pow(const typename _Expr::value_type& __x, const _Expr& __y) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _BinaryOp<__pow_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__pow_expr<value_type>(), |
| __scalar_expr<value_type>(__x, __y.size()), __y)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| sin(const _Expr& __x) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _UnaryOp<__sin_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__sin_expr<value_type>(), __x)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| sinh(const _Expr& __x) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _UnaryOp<__sinh_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__sinh_expr<value_type>(), __x)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| sqrt(const _Expr& __x) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _UnaryOp<__sqrt_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__sqrt_expr<value_type>(), __x)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| tan(const _Expr& __x) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _UnaryOp<__tan_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__tan_expr<value_type>(), __x)); |
| } |
| |
| template<class _Expr> |
| inline _LIBCPP_INLINE_VISIBILITY |
| typename enable_if |
| < |
| __is_val_expr<_Expr>::value, |
| __val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> > |
| >::type |
| tanh(const _Expr& __x) |
| { |
| typedef typename _Expr::value_type value_type; |
| typedef _UnaryOp<__tanh_expr<value_type>, _Expr> _Op; |
| return __val_expr<_Op>(_Op(__tanh_expr<value_type>(), __x)); |
| } |
| |
| template <class _Tp> |
| inline _LIBCPP_INLINE_VISIBILITY |
| _Tp* |
| begin(valarray<_Tp>& __v) |
| { |
| return __v.__begin_; |
| } |
| |
| template <class _Tp> |
| inline _LIBCPP_INLINE_VISIBILITY |
| const _Tp* |
| begin(const valarray<_Tp>& __v) |
| { |
| return __v.__begin_; |
| } |
| |
| template <class _Tp> |
| inline _LIBCPP_INLINE_VISIBILITY |
| _Tp* |
| end(valarray<_Tp>& __v) |
| { |
| return __v.__end_; |
| } |
| |
| template <class _Tp> |
| inline _LIBCPP_INLINE_VISIBILITY |
| const _Tp* |
| end(const valarray<_Tp>& __v) |
| { |
| return __v.__end_; |
| } |
| |
| _LIBCPP_END_NAMESPACE_STD |
| |
| #endif // _LIBCPP_VALARRAY |