From 8cace3f05003c6cb4d38c36890055f03151c2ad4 Mon Sep 17 00:00:00 2001 From: Richard Qin Date: Fri, 16 Oct 2026 02:39:56 +0800 Subject: Remove old code Signed-off-by: Richard Qin --- third_party/libcxx/include/c++/v1/valarray | 3318 ---------------------------- 1 file changed, 3318 deletions(-) delete mode 100644 third_party/libcxx/include/c++/v1/valarray (limited to 'third_party/libcxx/include/c++/v1/valarray') diff --git a/third_party/libcxx/include/c++/v1/valarray b/third_party/libcxx/include/c++/v1/valarray deleted file mode 100644 index 58287b6..0000000 --- a/third_party/libcxx/include/c++/v1/valarray +++ /dev/null @@ -1,3318 +0,0 @@ -// -*- C++ -*- -//===----------------------------------------------------------------------===// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_VALARRAY -#define _LIBCPP_VALARRAY - -/* - valarray synopsis - -namespace std -{ - -template -class valarray -{ -public: - typedef T value_type; - - // construct/destroy: - valarray(); - explicit valarray(size_t n); - valarray(const value_type& x, size_t n); - valarray(const value_type* px, size_t n); - valarray(const valarray& v); - valarray(valarray&& v) noexcept; - valarray(const slice_array& sa); - valarray(const gslice_array& ga); - valarray(const mask_array& ma); - valarray(const indirect_array& ia); - valarray(initializer_list il); - ~valarray(); - - // assignment: - valarray& operator=(const valarray& v); - valarray& operator=(valarray&& v) noexcept; - valarray& operator=(initializer_list il); - valarray& operator=(const value_type& x); - valarray& operator=(const slice_array& sa); - valarray& operator=(const gslice_array& ga); - valarray& operator=(const mask_array& ma); - valarray& operator=(const indirect_array& ia); - - // element access: - const value_type& operator[](size_t i) const; - value_type& operator[](size_t i); - - // subset operations: - valarray operator[](slice s) const; - slice_array operator[](slice s); - valarray operator[](const gslice& gs) const; - gslice_array operator[](const gslice& gs); - valarray operator[](const valarray& vb) const; - mask_array operator[](const valarray& vb); - valarray operator[](const valarray& vs) const; - indirect_array operator[](const valarray& vs); - - // unary operators: - valarray operator+() const; - valarray operator-() const; - valarray operator~() const; - valarray operator!() const; - - // computed assignment: - valarray& operator*= (const value_type& x); - valarray& operator/= (const value_type& x); - valarray& operator%= (const value_type& x); - valarray& operator+= (const value_type& x); - valarray& operator-= (const value_type& x); - valarray& operator^= (const value_type& x); - valarray& operator&= (const value_type& x); - valarray& operator|= (const value_type& x); - valarray& operator<<=(const value_type& x); - valarray& operator>>=(const value_type& x); - - valarray& operator*= (const valarray& v); - valarray& operator/= (const valarray& v); - valarray& operator%= (const valarray& v); - valarray& operator+= (const valarray& v); - valarray& operator-= (const valarray& v); - valarray& operator^= (const valarray& v); - valarray& operator|= (const valarray& v); - valarray& operator&= (const valarray& v); - valarray& operator<<=(const valarray& v); - valarray& operator>>=(const valarray& v); - - // member functions: - void swap(valarray& v) noexcept; - - size_t size() const; - - value_type sum() const; - value_type min() const; - value_type max() const; - - valarray shift (int i) const; - valarray cshift(int i) const; - valarray apply(value_type f(value_type)) const; - valarray apply(value_type f(const value_type&)) const; - void resize(size_t n, value_type x = value_type()); -}; - -template valarray(const T(&)[cnt], size_t) -> valarray; - -class slice -{ -public: - slice(); - slice(size_t start, size_t size, size_t stride); - - size_t start() const; - size_t size() const; - size_t stride() const; - - friend bool operator==(const slice& x, const slice& y); // since C++20 -}; - -template -class slice_array -{ -public: - typedef T value_type; - - const slice_array& operator=(const slice_array& sa) const; - void operator= (const valarray& v) const; - void operator*= (const valarray& v) const; - void operator/= (const valarray& v) const; - void operator%= (const valarray& v) const; - void operator+= (const valarray& v) const; - void operator-= (const valarray& v) const; - void operator^= (const valarray& v) const; - void operator&= (const valarray& v) const; - void operator|= (const valarray& v) const; - void operator<<=(const valarray& v) const; - void operator>>=(const valarray& v) const; - - void operator=(const value_type& x) const; - void operator=(const valarray& val_arr) const; - - slice_array() = delete; -}; - -class gslice -{ -public: - gslice(); - gslice(size_t start, const valarray& size, - const valarray& stride); - - size_t start() const; - valarray size() const; - valarray stride() const; -}; - -template -class gslice_array -{ -public: - typedef T value_type; - - void operator= (const valarray& v) const; - void operator*= (const valarray& v) const; - void operator/= (const valarray& v) const; - void operator%= (const valarray& v) const; - void operator+= (const valarray& v) const; - void operator-= (const valarray& v) const; - void operator^= (const valarray& v) const; - void operator&= (const valarray& v) const; - void operator|= (const valarray& v) const; - void operator<<=(const valarray& v) const; - void operator>>=(const valarray& v) const; - - gslice_array(const gslice_array& ga); - ~gslice_array(); - const gslice_array& operator=(const gslice_array& ga) const; - void operator=(const value_type& x) const; - - gslice_array() = delete; -}; - -template -class mask_array -{ -public: - typedef T value_type; - - void operator= (const valarray& v) const; - void operator*= (const valarray& v) const; - void operator/= (const valarray& v) const; - void operator%= (const valarray& v) const; - void operator+= (const valarray& v) const; - void operator-= (const valarray& v) const; - void operator^= (const valarray& v) const; - void operator&= (const valarray& v) const; - void operator|= (const valarray& v) const; - void operator<<=(const valarray& v) const; - void operator>>=(const valarray& v) const; - - mask_array(const mask_array& ma); - ~mask_array(); - const mask_array& operator=(const mask_array& ma) const; - void operator=(const value_type& x) const; - - mask_array() = delete; -}; - -template -class indirect_array -{ -public: - typedef T value_type; - - void operator= (const valarray& v) const; - void operator*= (const valarray& v) const; - void operator/= (const valarray& v) const; - void operator%= (const valarray& v) const; - void operator+= (const valarray& v) const; - void operator-= (const valarray& v) const; - void operator^= (const valarray& v) const; - void operator&= (const valarray& v) const; - void operator|= (const valarray& v) const; - void operator<<=(const valarray& v) const; - void operator>>=(const valarray& v) const; - - indirect_array(const indirect_array& ia); - ~indirect_array(); - const indirect_array& operator=(const indirect_array& ia) const; - void operator=(const value_type& x) const; - - indirect_array() = delete; -}; - -template void swap(valarray& x, valarray& y) noexcept; - -template valarray operator* (const valarray& x, const valarray& y); -template valarray operator* (const valarray& x, const T& y); -template valarray operator* (const T& x, const valarray& y); - -template valarray operator/ (const valarray& x, const valarray& y); -template valarray operator/ (const valarray& x, const T& y); -template valarray operator/ (const T& x, const valarray& y); - -template valarray operator% (const valarray& x, const valarray& y); -template valarray operator% (const valarray& x, const T& y); -template valarray operator% (const T& x, const valarray& y); - -template valarray operator+ (const valarray& x, const valarray& y); -template valarray operator+ (const valarray& x, const T& y); -template valarray operator+ (const T& x, const valarray& y); - -template valarray operator- (const valarray& x, const valarray& y); -template valarray operator- (const valarray& x, const T& y); -template valarray operator- (const T& x, const valarray& y); - -template valarray operator^ (const valarray& x, const valarray& y); -template valarray operator^ (const valarray& x, const T& y); -template valarray operator^ (const T& x, const valarray& y); - -template valarray operator& (const valarray& x, const valarray& y); -template valarray operator& (const valarray& x, const T& y); -template valarray operator& (const T& x, const valarray& y); - -template valarray operator| (const valarray& x, const valarray& y); -template valarray operator| (const valarray& x, const T& y); -template valarray operator| (const T& x, const valarray& y); - -template valarray operator<<(const valarray& x, const valarray& y); -template valarray operator<<(const valarray& x, const T& y); -template valarray operator<<(const T& x, const valarray& y); - -template valarray operator>>(const valarray& x, const valarray& y); -template valarray operator>>(const valarray& x, const T& y); -template valarray operator>>(const T& x, const valarray& y); - -template valarray operator&&(const valarray& x, const valarray& y); -template valarray operator&&(const valarray& x, const T& y); -template valarray operator&&(const T& x, const valarray& y); - -template valarray operator||(const valarray& x, const valarray& y); -template valarray operator||(const valarray& x, const T& y); -template valarray operator||(const T& x, const valarray& y); - -template valarray operator==(const valarray& x, const valarray& y); -template valarray operator==(const valarray& x, const T& y); -template valarray operator==(const T& x, const valarray& y); - -template valarray operator!=(const valarray& x, const valarray& y); -template valarray operator!=(const valarray& x, const T& y); -template valarray operator!=(const T& x, const valarray& y); - -template valarray operator< (const valarray& x, const valarray& y); -template valarray operator< (const valarray& x, const T& y); -template valarray operator< (const T& x, const valarray& y); - -template valarray operator> (const valarray& x, const valarray& y); -template valarray operator> (const valarray& x, const T& y); -template valarray operator> (const T& x, const valarray& y); - -template valarray operator<=(const valarray& x, const valarray& y); -template valarray operator<=(const valarray& x, const T& y); -template valarray operator<=(const T& x, const valarray& y); - -template valarray operator>=(const valarray& x, const valarray& y); -template valarray operator>=(const valarray& x, const T& y); -template valarray operator>=(const T& x, const valarray& y); - -template valarray abs (const valarray& x); -template valarray acos (const valarray& x); -template valarray asin (const valarray& x); -template valarray atan (const valarray& x); - -template valarray atan2(const valarray& x, const valarray& y); -template valarray atan2(const valarray& x, const T& y); -template valarray atan2(const T& x, const valarray& y); - -template valarray cos (const valarray& x); -template valarray cosh (const valarray& x); -template valarray exp (const valarray& x); -template valarray log (const valarray& x); -template valarray log10(const valarray& x); - -template valarray pow(const valarray& x, const valarray& y); -template valarray pow(const valarray& x, const T& y); -template valarray pow(const T& x, const valarray& y); - -template valarray sin (const valarray& x); -template valarray sinh (const valarray& x); -template valarray sqrt (const valarray& x); -template valarray tan (const valarray& x); -template valarray tanh (const valarray& x); - -template unspecified1 begin(valarray& v); -template unspecified2 begin(const valarray& v); -template unspecified1 end(valarray& v); -template unspecified2 end(const valarray& v); - -} // std - -*/ - -#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS) -# include <__cxx03/valarray> -#else -# include <__algorithm/copy.h> -# include <__algorithm/count.h> -# include <__algorithm/fill.h> -# include <__algorithm/max_element.h> -# include <__algorithm/min.h> -# include <__algorithm/min_element.h> -# include <__algorithm/unwrap_iter.h> -# include <__assert> -# include <__config> -# include <__cstddef/ptrdiff_t.h> -# include <__functional/operations.h> -# include <__memory/addressof.h> -# include <__memory/allocator.h> -# include <__memory/uninitialized_algorithms.h> -# include <__type_traits/decay.h> -# include <__type_traits/remove_reference.h> -# include <__utility/exception_guard.h> -# include <__utility/move.h> -# include <__utility/swap.h> -# include -# include - -// standard-mandated includes - -// [valarray.syn] -# include - -# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) -# pragma GCC system_header -# endif - -_LIBCPP_PUSH_MACROS -# include <__undef_macros> - -_LIBCPP_BEGIN_NAMESPACE_STD - -template -class valarray; - -class slice { - size_t __start_; - size_t __size_; - size_t __stride_; - -public: - _LIBCPP_HIDE_FROM_ABI slice() : __start_(0), __size_(0), __stride_(0) {} - - _LIBCPP_HIDE_FROM_ABI slice(size_t __start, size_t __size, size_t __stride) - : __start_(__start), __size_(__size), __stride_(__stride) {} - - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t start() const { return __start_; } - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; } - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t stride() const { return __stride_; } - -# if _LIBCPP_STD_VER >= 20 - - _LIBCPP_HIDE_FROM_ABI friend bool operator==(const slice& __x, const slice& __y) { - return __x.start() == __y.start() && __x.size() == __y.size() && __x.stride() == __y.stride(); - } - -# endif -}; - -template -class slice_array; -class _LIBCPP_EXPORTED_FROM_ABI gslice; -template -class gslice_array; -template -class mask_array; -template -class indirect_array; - -template -_LIBCPP_HIDE_FROM_ABI _Tp* begin(valarray<_Tp>& __v); - -template -_LIBCPP_HIDE_FROM_ABI const _Tp* begin(const valarray<_Tp>& __v); - -template -_LIBCPP_HIDE_FROM_ABI _Tp* end(valarray<_Tp>& __v); - -template -_LIBCPP_HIDE_FROM_ABI const _Tp* end(const valarray<_Tp>& __v); - -template -struct _UnaryOp { - typedef typename _Op::__result_type __result_type; - using value_type = __decay_t<__result_type>; - - _Op __op_; - _A0 __a0_; - - _LIBCPP_HIDE_FROM_ABI _UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {} - - _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i]); } - - _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); } -}; - -template -struct _BinaryOp { - typedef typename _Op::__result_type __result_type; - using value_type = __decay_t<__result_type>; - - _Op __op_; - _A0 __a0_; - _A1 __a1_; - - _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1) - : __op_(__op), __a0_(__a0), __a1_(__a1) {} - - _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); } - - _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); } -}; - -template -class __scalar_expr { -public: - typedef _Tp value_type; - typedef const _Tp& __result_type; - -private: - const value_type& __t_; - size_t __s_; - -public: - _LIBCPP_HIDE_FROM_ABI explicit __scalar_expr(const value_type& __t, size_t __s) : __t_(__t), __s_(__s) {} - - _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t) const { return __t_; } - - _LIBCPP_HIDE_FROM_ABI size_t size() const { return __s_; } -}; - -template -struct __unary_plus { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return +__x; } -}; - -template -struct __bit_not { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return ~__x; } -}; - -template -struct __bit_shift_left { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x << __y; } -}; - -template -struct __bit_shift_right { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x >> __y; } -}; - -template -struct __apply_expr { -private: - _Fp __f_; - -public: - typedef _Tp __result_type; - - _LIBCPP_HIDE_FROM_ABI explicit __apply_expr(_Fp __f) : __f_(__f) {} - - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return __f_(__x); } -}; - -template -struct __abs_expr { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::abs(__x); } -}; - -template -struct __acos_expr { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::acos(__x); } -}; - -template -struct __asin_expr { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::asin(__x); } -}; - -template -struct __atan_expr { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::atan(__x); } -}; - -template -struct __atan2_expr { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return std::atan2(__x, __y); } -}; - -template -struct __cos_expr { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::cos(__x); } -}; - -template -struct __cosh_expr { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::cosh(__x); } -}; - -template -struct __exp_expr { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::exp(__x); } -}; - -template -struct __log_expr { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::log(__x); } -}; - -template -struct __log10_expr { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::log10(__x); } -}; - -template -struct __pow_expr { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return std::pow(__x, __y); } -}; - -template -struct __sin_expr { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::sin(__x); } -}; - -template -struct __sinh_expr { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::sinh(__x); } -}; - -template -struct __sqrt_expr { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::sqrt(__x); } -}; - -template -struct __tan_expr { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::tan(__x); } -}; - -template -struct __tanh_expr { - typedef _Tp __result_type; - _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::tanh(__x); } -}; - -template -class __slice_expr { - typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; - -public: - typedef typename _RmExpr::value_type value_type; - typedef value_type __result_type; - -private: - _ValExpr __expr_; - size_t __start_; - size_t __size_; - size_t __stride_; - - _LIBCPP_HIDE_FROM_ABI __slice_expr(const slice& __sl, const _RmExpr& __e) - : __expr_(__e), __start_(__sl.start()), __size_(__sl.size()), __stride_(__sl.stride()) {} - -public: - _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__start_ + __i * __stride_]; } - - _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; } - - template - friend class __val_expr; - template - friend class valarray; -}; - -template -class __mask_expr; - -template -class __indirect_expr; - -template -class __shift_expr { - typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; - -public: - typedef typename _RmExpr::value_type value_type; - typedef value_type __result_type; - -private: - _ValExpr __expr_; - size_t __size_; - ptrdiff_t __ul_; - ptrdiff_t __sn_; - ptrdiff_t __n_; - static const ptrdiff_t _Np = static_cast(sizeof(ptrdiff_t) * __CHAR_BIT__ - 1); - - _LIBCPP_HIDE_FROM_ABI __shift_expr(int __n, const _RmExpr& __e) : __expr_(__e), __size_(__e.size()), __n_(__n) { - ptrdiff_t __neg_n = static_cast(__n_ >> _Np); - __sn_ = __neg_n | static_cast(static_cast(-__n_) >> _Np); - __ul_ = ((__size_ - __n_) & ~__neg_n) | ((__n_ + 1) & __neg_n); - } - -public: - _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __j) const { - ptrdiff_t __i = static_cast(__j); - ptrdiff_t __m = (__sn_ * __i - __ul_) >> _Np; - return (__expr_[(__i + __n_) & __m] & __m) | (value_type() & ~__m); - } - - _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; } - - template - friend class __val_expr; -}; - -template -class __cshift_expr { - typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; - -public: - typedef typename _RmExpr::value_type value_type; - typedef value_type __result_type; - -private: - _ValExpr __expr_; - size_t __size_; - size_t __m_; - size_t __o1_; - size_t __o2_; - - _LIBCPP_HIDE_FROM_ABI __cshift_expr(int __n, const _RmExpr& __e) : __expr_(__e), __size_(__e.size()) { - __n %= static_cast(__size_); - if (__n >= 0) { - __m_ = __size_ - __n; - __o1_ = __n; - __o2_ = __n - __size_; - } else { - __m_ = -__n; - __o1_ = __n + __size_; - __o2_ = __n; - } - } - -public: - _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { - if (__i < __m_) - return __expr_[__i + __o1_]; - return __expr_[__i + __o2_]; - } - - _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; } - - template - friend class __val_expr; -}; - -template -class __val_expr; - -template -struct __is_val_expr : false_type {}; - -template -struct __is_val_expr<__val_expr<_ValExpr> > : true_type {}; - -template -struct __is_val_expr > : true_type {}; - -template -struct __is_val_expr > : true_type {}; - -template -struct __is_val_expr > : true_type {}; - -template -struct __is_val_expr > : true_type {}; - -template -struct __is_val_expr > : true_type {}; - -// The functions using a __val_expr access the elements by their index. -// valarray and the libc++ lazy proxies have an operator[]. The -// Standard proxy array's don't have this operator, instead they have a -// implementation specific accessor -// __get(size_t) -// -// The functions use the non-member function -// __get(__val_expr, size_t) -// -// If the __val_expr is a specialization of __val_expr_use_member_functions it -// uses the __val_expr's member function -// __get(size_t) -// else it uses the __val_expr's member function -// operator[](size_t) -template -struct __val_expr_use_member_functions; - -template -struct __val_expr_use_member_functions : false_type {}; - -template -struct __val_expr_use_member_functions > : true_type {}; - -template -struct __val_expr_use_member_functions > : true_type {}; - -template -struct __val_expr_use_member_functions > : true_type {}; - -template -struct __val_expr_use_member_functions > : true_type {}; - -template -class valarray { -public: - typedef _Tp value_type; - typedef _Tp __result_type; - -private: - value_type* __begin_; - value_type* __end_; - -public: - // construct/destroy: - _LIBCPP_HIDE_FROM_ABI valarray() : __begin_(nullptr), __end_(nullptr) {} - inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 explicit valarray(size_t __n); - _LIBCPP_HIDE_FROM_ABI valarray(const value_type& __x, size_t __n); - valarray(const value_type* __p, size_t __n); - valarray(const valarray& __v); -# ifndef _LIBCPP_CXX03_LANG - _LIBCPP_HIDE_FROM_ABI valarray(valarray&& __v) _NOEXCEPT; - valarray(initializer_list __il); -# endif // _LIBCPP_CXX03_LANG - valarray(const slice_array& __sa); - valarray(const gslice_array& __ga); - valarray(const mask_array& __ma); - valarray(const indirect_array& __ia); - inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 ~valarray(); - - // assignment: - valarray& operator=(const valarray& __v); -# ifndef _LIBCPP_CXX03_LANG - _LIBCPP_HIDE_FROM_ABI valarray& operator=(valarray&& __v) _NOEXCEPT; - _LIBCPP_HIDE_FROM_ABI valarray& operator=(initializer_list); -# endif // _LIBCPP_CXX03_LANG - _LIBCPP_HIDE_FROM_ABI valarray& operator=(const value_type& __x); - _LIBCPP_HIDE_FROM_ABI valarray& operator=(const slice_array& __sa); - _LIBCPP_HIDE_FROM_ABI valarray& operator=(const gslice_array& __ga); - _LIBCPP_HIDE_FROM_ABI valarray& operator=(const mask_array& __ma); - _LIBCPP_HIDE_FROM_ABI valarray& operator=(const indirect_array& __ia); - template - _LIBCPP_HIDE_FROM_ABI valarray& operator=(const __val_expr<_ValExpr>& __v); - - // element access: - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const value_type& operator[](size_t __i) const { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < size(), "valarray::operator[] index out of bounds"); - return __begin_[__i]; - } - - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI value_type& operator[](size_t __i) { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < size(), "valarray::operator[] index out of bounds"); - return __begin_[__i]; - } - - // subset operations: - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI __val_expr<__slice_expr > operator[](slice __s) const; - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI slice_array operator[](slice __s); - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr > - operator[](const gslice& __gs) const; - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI gslice_array operator[](const gslice& __gs); -# ifndef _LIBCPP_CXX03_LANG - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr > operator[](gslice&& __gs) const; - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI gslice_array operator[](gslice&& __gs); -# endif // _LIBCPP_CXX03_LANG - [[__nodiscard__]] - _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr > operator[](const valarray& __vb) const; - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI mask_array operator[](const valarray& __vb); -# ifndef _LIBCPP_CXX03_LANG - [[__nodiscard__]] - _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr > operator[](valarray&& __vb) const; - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI mask_array operator[](valarray&& __vb); -# endif // _LIBCPP_CXX03_LANG - [[__nodiscard__]] - _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr > operator[](const valarray& __vs) const; - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI indirect_array operator[](const valarray& __vs); -# ifndef _LIBCPP_CXX03_LANG - [[__nodiscard__]] - _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr > operator[](valarray&& __vs) const; - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI indirect_array operator[](valarray&& __vs); -# endif // _LIBCPP_CXX03_LANG - - // unary operators: - _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray&> > operator+() const; - _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp, const valarray&> > operator-() const; - _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray&> > operator~() const; - _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp, const valarray&> > operator!() const; - - // computed assignment: - _LIBCPP_HIDE_FROM_ABI valarray& operator*=(const value_type& __x); - _LIBCPP_HIDE_FROM_ABI valarray& operator/=(const value_type& __x); - _LIBCPP_HIDE_FROM_ABI valarray& operator%=(const value_type& __x); - _LIBCPP_HIDE_FROM_ABI valarray& operator+=(const value_type& __x); - _LIBCPP_HIDE_FROM_ABI valarray& operator-=(const value_type& __x); - _LIBCPP_HIDE_FROM_ABI valarray& operator^=(const value_type& __x); - _LIBCPP_HIDE_FROM_ABI valarray& operator&=(const value_type& __x); - _LIBCPP_HIDE_FROM_ABI valarray& operator|=(const value_type& __x); - _LIBCPP_HIDE_FROM_ABI valarray& operator<<=(const value_type& __x); - _LIBCPP_HIDE_FROM_ABI valarray& operator>>=(const value_type& __x); - - template ::value, int> = 0> - _LIBCPP_HIDE_FROM_ABI valarray& operator*=(const _Expr& __v); - - template ::value, int> = 0> - _LIBCPP_HIDE_FROM_ABI valarray& operator/=(const _Expr& __v); - - template ::value, int> = 0> - _LIBCPP_HIDE_FROM_ABI valarray& operator%=(const _Expr& __v); - - template ::value, int> = 0> - _LIBCPP_HIDE_FROM_ABI valarray& operator+=(const _Expr& __v); - - template ::value, int> = 0> - _LIBCPP_HIDE_FROM_ABI valarray& operator-=(const _Expr& __v); - - template ::value, int> = 0> - _LIBCPP_HIDE_FROM_ABI valarray& operator^=(const _Expr& __v); - - template ::value, int> = 0> - _LIBCPP_HIDE_FROM_ABI valarray& operator|=(const _Expr& __v); - - template ::value, int> = 0> - _LIBCPP_HIDE_FROM_ABI valarray& operator&=(const _Expr& __v); - - template ::value, int> = 0> - _LIBCPP_HIDE_FROM_ABI valarray& operator<<=(const _Expr& __v); - - template ::value, int> = 0> - _LIBCPP_HIDE_FROM_ABI valarray& operator>>=(const _Expr& __v); - - // member functions: - _LIBCPP_HIDE_FROM_ABI void swap(valarray& __v) _NOEXCEPT; - - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t size() const { return static_cast(__end_ - __begin_); } - - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI value_type sum() const; - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI value_type min() const; - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI value_type max() const; - - [[__nodiscard__]] valarray shift(int __i) const; - [[__nodiscard__]] valarray cshift(int __i) const; - [[__nodiscard__]] valarray apply(value_type __f(value_type)) const; - [[__nodiscard__]] valarray apply(value_type __f(const value_type&)) const; - void resize(size_t __n, value_type __x = value_type()); - -private: - template - friend class valarray; - template - friend class slice_array; - template - friend class gslice_array; - template - friend class mask_array; - template - friend class __mask_expr; - template - friend class indirect_array; - template - friend class __indirect_expr; - template - friend class __val_expr; - - template - friend _Up* begin(valarray<_Up>& __v); - - template - friend const _Up* begin(const valarray<_Up>& __v); - - template - friend _Up* end(valarray<_Up>& __v); - - template - friend const _Up* end(const valarray<_Up>& __v); - - _LIBCPP_HIDE_FROM_ABI void __clear(size_t __capacity); - valarray& __assign_range(const value_type* __f, const value_type* __l); -}; - -# if _LIBCPP_STD_VER >= 17 -template -valarray(const _Tp (&)[_Size], size_t) -> valarray<_Tp>; -# endif - -template ::value && __val_expr_use_member_functions<_Expr>::value, int> = 0> -_LIBCPP_HIDE_FROM_ABI typename _Expr::value_type __get(const _Expr& __v, size_t __i) { - return __v.__get(__i); -} - -template ::value && !__val_expr_use_member_functions<_Expr>::value, int> = 0> -_LIBCPP_HIDE_FROM_ABI typename _Expr::value_type __get(const _Expr& __v, size_t __i) { - return __v[__i]; -} - -extern template _LIBCPP_EXPORTED_FROM_ABI void valarray::resize(size_t, size_t); - -template -struct _UnaryOp<_Op, valarray<_Tp> > { - typedef typename _Op::__result_type __result_type; - using value_type = __decay_t<__result_type>; - - _Op __op_; - const valarray<_Tp>& __a0_; - - _LIBCPP_HIDE_FROM_ABI _UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {} - - _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i]); } - - _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); } -}; - -template -struct _BinaryOp<_Op, valarray<_Tp>, _A1> { - typedef typename _Op::__result_type __result_type; - using value_type = __decay_t<__result_type>; - - _Op __op_; - const valarray<_Tp>& __a0_; - _A1 __a1_; - - _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1) - : __op_(__op), __a0_(__a0), __a1_(__a1) {} - - _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); } - - _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); } -}; - -template -struct _BinaryOp<_Op, _A0, valarray<_Tp> > { - typedef typename _Op::__result_type __result_type; - using value_type = __decay_t<__result_type>; - - _Op __op_; - _A0 __a0_; - const valarray<_Tp>& __a1_; - - _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1) - : __op_(__op), __a0_(__a0), __a1_(__a1) {} - - _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); } - - _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); } -}; - -template -struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> > { - typedef typename _Op::__result_type __result_type; - using value_type = __decay_t<__result_type>; - - _Op __op_; - const valarray<_Tp>& __a0_; - const valarray<_Tp>& __a1_; - - _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1) - : __op_(__op), __a0_(__a0), __a1_(__a1) {} - - _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); } - - _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); } -}; - -// slice_array - -template -class slice_array { -public: - typedef _Tp value_type; - -private: - value_type* __vp_; - size_t __size_; - size_t __stride_; - -public: - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const; - - slice_array(slice_array const&) = default; - - _LIBCPP_HIDE_FROM_ABI const slice_array& operator=(const slice_array& __sa) const; - - _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const; - - _LIBCPP_HIDE_FROM_ABI void operator=(const valarray& __va) const; - - // Behaves like __val_expr::operator[], which returns by value. - _LIBCPP_HIDE_FROM_ABI value_type __get(size_t __i) const { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __size_, "slice_array.__get() index out of bounds"); - return __vp_[__i * __stride_]; - } - -private: - _LIBCPP_HIDE_FROM_ABI slice_array(const slice& __sl, const valarray& __v) - : __vp_(const_cast(__v.__begin_ + __sl.start())), __size_(__sl.size()), __stride_(__sl.stride()) {} - - template - friend class valarray; -}; - -template -inline const slice_array<_Tp>& slice_array<_Tp>::operator=(const slice_array& __sa) const { - value_type* __t = __vp_; - const value_type* __s = __sa.__vp_; - for (size_t __n = __size_; __n; --__n, __t += __stride_, __s += __sa.__stride_) - *__t = *__s; - return *this; -} - -template -template ::value, int> > -inline void slice_array<_Tp>::operator=(const _Expr& __v) const { - value_type* __t = __vp_; - for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) - *__t = __v[__i]; -} - -template -inline void slice_array<_Tp>::operator=(const valarray& __va) const { - value_type* __t = __vp_; - for (size_t __i = 0; __i < __va.size(); ++__i, __t += __stride_) - *__t = __va[__i]; -} - -template -template ::value, int> > -inline void slice_array<_Tp>::operator*=(const _Expr& __v) const { - value_type* __t = __vp_; - for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) - *__t *= __v[__i]; -} - -template -template ::value, int> > -inline void slice_array<_Tp>::operator/=(const _Expr& __v) const { - value_type* __t = __vp_; - for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) - *__t /= __v[__i]; -} - -template -template ::value, int> > -inline void slice_array<_Tp>::operator%=(const _Expr& __v) const { - value_type* __t = __vp_; - for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) - *__t %= __v[__i]; -} - -template -template ::value, int> > -inline void slice_array<_Tp>::operator+=(const _Expr& __v) const { - value_type* __t = __vp_; - for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) - *__t += __v[__i]; -} - -template -template ::value, int> > -inline void slice_array<_Tp>::operator-=(const _Expr& __v) const { - value_type* __t = __vp_; - for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) - *__t -= __v[__i]; -} - -template -template ::value, int> > -inline void slice_array<_Tp>::operator^=(const _Expr& __v) const { - value_type* __t = __vp_; - for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) - *__t ^= __v[__i]; -} - -template -template ::value, int> > -inline void slice_array<_Tp>::operator&=(const _Expr& __v) const { - value_type* __t = __vp_; - for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) - *__t &= __v[__i]; -} - -template -template ::value, int> > -inline void slice_array<_Tp>::operator|=(const _Expr& __v) const { - value_type* __t = __vp_; - for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) - *__t |= __v[__i]; -} - -template -template ::value, int> > -inline void slice_array<_Tp>::operator<<=(const _Expr& __v) const { - value_type* __t = __vp_; - for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) - *__t <<= __v[__i]; -} - -template -template ::value, int> > -inline void slice_array<_Tp>::operator>>=(const _Expr& __v) const { - value_type* __t = __vp_; - for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_) - *__t >>= __v[__i]; -} - -template -inline void slice_array<_Tp>::operator=(const value_type& __x) const { - value_type* __t = __vp_; - for (size_t __n = __size_; __n; --__n, __t += __stride_) - *__t = __x; -} - -// gslice - -class _LIBCPP_EXPORTED_FROM_ABI gslice { - valarray __size_; - valarray __stride_; - valarray __1d_; - -public: - _LIBCPP_HIDE_FROM_ABI gslice() {} - - _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, const valarray& __size, const valarray& __stride) - : __size_(__size), __stride_(__stride) { - __init(__start); - } - -# ifndef _LIBCPP_CXX03_LANG - - _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, const valarray& __size, valarray&& __stride) - : __size_(__size), __stride_(std::move(__stride)) { - __init(__start); - } - - _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, valarray&& __size, const valarray& __stride) - : __size_(std::move(__size)), __stride_(__stride) { - __init(__start); - } - - _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, valarray&& __size, valarray&& __stride) - : __size_(std::move(__size)), __stride_(std::move(__stride)) { - __init(__start); - } - -# endif // _LIBCPP_CXX03_LANG - - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t start() const { return __1d_.size() ? __1d_[0] : 0; } - - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI valarray size() const { return __size_; } - - [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI valarray stride() const { return __stride_; } - -private: - void __init(size_t __start); - - template - friend class gslice_array; - template - friend class valarray; - template - friend class __val_expr; -}; - -// gslice_array - -template -class gslice_array { -public: - typedef _Tp value_type; - -private: - value_type* __vp_; - valarray __1d_; - -public: - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const; - - _LIBCPP_HIDE_FROM_ABI const gslice_array& operator=(const gslice_array& __ga) const; - - _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const; - - gslice_array(const gslice_array&) = default; - - // Behaves like __val_expr::operator[], which returns by value. - _LIBCPP_HIDE_FROM_ABI value_type __get(size_t __i) const { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __1d_.size(), "gslice_array.__get() index out of bounds"); - return __vp_[__1d_[__i]]; - } - -private: - gslice_array(const gslice& __gs, const valarray& __v) - : __vp_(const_cast(__v.__begin_)), __1d_(__gs.__1d_) {} - -# ifndef _LIBCPP_CXX03_LANG - gslice_array(gslice&& __gs, const valarray& __v) - : __vp_(const_cast(__v.__begin_)), __1d_(std::move(__gs.__1d_)) {} -# endif // _LIBCPP_CXX03_LANG - - template - friend class valarray; -}; - -template -template ::value, int> > -inline void gslice_array<_Tp>::operator=(const _Expr& __v) const { - typedef const size_t* _Ip; - size_t __j = 0; - for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) - __vp_[*__i] = __v[__j]; -} - -template -template ::value, int> > -inline void gslice_array<_Tp>::operator*=(const _Expr& __v) const { - typedef const size_t* _Ip; - size_t __j = 0; - for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) - __vp_[*__i] *= __v[__j]; -} - -template -template ::value, int> > -inline void gslice_array<_Tp>::operator/=(const _Expr& __v) const { - typedef const size_t* _Ip; - size_t __j = 0; - for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) - __vp_[*__i] /= __v[__j]; -} - -template -template ::value, int> > -inline void gslice_array<_Tp>::operator%=(const _Expr& __v) const { - typedef const size_t* _Ip; - size_t __j = 0; - for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) - __vp_[*__i] %= __v[__j]; -} - -template -template ::value, int> > -inline void gslice_array<_Tp>::operator+=(const _Expr& __v) const { - typedef const size_t* _Ip; - size_t __j = 0; - for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) - __vp_[*__i] += __v[__j]; -} - -template -template ::value, int> > -inline void gslice_array<_Tp>::operator-=(const _Expr& __v) const { - typedef const size_t* _Ip; - size_t __j = 0; - for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) - __vp_[*__i] -= __v[__j]; -} - -template -template ::value, int> > -inline void gslice_array<_Tp>::operator^=(const _Expr& __v) const { - typedef const size_t* _Ip; - size_t __j = 0; - for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) - __vp_[*__i] ^= __v[__j]; -} - -template -template ::value, int> > -inline void gslice_array<_Tp>::operator&=(const _Expr& __v) const { - typedef const size_t* _Ip; - size_t __j = 0; - for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) - __vp_[*__i] &= __v[__j]; -} - -template -template ::value, int> > -inline void gslice_array<_Tp>::operator|=(const _Expr& __v) const { - typedef const size_t* _Ip; - size_t __j = 0; - for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) - __vp_[*__i] |= __v[__j]; -} - -template -template ::value, int> > -inline void gslice_array<_Tp>::operator<<=(const _Expr& __v) const { - typedef const size_t* _Ip; - size_t __j = 0; - for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) - __vp_[*__i] <<= __v[__j]; -} - -template -template ::value, int> > -inline void gslice_array<_Tp>::operator>>=(const _Expr& __v) const { - typedef const size_t* _Ip; - size_t __j = 0; - for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j) - __vp_[*__i] >>= __v[__j]; -} - -template -inline const gslice_array<_Tp>& gslice_array<_Tp>::operator=(const gslice_array& __ga) const { - typedef const size_t* _Ip; - const value_type* __s = __ga.__vp_; - for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ga.__1d_.__begin_; __i != __e; ++__i, ++__j) - __vp_[*__i] = __s[*__j]; - return *this; -} - -template -inline void gslice_array<_Tp>::operator=(const value_type& __x) const { - typedef const size_t* _Ip; - for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i) - __vp_[*__i] = __x; -} - -// mask_array - -template -class mask_array { -public: - typedef _Tp value_type; - -private: - value_type* __vp_; - valarray __1d_; - -public: - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const; - - mask_array(const mask_array&) = default; - - _LIBCPP_HIDE_FROM_ABI const mask_array& operator=(const mask_array& __ma) const; - - _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const; - - // Behaves like __val_expr::operator[], which returns by value. - _LIBCPP_HIDE_FROM_ABI value_type __get(size_t __i) const { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __1d_.size(), "mask_array.__get() index out of bounds"); - return __vp_[__1d_[__i]]; - } - -private: - _LIBCPP_HIDE_FROM_ABI mask_array(const valarray& __vb, const valarray& __v) - : __vp_(const_cast(__v.__begin_)), - __1d_(static_cast(count(__vb.__begin_, __vb.__end_, true))) { - size_t __j = 0; - for (size_t __i = 0; __i < __vb.size(); ++__i) - if (__vb[__i]) - __1d_[__j++] = __i; - } - - template - friend class valarray; -}; - -template -template ::value, int> > -inline void mask_array<_Tp>::operator=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] = __v[__i]; -} - -template -template ::value, int> > -inline void mask_array<_Tp>::operator*=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] *= __v[__i]; -} - -template -template ::value, int> > -inline void mask_array<_Tp>::operator/=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] /= __v[__i]; -} - -template -template ::value, int> > -inline void mask_array<_Tp>::operator%=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] %= __v[__i]; -} - -template -template ::value, int> > -inline void mask_array<_Tp>::operator+=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] += __v[__i]; -} - -template -template ::value, int> > -inline void mask_array<_Tp>::operator-=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] -= __v[__i]; -} - -template -template ::value, int> > -inline void mask_array<_Tp>::operator^=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] ^= __v[__i]; -} - -template -template ::value, int> > -inline void mask_array<_Tp>::operator&=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] &= __v[__i]; -} - -template -template ::value, int> > -inline void mask_array<_Tp>::operator|=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] |= __v[__i]; -} - -template -template ::value, int> > -inline void mask_array<_Tp>::operator<<=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] <<= __v[__i]; -} - -template -template ::value, int> > -inline void mask_array<_Tp>::operator>>=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] >>= __v[__i]; -} - -template -inline const mask_array<_Tp>& mask_array<_Tp>::operator=(const mask_array& __ma) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] = __ma.__vp_[__1d_[__i]]; - return *this; -} - -template -inline void mask_array<_Tp>::operator=(const value_type& __x) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] = __x; -} - -template -class __mask_expr { - typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; - -public: - typedef typename _RmExpr::value_type value_type; - typedef value_type __result_type; - -private: - _ValExpr __expr_; - valarray __1d_; - - _LIBCPP_HIDE_FROM_ABI __mask_expr(const valarray& __vb, const _RmExpr& __e) - : __expr_(__e), __1d_(static_cast(count(__vb.__begin_, __vb.__end_, true))) { - size_t __j = 0; - for (size_t __i = 0; __i < __vb.size(); ++__i) - if (__vb[__i]) - __1d_[__j++] = __i; - } - -public: - _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__1d_[__i]]; } - - _LIBCPP_HIDE_FROM_ABI size_t size() const { return __1d_.size(); } - - template - friend class __val_expr; - template - friend class valarray; -}; - -// indirect_array - -template -class indirect_array { -public: - typedef _Tp value_type; - -private: - value_type* __vp_; - valarray __1d_; - -public: - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const; - - template ::value, int> = 0> - void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const; - - indirect_array(const indirect_array&) = default; - - _LIBCPP_HIDE_FROM_ABI const indirect_array& operator=(const indirect_array& __ia) const; - - _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const; - - // Behaves like __val_expr::operator[], which returns by value. - _LIBCPP_HIDE_FROM_ABI value_type __get(size_t __i) const { - _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __1d_.size(), "indirect_array.__get() index out of bounds"); - return __vp_[__1d_[__i]]; - } - -private: - _LIBCPP_HIDE_FROM_ABI indirect_array(const valarray& __ia, const valarray& __v) - : __vp_(const_cast(__v.__begin_)), __1d_(__ia) {} - -# ifndef _LIBCPP_CXX03_LANG - - _LIBCPP_HIDE_FROM_ABI indirect_array(valarray&& __ia, const valarray& __v) - : __vp_(const_cast(__v.__begin_)), __1d_(std::move(__ia)) {} - -# endif // _LIBCPP_CXX03_LANG - - template - friend class valarray; -}; - -template -template ::value, int> > -inline void indirect_array<_Tp>::operator=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] = __v[__i]; -} - -template -template ::value, int> > -inline void indirect_array<_Tp>::operator*=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] *= __v[__i]; -} - -template -template ::value, int> > -inline void indirect_array<_Tp>::operator/=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] /= __v[__i]; -} - -template -template ::value, int> > -inline void indirect_array<_Tp>::operator%=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] %= __v[__i]; -} - -template -template ::value, int> > -inline void indirect_array<_Tp>::operator+=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] += __v[__i]; -} - -template -template ::value, int> > -inline void indirect_array<_Tp>::operator-=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] -= __v[__i]; -} - -template -template ::value, int> > -inline void indirect_array<_Tp>::operator^=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] ^= __v[__i]; -} - -template -template ::value, int> > -inline void indirect_array<_Tp>::operator&=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] &= __v[__i]; -} - -template -template ::value, int> > -inline void indirect_array<_Tp>::operator|=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] |= __v[__i]; -} - -template -template ::value, int> > -inline void indirect_array<_Tp>::operator<<=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] <<= __v[__i]; -} - -template -template ::value, int> > -inline void indirect_array<_Tp>::operator>>=(const _Expr& __v) const { - size_t __n = __1d_.size(); - for (size_t __i = 0; __i < __n; ++__i) - __vp_[__1d_[__i]] >>= __v[__i]; -} - -template -inline const indirect_array<_Tp>& indirect_array<_Tp>::operator=(const indirect_array& __ia) const { - typedef const size_t* _Ip; - const value_type* __s = __ia.__vp_; - for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ia.__1d_.__begin_; __i != __e; ++__i, ++__j) - __vp_[*__i] = __s[*__j]; - return *this; -} - -template -inline void indirect_array<_Tp>::operator=(const value_type& __x) const { - typedef const size_t* _Ip; - for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i) - __vp_[*__i] = __x; -} - -template -class __indirect_expr { - typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; - -public: - typedef typename _RmExpr::value_type value_type; - typedef value_type __result_type; - -private: - _ValExpr __expr_; - valarray __1d_; - - _LIBCPP_HIDE_FROM_ABI __indirect_expr(const valarray& __ia, const _RmExpr& __e) : __expr_(__e), __1d_(__ia) {} - -# ifndef _LIBCPP_CXX03_LANG - - _LIBCPP_HIDE_FROM_ABI __indirect_expr(valarray&& __ia, const _RmExpr& __e) - : __expr_(__e), __1d_(std::move(__ia)) {} - -# endif // _LIBCPP_CXX03_LANG - -public: - _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__1d_[__i]]; } - - _LIBCPP_HIDE_FROM_ABI size_t size() const { return __1d_.size(); } - - template - friend class __val_expr; - template - friend class valarray; -}; - -template -class __val_expr { - typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr; - - _ValExpr __expr_; - -public: - typedef typename _RmExpr::value_type value_type; - typedef typename _RmExpr::__result_type __result_type; - - _LIBCPP_HIDE_FROM_ABI explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {} - - _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__i]; } - - _LIBCPP_HIDE_FROM_ABI __val_expr<__slice_expr<_ValExpr> > operator[](slice __s) const { - typedef __slice_expr<_ValExpr> _NewExpr; - return __val_expr< _NewExpr >(_NewExpr(__s, __expr_)); - } - - _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<_ValExpr> > operator[](const gslice& __gs) const { - typedef __indirect_expr<_ValExpr> _NewExpr; - return __val_expr<_NewExpr >(_NewExpr(__gs.__1d_, __expr_)); - } - - _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<_ValExpr> > operator[](const valarray& __vb) const { - typedef __mask_expr<_ValExpr> _NewExpr; - return __val_expr< _NewExpr >(_NewExpr(__vb, __expr_)); - } - - _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<_ValExpr> > operator[](const valarray& __vs) const { - typedef __indirect_expr<_ValExpr> _NewExpr; - return __val_expr< _NewExpr >(_NewExpr(__vs, __expr_)); - } - - _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__unary_plus, _ValExpr> > operator+() const { - typedef _UnaryOp<__unary_plus, _ValExpr> _NewExpr; - return __val_expr<_NewExpr>(_NewExpr(__unary_plus(), __expr_)); - } - - _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp, _ValExpr> > operator-() const { - typedef _UnaryOp, _ValExpr> _NewExpr; - return __val_expr<_NewExpr>(_NewExpr(negate(), __expr_)); - } - - _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__bit_not, _ValExpr> > operator~() const { - typedef _UnaryOp<__bit_not, _ValExpr> _NewExpr; - return __val_expr<_NewExpr>(_NewExpr(__bit_not(), __expr_)); - } - - _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp, _ValExpr> > operator!() const { - typedef _UnaryOp, _ValExpr> _NewExpr; - return __val_expr<_NewExpr>(_NewExpr(logical_not(), __expr_)); - } - - operator valarray<__result_type>() const; - - _LIBCPP_HIDE_FROM_ABI size_t size() const { return __expr_.size(); } - - _LIBCPP_HIDE_FROM_ABI __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_HIDE_FROM_ABI __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_HIDE_FROM_ABI __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_HIDE_FROM_ABI __val_expr<__shift_expr<_ValExpr> > shift(int __i) const { - return __val_expr<__shift_expr<_ValExpr> >(__shift_expr<_ValExpr>(__i, __expr_)); - } - - _LIBCPP_HIDE_FROM_ABI __val_expr<__cshift_expr<_ValExpr> > cshift(int __i) const { - return __val_expr<__cshift_expr<_ValExpr> >(__cshift_expr<_ValExpr>(__i, __expr_)); - } - - _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__apply_expr, _ValExpr> > - apply(value_type __f(value_type)) const { - typedef __apply_expr _Op; - typedef _UnaryOp<_Op, _ValExpr> _NewExpr; - return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_)); - } - - _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__apply_expr, _ValExpr> > - apply(value_type __f(const value_type&)) const { - typedef __apply_expr _Op; - typedef _UnaryOp<_Op, _ValExpr> _NewExpr; - return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_)); - } -}; - -template -__val_expr<_ValExpr>::operator valarray<__val_expr::__result_type>() const { - valarray<__result_type> __r; - size_t __n = __expr_.size(); - if (__n) { - __r.__begin_ = __r.__end_ = allocator<__result_type>().allocate(__n); - for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i) - ::new ((void*)__r.__end_) __result_type(__expr_[__i]); - } - return __r; -} - -// valarray - -template -inline valarray<_Tp>::valarray(size_t __n) : __begin_(nullptr), __end_(nullptr) { - if (__n) { - __begin_ = __end_ = allocator().allocate(__n); - auto __guard = std::__make_exception_guard([&] { __clear(__n); }); - for (size_t __n_left = __n; __n_left; --__n_left, ++__end_) - ::new ((void*)__end_) value_type(); - __guard.__complete(); - } -} - -template -inline valarray<_Tp>::valarray(const value_type& __x, size_t __n) : __begin_(nullptr), __end_(nullptr) { - resize(__n, __x); -} - -template -valarray<_Tp>::valarray(const value_type* __p, size_t __n) : __begin_(nullptr), __end_(nullptr) { - if (__n) { - __begin_ = __end_ = allocator().allocate(__n); - auto __guard = std::__make_exception_guard([&] { __clear(__n); }); - for (size_t __n_left = __n; __n_left; ++__end_, ++__p, --__n_left) - ::new ((void*)__end_) value_type(*__p); - __guard.__complete(); - } -} - -template -valarray<_Tp>::valarray(const valarray& __v) : __begin_(nullptr), __end_(nullptr) { - if (__v.size()) { - __begin_ = __end_ = allocator().allocate(__v.size()); - auto __guard = std::__make_exception_guard([&] { __clear(__v.size()); }); - for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p) - ::new ((void*)__end_) value_type(*__p); - __guard.__complete(); - } -} - -# ifndef _LIBCPP_CXX03_LANG - -template -inline valarray<_Tp>::valarray(valarray&& __v) _NOEXCEPT : __begin_(__v.__begin_), __end_(__v.__end_) { - __v.__begin_ = __v.__end_ = nullptr; -} - -template -valarray<_Tp>::valarray(initializer_list __il) : __begin_(nullptr), __end_(nullptr) { - const size_t __n = __il.size(); - if (__n) { - __begin_ = __end_ = allocator().allocate(__n); - auto __guard = std::__make_exception_guard([&] { __clear(__n); }); - size_t __n_left = __n; - for (const value_type* __p = __il.begin(); __n_left; ++__end_, ++__p, --__n_left) - ::new ((void*)__end_) value_type(*__p); - __guard.__complete(); - } -} - -# endif // _LIBCPP_CXX03_LANG - -template -valarray<_Tp>::valarray(const slice_array& __sa) : __begin_(nullptr), __end_(nullptr) { - const size_t __n = __sa.__size_; - if (__n) { - __begin_ = __end_ = allocator().allocate(__n); - auto __guard = std::__make_exception_guard([&] { __clear(__n); }); - size_t __n_left = __n; - for (const value_type* __p = __sa.__vp_; __n_left; ++__end_, __p += __sa.__stride_, --__n_left) - ::new ((void*)__end_) value_type(*__p); - __guard.__complete(); - } -} - -template -valarray<_Tp>::valarray(const gslice_array& __ga) : __begin_(nullptr), __end_(nullptr) { - const size_t __n = __ga.__1d_.size(); - if (__n) { - __begin_ = __end_ = allocator().allocate(__n); - auto __guard = std::__make_exception_guard([&] { __clear(__n); }); - typedef const size_t* _Ip; - const value_type* __s = __ga.__vp_; - for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__end_) - ::new ((void*)__end_) value_type(__s[*__i]); - __guard.__complete(); - } -} - -template -valarray<_Tp>::valarray(const mask_array& __ma) : __begin_(nullptr), __end_(nullptr) { - const size_t __n = __ma.__1d_.size(); - if (__n) { - __begin_ = __end_ = allocator().allocate(__n); - auto __guard = std::__make_exception_guard([&] { __clear(__n); }); - typedef const size_t* _Ip; - const value_type* __s = __ma.__vp_; - for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__end_) - ::new ((void*)__end_) value_type(__s[*__i]); - __guard.__complete(); - } -} - -template -valarray<_Tp>::valarray(const indirect_array& __ia) : __begin_(nullptr), __end_(nullptr) { - const size_t __n = __ia.__1d_.size(); - if (__n) { - __begin_ = __end_ = allocator().allocate(__n); - auto __guard = std::__make_exception_guard([&] { __clear(__n); }); - typedef const size_t* _Ip; - const value_type* __s = __ia.__vp_; - for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__end_) - ::new ((void*)__end_) value_type(__s[*__i]); - __guard.__complete(); - } -} - -template -inline valarray<_Tp>::~valarray() { - __clear(size()); -} - -template -valarray<_Tp>& valarray<_Tp>::__assign_range(const value_type* __f, const value_type* __l) { - size_t __n = __l - __f; - if (size() != __n) { - __clear(size()); - __begin_ = allocator().allocate(__n); - __end_ = __begin_ + __n; - std::uninitialized_copy(__f, __l, __begin_); - } else { - std::copy(__f, __l, __begin_); - } - return *this; -} - -template -valarray<_Tp>& valarray<_Tp>::operator=(const valarray& __v) { - if (this != std::addressof(__v)) - return __assign_range(__v.__begin_, __v.__end_); - return *this; -} - -# ifndef _LIBCPP_CXX03_LANG - -template -inline valarray<_Tp>& valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT { - __clear(size()); - __begin_ = __v.__begin_; - __end_ = __v.__end_; - __v.__begin_ = nullptr; - __v.__end_ = nullptr; - return *this; -} - -template -inline valarray<_Tp>& valarray<_Tp>::operator=(initializer_list __il) { - return __assign_range(__il.begin(), __il.end()); -} - -# endif // _LIBCPP_CXX03_LANG - -template -inline valarray<_Tp>& valarray<_Tp>::operator=(const value_type& __x) { - std::fill(__begin_, __end_, __x); - return *this; -} - -template -inline valarray<_Tp>& valarray<_Tp>::operator=(const slice_array& __sa) { - value_type* __t = __begin_; - const value_type* __s = __sa.__vp_; - for (size_t __n = __sa.__size_; __n; --__n, __s += __sa.__stride_, ++__t) - *__t = *__s; - return *this; -} - -template -inline valarray<_Tp>& valarray<_Tp>::operator=(const gslice_array& __ga) { - typedef const size_t* _Ip; - value_type* __t = __begin_; - const value_type* __s = __ga.__vp_; - for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__t) - *__t = __s[*__i]; - return *this; -} - -template -inline valarray<_Tp>& valarray<_Tp>::operator=(const mask_array& __ma) { - typedef const size_t* _Ip; - value_type* __t = __begin_; - const value_type* __s = __ma.__vp_; - for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__t) - *__t = __s[*__i]; - return *this; -} - -template -inline valarray<_Tp>& valarray<_Tp>::operator=(const indirect_array& __ia) { - typedef const size_t* _Ip; - value_type* __t = __begin_; - const value_type* __s = __ia.__vp_; - for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__t) - *__t = __s[*__i]; - return *this; -} - -template -template -inline valarray<_Tp>& valarray<_Tp>::operator=(const __val_expr<_ValExpr>& __v) { - size_t __n = __v.size(); - if (size() != __n) - resize(__n); - value_type* __t = __begin_; - for (size_t __i = 0; __i != __n; ++__t, ++__i) - *__t = __result_type(__v[__i]); - return *this; -} - -template -inline __val_expr<__slice_expr&> > valarray<_Tp>::operator[](slice __s) const { - return __val_expr<__slice_expr >(__slice_expr(__s, *this)); -} - -template -inline slice_array<_Tp> valarray<_Tp>::operator[](slice __s) { - return slice_array(__s, *this); -} - -template -inline __val_expr<__indirect_expr&> > valarray<_Tp>::operator[](const gslice& __gs) const { - return __val_expr<__indirect_expr >(__indirect_expr(__gs.__1d_, *this)); -} - -template -inline gslice_array<_Tp> valarray<_Tp>::operator[](const gslice& __gs) { - return gslice_array(__gs, *this); -} - -# ifndef _LIBCPP_CXX03_LANG - -template -inline __val_expr<__indirect_expr&> > valarray<_Tp>::operator[](gslice&& __gs) const { - return __val_expr<__indirect_expr >(__indirect_expr(std::move(__gs.__1d_), *this)); -} - -template -inline gslice_array<_Tp> valarray<_Tp>::operator[](gslice&& __gs) { - return gslice_array(std::move(__gs), *this); -} - -# endif // _LIBCPP_CXX03_LANG - -template -inline __val_expr<__mask_expr&> > valarray<_Tp>::operator[](const valarray& __vb) const { - return __val_expr<__mask_expr >(__mask_expr(__vb, *this)); -} - -template -inline mask_array<_Tp> valarray<_Tp>::operator[](const valarray& __vb) { - return mask_array(__vb, *this); -} - -# ifndef _LIBCPP_CXX03_LANG - -template -inline __val_expr<__mask_expr&> > valarray<_Tp>::operator[](valarray&& __vb) const { - return __val_expr<__mask_expr >(__mask_expr(std::move(__vb), *this)); -} - -template -inline mask_array<_Tp> valarray<_Tp>::operator[](valarray&& __vb) { - return mask_array(std::move(__vb), *this); -} - -# endif // _LIBCPP_CXX03_LANG - -template -inline __val_expr<__indirect_expr&> > -valarray<_Tp>::operator[](const valarray& __vs) const { - return __val_expr<__indirect_expr >(__indirect_expr(__vs, *this)); -} - -template -inline indirect_array<_Tp> valarray<_Tp>::operator[](const valarray& __vs) { - return indirect_array(__vs, *this); -} - -# ifndef _LIBCPP_CXX03_LANG - -template -inline __val_expr<__indirect_expr&> > valarray<_Tp>::operator[](valarray&& __vs) const { - return __val_expr<__indirect_expr >(__indirect_expr(std::move(__vs), *this)); -} - -template -inline indirect_array<_Tp> valarray<_Tp>::operator[](valarray&& __vs) { - return indirect_array(std::move(__vs), *this); -} - -# endif // _LIBCPP_CXX03_LANG - -template -inline __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator+() const { - using _Op = _UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&>; - return __val_expr<_Op>(_Op(__unary_plus<_Tp>(), *this)); -} - -template -inline __val_expr<_UnaryOp, const valarray<_Tp>&> > valarray<_Tp>::operator-() const { - using _Op = _UnaryOp, const valarray<_Tp>&>; - return __val_expr<_Op>(_Op(negate<_Tp>(), *this)); -} - -template -inline __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator~() const { - using _Op = _UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&>; - return __val_expr<_Op>(_Op(__bit_not<_Tp>(), *this)); -} - -template -inline __val_expr<_UnaryOp, const valarray<_Tp>&> > valarray<_Tp>::operator!() const { - using _Op = _UnaryOp, const valarray<_Tp>&>; - return __val_expr<_Op>(_Op(logical_not<_Tp>(), *this)); -} - -template -inline valarray<_Tp>& valarray<_Tp>::operator*=(const value_type& __x) { - for (value_type* __p = __begin_; __p != __end_; ++__p) - *__p *= __x; - return *this; -} - -template -inline valarray<_Tp>& valarray<_Tp>::operator/=(const value_type& __x) { - for (value_type* __p = __begin_; __p != __end_; ++__p) - *__p /= __x; - return *this; -} - -template -inline valarray<_Tp>& valarray<_Tp>::operator%=(const value_type& __x) { - for (value_type* __p = __begin_; __p != __end_; ++__p) - *__p %= __x; - return *this; -} - -template -inline valarray<_Tp>& valarray<_Tp>::operator+=(const value_type& __x) { - for (value_type* __p = __begin_; __p != __end_; ++__p) - *__p += __x; - return *this; -} - -template -inline valarray<_Tp>& valarray<_Tp>::operator-=(const value_type& __x) { - for (value_type* __p = __begin_; __p != __end_; ++__p) - *__p -= __x; - return *this; -} - -template -inline valarray<_Tp>& valarray<_Tp>::operator^=(const value_type& __x) { - for (value_type* __p = __begin_; __p != __end_; ++__p) - *__p ^= __x; - return *this; -} - -template -inline valarray<_Tp>& valarray<_Tp>::operator&=(const value_type& __x) { - for (value_type* __p = __begin_; __p != __end_; ++__p) - *__p &= __x; - return *this; -} - -template -inline valarray<_Tp>& valarray<_Tp>::operator|=(const value_type& __x) { - for (value_type* __p = __begin_; __p != __end_; ++__p) - *__p |= __x; - return *this; -} - -template -inline valarray<_Tp>& valarray<_Tp>::operator<<=(const value_type& __x) { - for (value_type* __p = __begin_; __p != __end_; ++__p) - *__p <<= __x; - return *this; -} - -template -inline valarray<_Tp>& valarray<_Tp>::operator>>=(const value_type& __x) { - for (value_type* __p = __begin_; __p != __end_; ++__p) - *__p >>= __x; - return *this; -} - -template -template ::value, int> > -inline valarray<_Tp>& valarray<_Tp>::operator*=(const _Expr& __v) { - size_t __i = 0; - for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) - *__t *= std::__get(__v, __i); - return *this; -} - -template -template ::value, int> > -inline valarray<_Tp>& valarray<_Tp>::operator/=(const _Expr& __v) { - size_t __i = 0; - for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) - *__t /= std::__get(__v, __i); - return *this; -} - -template -template ::value, int> > -inline valarray<_Tp>& valarray<_Tp>::operator%=(const _Expr& __v) { - size_t __i = 0; - for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) - *__t %= std::__get(__v, __i); - return *this; -} - -template -template ::value, int> > -inline valarray<_Tp>& valarray<_Tp>::operator+=(const _Expr& __v) { - size_t __i = 0; - for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) - *__t += std::__get(__v, __i); - return *this; -} - -template -template ::value, int> > -inline valarray<_Tp>& valarray<_Tp>::operator-=(const _Expr& __v) { - size_t __i = 0; - for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) - *__t -= std::__get(__v, __i); - return *this; -} - -template -template ::value, int> > -inline valarray<_Tp>& valarray<_Tp>::operator^=(const _Expr& __v) { - size_t __i = 0; - for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) - *__t ^= std::__get(__v, __i); - return *this; -} - -template -template ::value, int> > -inline valarray<_Tp>& valarray<_Tp>::operator|=(const _Expr& __v) { - size_t __i = 0; - for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) - *__t |= std::__get(__v, __i); - return *this; -} - -template -template ::value, int> > -inline valarray<_Tp>& valarray<_Tp>::operator&=(const _Expr& __v) { - size_t __i = 0; - for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) - *__t &= std::__get(__v, __i); - return *this; -} - -template -template ::value, int> > -inline valarray<_Tp>& valarray<_Tp>::operator<<=(const _Expr& __v) { - size_t __i = 0; - for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) - *__t <<= std::__get(__v, __i); - return *this; -} - -template -template ::value, int> > -inline valarray<_Tp>& valarray<_Tp>::operator>>=(const _Expr& __v) { - size_t __i = 0; - for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i) - *__t >>= std::__get(__v, __i); - return *this; -} - -template -inline void valarray<_Tp>::swap(valarray& __v) _NOEXCEPT { - std::swap(__begin_, __v.__begin_); - std::swap(__end_, __v.__end_); -} - -template -inline _Tp valarray<_Tp>::sum() const { - if (__begin_ == __end_) - return value_type(); - const value_type* __p = __begin_; - _Tp __r = *__p; - for (++__p; __p != __end_; ++__p) - __r += *__p; - return __r; -} - -template -inline _Tp valarray<_Tp>::min() const { - if (__begin_ == __end_) - return value_type(); - return *std::min_element(__begin_, __end_); -} - -template -inline _Tp valarray<_Tp>::max() const { - if (__begin_ == __end_) - return value_type(); - return *std::max_element(__begin_, __end_); -} - -template -valarray<_Tp> valarray<_Tp>::shift(int __i) const { - valarray __r; - size_t __n = size(); - if (__n) { - __r.__begin_ = __r.__end_ = allocator().allocate(__n); - const value_type* __sb; - value_type* __tb; - value_type* __te; - if (__i >= 0) { - __i = std::min(__i, static_cast(__n)); - __sb = __begin_ + __i; - __tb = __r.__begin_; - __te = __r.__begin_ + (__n - __i); - } else { - __i = std::min(-__i, static_cast(__n)); - __sb = __begin_; - __tb = __r.__begin_ + __i; - __te = __r.__begin_ + __n; - } - for (; __r.__end_ != __tb; ++__r.__end_) - ::new ((void*)__r.__end_) value_type(); - for (; __r.__end_ != __te; ++__r.__end_, ++__sb) - ::new ((void*)__r.__end_) value_type(*__sb); - for (__te = __r.__begin_ + __n; __r.__end_ != __te; ++__r.__end_) - ::new ((void*)__r.__end_) value_type(); - } - return __r; -} - -template -valarray<_Tp> valarray<_Tp>::cshift(int __i) const { - valarray __r; - size_t __n = size(); - if (__n) { - __r.__begin_ = __r.__end_ = allocator().allocate(__n); - __i %= static_cast(__n); - const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i; - for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s) - ::new ((void*)__r.__end_) value_type(*__s); - for (const value_type* __s = __begin_; __s != __m; ++__r.__end_, ++__s) - ::new ((void*)__r.__end_) value_type(*__s); - } - return __r; -} - -template -valarray<_Tp> valarray<_Tp>::apply(value_type __f(value_type)) const { - valarray __r; - size_t __n = size(); - if (__n) { - __r.__begin_ = __r.__end_ = allocator().allocate(__n); - for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) - ::new ((void*)__r.__end_) value_type(__f(*__p)); - } - return __r; -} - -template -valarray<_Tp> valarray<_Tp>::apply(value_type __f(const value_type&)) const { - valarray __r; - size_t __n = size(); - if (__n) { - __r.__begin_ = __r.__end_ = allocator().allocate(__n); - for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n) - ::new ((void*)__r.__end_) value_type(__f(*__p)); - } - return __r; -} - -template -inline void valarray<_Tp>::__clear(size_t __capacity) { - if (__begin_ != nullptr) { - while (__end_ != __begin_) - (--__end_)->~value_type(); - allocator().deallocate(__begin_, __capacity); - __begin_ = __end_ = nullptr; - } -} - -template -void valarray<_Tp>::resize(size_t __n, value_type __x) { - __clear(size()); - if (__n) { - __begin_ = __end_ = allocator().allocate(__n); - auto __guard = std::__make_exception_guard([&] { __clear(__n); }); - for (size_t __n_left = __n; __n_left; --__n_left, ++__end_) - ::new ((void*)__end_) value_type(__x); - __guard.__complete(); - } -} - -template -inline _LIBCPP_HIDE_FROM_ABI void swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT { - __x.swap(__y); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp, _Expr1, _Expr2> > -operator*(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(multiplies(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, _Expr, __scalar_expr > > -operator*(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(multiplies(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, __scalar_expr, _Expr> > -operator*(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(multiplies(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp, _Expr1, _Expr2> > -operator/(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(divides(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, _Expr, __scalar_expr > > -operator/(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(divides(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, __scalar_expr, _Expr> > -operator/(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(divides(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp, _Expr1, _Expr2> > -operator%(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(modulus(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, _Expr, __scalar_expr > > -operator%(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(modulus(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, __scalar_expr, _Expr> > -operator%(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(modulus(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp, _Expr1, _Expr2> > -operator+(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(plus(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, _Expr, __scalar_expr > > -operator+(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(plus(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, __scalar_expr, _Expr> > -operator+(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(plus(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp, _Expr1, _Expr2> > -operator-(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(minus(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, _Expr, __scalar_expr > > -operator-(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(minus(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, __scalar_expr, _Expr> > -operator-(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(minus(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp, _Expr1, _Expr2> > -operator^(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(bit_xor(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, _Expr, __scalar_expr > > -operator^(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(bit_xor(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, __scalar_expr, _Expr> > -operator^(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(bit_xor(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp, _Expr1, _Expr2> > -operator&(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(bit_and(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, _Expr, __scalar_expr > > -operator&(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(bit_and(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, __scalar_expr, _Expr> > -operator&(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(bit_and(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp, _Expr1, _Expr2> > -operator|(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(bit_or(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, _Expr, __scalar_expr > > -operator|(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(bit_or(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, __scalar_expr, _Expr> > -operator|(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(bit_or(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__bit_shift_left, _Expr1, _Expr2> > -operator<<(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp<__bit_shift_left, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(__bit_shift_left(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr< _BinaryOp<__bit_shift_left, _Expr, __scalar_expr > > -operator<<(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp<__bit_shift_left, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(__bit_shift_left(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr< _BinaryOp<__bit_shift_left, __scalar_expr, _Expr> > -operator<<(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp<__bit_shift_left, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__bit_shift_left(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__bit_shift_right, _Expr1, _Expr2> > -operator>>(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp<__bit_shift_right, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(__bit_shift_right(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr< - _BinaryOp<__bit_shift_right, _Expr, __scalar_expr > > -operator>>(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp<__bit_shift_right, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(__bit_shift_right(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr< _BinaryOp<__bit_shift_right, __scalar_expr, _Expr> > -operator>>(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp<__bit_shift_right, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__bit_shift_right(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp, _Expr1, _Expr2> > -operator&&(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(logical_and(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, _Expr, __scalar_expr > > -operator&&(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(logical_and(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, __scalar_expr, _Expr> > -operator&&(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(logical_and(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp, _Expr1, _Expr2> > -operator||(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(logical_or(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, _Expr, __scalar_expr > > -operator||(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(logical_or(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, __scalar_expr, _Expr> > -operator||(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(logical_or(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp, _Expr1, _Expr2> > -operator==(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(equal_to(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, _Expr, __scalar_expr > > -operator==(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(equal_to(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, __scalar_expr, _Expr> > -operator==(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(equal_to(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp, _Expr1, _Expr2> > -operator!=(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(not_equal_to(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, _Expr, __scalar_expr > > -operator!=(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(not_equal_to(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, __scalar_expr, _Expr> > -operator!=(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(not_equal_to(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp, _Expr1, _Expr2> > -operator<(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(less(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, _Expr, __scalar_expr > > -operator<(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(less(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, __scalar_expr, _Expr> > -operator<(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(less(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp, _Expr1, _Expr2> > -operator>(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(greater(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, _Expr, __scalar_expr > > -operator>(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(greater(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, __scalar_expr, _Expr> > -operator>(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(greater(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp, _Expr1, _Expr2> > -operator<=(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(less_equal(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, _Expr, __scalar_expr > > -operator<=(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(less_equal(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, __scalar_expr, _Expr> > -operator<=(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(less_equal(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp, _Expr1, _Expr2> > -operator>=(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(greater_equal(), __x, __y)); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, _Expr, __scalar_expr > > -operator>=(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(greater_equal(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp, __scalar_expr, _Expr> > -operator>=(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(greater_equal(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__abs_expr, _Expr> > -abs(const _Expr& __x) { - typedef typename _Expr::value_type value_type; - typedef _UnaryOp<__abs_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__abs_expr(), __x)); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__acos_expr, _Expr> > -acos(const _Expr& __x) { - typedef typename _Expr::value_type value_type; - typedef _UnaryOp<__acos_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__acos_expr(), __x)); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__asin_expr, _Expr> > -asin(const _Expr& __x) { - typedef typename _Expr::value_type value_type; - typedef _UnaryOp<__asin_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__asin_expr(), __x)); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__atan_expr, _Expr> > -atan(const _Expr& __x) { - typedef typename _Expr::value_type value_type; - typedef _UnaryOp<__atan_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__atan_expr(), __x)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -[[__nodiscard__]] inline - _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__atan2_expr, _Expr1, _Expr2> > - atan2(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp<__atan2_expr, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(__atan2_expr(), __x, __y)); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp<__atan2_expr, _Expr, __scalar_expr > > -atan2(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp<__atan2_expr, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(__atan2_expr(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp<__atan2_expr, __scalar_expr, _Expr> > -atan2(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp<__atan2_expr, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__atan2_expr(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__cos_expr, _Expr> > -cos(const _Expr& __x) { - typedef typename _Expr::value_type value_type; - typedef _UnaryOp<__cos_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__cos_expr(), __x)); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__cosh_expr, _Expr> > -cosh(const _Expr& __x) { - typedef typename _Expr::value_type value_type; - typedef _UnaryOp<__cosh_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__cosh_expr(), __x)); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__exp_expr, _Expr> > -exp(const _Expr& __x) { - typedef typename _Expr::value_type value_type; - typedef _UnaryOp<__exp_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__exp_expr(), __x)); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__log_expr, _Expr> > -log(const _Expr& __x) { - typedef typename _Expr::value_type value_type; - typedef _UnaryOp<__log_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__log_expr(), __x)); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__log10_expr, _Expr> > -log10(const _Expr& __x) { - typedef typename _Expr::value_type value_type; - typedef _UnaryOp<__log10_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__log10_expr(), __x)); -} - -template ::value && __is_val_expr<_Expr2>::value, int> = 0> -[[__nodiscard__]] inline - _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__pow_expr, _Expr1, _Expr2> > - pow(const _Expr1& __x, const _Expr2& __y) { - typedef typename _Expr1::value_type value_type; - typedef _BinaryOp<__pow_expr, _Expr1, _Expr2> _Op; - return __val_expr<_Op>(_Op(__pow_expr(), __x, __y)); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp<__pow_expr, _Expr, __scalar_expr > > -pow(const _Expr& __x, const typename _Expr::value_type& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp<__pow_expr, _Expr, __scalar_expr > _Op; - return __val_expr<_Op>(_Op(__pow_expr(), __x, __scalar_expr(__y, __x.size()))); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI -__val_expr<_BinaryOp<__pow_expr, __scalar_expr, _Expr> > -pow(const typename _Expr::value_type& __x, const _Expr& __y) { - typedef typename _Expr::value_type value_type; - typedef _BinaryOp<__pow_expr, __scalar_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__pow_expr(), __scalar_expr(__x, __y.size()), __y)); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sin_expr, _Expr> > -sin(const _Expr& __x) { - typedef typename _Expr::value_type value_type; - typedef _UnaryOp<__sin_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__sin_expr(), __x)); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sinh_expr, _Expr> > -sinh(const _Expr& __x) { - typedef typename _Expr::value_type value_type; - typedef _UnaryOp<__sinh_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__sinh_expr(), __x)); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sqrt_expr, _Expr> > -sqrt(const _Expr& __x) { - typedef typename _Expr::value_type value_type; - typedef _UnaryOp<__sqrt_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__sqrt_expr(), __x)); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__tan_expr, _Expr> > -tan(const _Expr& __x) { - typedef typename _Expr::value_type value_type; - typedef _UnaryOp<__tan_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__tan_expr(), __x)); -} - -template ::value, int> = 0> -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__tanh_expr, _Expr> > -tanh(const _Expr& __x) { - typedef typename _Expr::value_type value_type; - typedef _UnaryOp<__tanh_expr, _Expr> _Op; - return __val_expr<_Op>(_Op(__tanh_expr(), __x)); -} - -template -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _Tp* begin(valarray<_Tp>& __v) { - return __v.__begin_; -} - -template -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI const _Tp* begin(const valarray<_Tp>& __v) { - return __v.__begin_; -} - -template -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _Tp* end(valarray<_Tp>& __v) { - return __v.__end_; -} - -template -[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI const _Tp* end(const valarray<_Tp>& __v) { - return __v.__end_; -} - -_LIBCPP_END_NAMESPACE_STD - -_LIBCPP_POP_MACROS - -# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 -# include -# include -# include -# include -# include -# include -# include -# endif -#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS) - -#endif // _LIBCPP_VALARRAY -- cgit v1.2.3