31 #ifndef _GLIBCXX_VALARRAY
32 #define _GLIBCXX_VALARRAY 1
34 #pragma GCC system_header
40 #if __cplusplus >= 201103L
44 namespace std _GLIBCXX_VISIBILITY(default)
46 _GLIBCXX_BEGIN_NAMESPACE_VERSION
48 template<
class _Clos,
typename _Tp>
51 template<
typename _Tp1,
typename _Tp2>
56 template<
class _Oper,
template<
class,
class>
class _Meta,
class _Dom>
60 template<
class,
class>
class _Meta1,
61 template<
class,
class>
class _Meta2,
62 class _Dom1,
class _Dom2>
65 template<
template<
class,
class>
class _Meta,
class _Dom>
68 template<
template<
class,
class>
class _Meta,
class _Dom>
71 template<
template<
class,
class>
class _Meta,
class _Dom>
74 template<
template<
class,
class>
class _Meta,
class _Dom>
77 template<
template<
class,
class>
class _Meta,
class _Dom>
81 using __detail::_UnClos;
82 using __detail::_BinClos;
83 using __detail::_SClos;
84 using __detail::_GClos;
85 using __detail::_IClos;
86 using __detail::_ValFunClos;
87 using __detail::_RefFunClos;
97 _GLIBCXX_END_NAMESPACE_VERSION
103 namespace std _GLIBCXX_VISIBILITY(default)
105 _GLIBCXX_BEGIN_NAMESPACE_VERSION
132 typedef typename __fun<_Op, _Tp>::result_type __rt;
133 typedef _Expr<_UnClos<_Op, _ValArray, _Tp>, __rt> _Rt;
136 typedef _Tp value_type;
149 valarray(
const _Tp* __restrict__,
size_t);
154 #if __cplusplus >= 201103L
169 valarray(
const indirect_array<_Tp>&);
171 #if __cplusplus >= 201103L
177 valarray(
const _Expr<_Dom, _Tp>& __e);
191 #if __cplusplus >= 201103L
199 valarray<_Tp>&
operator=(valarray<_Tp>&& __v) noexcept;
209 valarray<_Tp>&
operator=(
const _Tp& __t);
219 valarray<_Tp>&
operator=(
const slice_array<_Tp>& __sa);
229 valarray<_Tp>&
operator=(
const gslice_array<_Tp>& __ga);
239 valarray<_Tp>&
operator=(
const mask_array<_Tp>& __ma);
249 valarray<_Tp>&
operator=(
const indirect_array<_Tp>& __ia);
251 #if __cplusplus >= 201103L
263 template<
class _Dom> valarray<_Tp>&
290 _Expr<_SClos<_ValArray, _Tp>, _Tp>
operator[](slice __s)
const;
313 _Expr<_GClos<_ValArray, _Tp>, _Tp>
operator[](
const gslice& __s)
const;
325 gslice_array<_Tp>
operator[](
const gslice& __s);
339 valarray<_Tp>
operator[](
const valarray<bool>& __m)
const;
353 mask_array<_Tp>
operator[](
const valarray<bool>& __m);
366 _Expr<_IClos<_ValArray, _Tp>, _Tp>
367 operator[](
const valarray<size_t>& __i)
const;
381 indirect_array<_Tp>
operator[](
const valarray<size_t>& __i);
385 typename _UnaryOp<__unary_plus>::_Rt
operator+()
const;
388 typename _UnaryOp<__negate>::_Rt
operator-()
const;
391 typename _UnaryOp<__bitwise_not>::_Rt
operator~()
const;
394 typename _UnaryOp<__logical_not>::_Rt
operator!()
const;
428 valarray<_Tp>&
operator*=(
const valarray<_Tp>&);
431 valarray<_Tp>&
operator/=(
const valarray<_Tp>&);
434 valarray<_Tp>&
operator%=(
const valarray<_Tp>&);
437 valarray<_Tp>&
operator+=(
const valarray<_Tp>&);
440 valarray<_Tp>&
operator-=(
const valarray<_Tp>&);
443 valarray<_Tp>&
operator^=(
const valarray<_Tp>&);
446 valarray<_Tp>&
operator|=(
const valarray<_Tp>&);
449 valarray<_Tp>&
operator&=(
const valarray<_Tp>&);
452 valarray<_Tp>& operator<<=(const valarray<_Tp>&);
458 valarray<_Tp>&
operator*=(
const _Expr<_Dom, _Tp>&);
460 valarray<_Tp>&
operator/=(
const _Expr<_Dom, _Tp>&);
462 valarray<_Tp>&
operator%=(
const _Expr<_Dom, _Tp>&);
464 valarray<_Tp>&
operator+=(
const _Expr<_Dom, _Tp>&);
466 valarray<_Tp>&
operator-=(
const _Expr<_Dom, _Tp>&);
468 valarray<_Tp>&
operator^=(
const _Expr<_Dom, _Tp>&);
470 valarray<_Tp>&
operator|=(
const _Expr<_Dom, _Tp>&);
472 valarray<_Tp>&
operator&=(
const _Expr<_Dom, _Tp>&);
474 valarray<_Tp>& operator<<=(const _Expr<_Dom, _Tp>&);
476 valarray<_Tp>&
operator>>=(
const _Expr<_Dom, _Tp>&);
479 #if __cplusplus >= 201103L
481 void swap(valarray<_Tp>& __v) noexcept;
516 valarray<_Tp>
shift (
int __n)
const;
533 valarray<_Tp>
cshift(
int __n)
const;
545 _Expr<_ValFunClos<_ValArray, _Tp>, _Tp>
apply(_Tp func(_Tp))
const;
557 _Expr<_RefFunClos<_ValArray, _Tp>, _Tp>
apply(_Tp func(
const _Tp&))
const;
568 void resize(
size_t __size, _Tp __c = _Tp());
572 _Tp* __restrict__ _M_data;
574 friend class _Array<_Tp>;
577 #if __cpp_deduction_guides >= 201606
578 template<
typename _Tp,
size_t _Nm>
579 valarray(
const _Tp(&)[_Nm],
size_t) -> valarray<_Tp>;
582 template<
typename _Tp>
586 __glibcxx_requires_subscript(__i);
590 template<
typename _Tp>
594 __glibcxx_requires_subscript(__i);
600 _GLIBCXX_END_NAMESPACE_VERSION
610 namespace std _GLIBCXX_VISIBILITY(default)
612 _GLIBCXX_BEGIN_NAMESPACE_VERSION
619 template<
typename _Tp>
623 template<
typename _Tp>
626 : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
627 { std::__valarray_default_construct(_M_data, _M_data + __n); }
629 template<
typename _Tp>
632 : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
633 { std::__valarray_fill_construct(_M_data, _M_data + __n, __t); }
635 template<
typename _Tp>
638 : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
640 __glibcxx_assert(__p != 0 || __n == 0);
641 std::__valarray_copy_construct(__p, __p + __n, _M_data);
644 template<
typename _Tp>
647 : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size))
648 { std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size,
651 #if __cplusplus >= 201103L
652 template<
typename _Tp>
655 : _M_size(__v._M_size), _M_data(__v._M_data)
662 template<
typename _Tp>
665 : _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz))
667 std::__valarray_copy_construct
668 (__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data));
671 template<
typename _Tp>
674 : _M_size(__ga._M_index.size()),
675 _M_data(__valarray_get_storage<_Tp>(_M_size))
677 std::__valarray_copy_construct
678 (__ga._M_array, _Array<size_t>(__ga._M_index),
679 _Array<_Tp>(_M_data), _M_size);
682 template<
typename _Tp>
685 : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz))
687 std::__valarray_copy_construct
688 (__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size);
691 template<
typename _Tp>
694 : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz))
696 std::__valarray_copy_construct
697 (__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size);
700 #if __cplusplus >= 201103L
701 template<
typename _Tp>
704 : _M_size(__l.size()), _M_data(__valarray_get_storage<_Tp>(__l.size()))
705 { std::__valarray_copy_construct(__l.begin(), __l.end(), _M_data); }
708 template<
typename _Tp>
template<
class _Dom>
711 : _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size))
712 { std::__valarray_copy_construct(__e, _M_size, _Array<_Tp>(_M_data)); }
714 template<
typename _Tp>
716 valarray<_Tp>::~valarray() _GLIBCXX_NOEXCEPT
718 std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
719 std::__valarray_release_memory(_M_data);
722 template<
typename _Tp>
723 inline valarray<_Tp>&
728 if (_M_size == __v._M_size)
729 std::__valarray_copy(__v._M_data, _M_size, _M_data);
734 std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
735 std::__valarray_release_memory(_M_data);
737 _M_size = __v._M_size;
738 _M_data = __valarray_get_storage<_Tp>(_M_size);
739 std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size,
745 #if __cplusplus >= 201103L
746 template<
typename _Tp>
752 std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
753 std::__valarray_release_memory(_M_data);
755 _M_size = __v._M_size;
756 _M_data = __v._M_data;
762 template<
typename _Tp>
768 if (_M_size == __l.size())
769 std::__valarray_copy(__l.begin(), __l.size(), _M_data);
774 std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
775 std::__valarray_release_memory(_M_data);
777 _M_size = __l.size();
778 _M_data = __valarray_get_storage<_Tp>(_M_size);
779 std::__valarray_copy_construct(__l.begin(), __l.begin() + _M_size,
786 template<
typename _Tp>
790 std::__valarray_fill(_M_data, _M_size, __t);
794 template<
typename _Tp>
798 __glibcxx_assert(_M_size == __sa._M_sz);
799 std::__valarray_copy(__sa._M_array, __sa._M_sz,
800 __sa._M_stride, _Array<_Tp>(_M_data));
804 template<
typename _Tp>
808 __glibcxx_assert(_M_size == __ga._M_index.
size());
809 std::__valarray_copy(__ga._M_array, _Array<size_t>(__ga._M_index),
810 _Array<_Tp>(_M_data), _M_size);
814 template<
typename _Tp>
818 __glibcxx_assert(_M_size == __ma._M_sz);
819 std::__valarray_copy(__ma._M_array, __ma._M_mask,
820 _Array<_Tp>(_M_data), _M_size);
824 template<
typename _Tp>
828 __glibcxx_assert(_M_size == __ia._M_sz);
829 std::__valarray_copy(__ia._M_array, __ia._M_index,
830 _Array<_Tp>(_M_data), _M_size);
834 template<
typename _Tp>
template<
class _Dom>
840 if (_M_size == __e.size())
841 std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data));
846 std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
847 std::__valarray_release_memory(_M_data);
849 _M_size = __e.size();
850 _M_data = __valarray_get_storage<_Tp>(_M_size);
851 std::__valarray_copy_construct(__e, _M_size, _Array<_Tp>(_M_data));
856 template<
typename _Tp>
857 inline _Expr<_SClos<_ValArray,_Tp>, _Tp>
860 typedef _SClos<_ValArray,_Tp> _Closure;
861 return _Expr<_Closure, _Tp>(_Closure (_Array<_Tp>(_M_data), __s));
864 template<
typename _Tp>
869 template<
typename _Tp>
870 inline _Expr<_GClos<_ValArray,_Tp>, _Tp>
873 typedef _GClos<_ValArray,_Tp> _Closure;
874 return _Expr<_Closure, _Tp>
875 (_Closure(_Array<_Tp>(_M_data), __gs._M_index->_M_index));
878 template<
typename _Tp>
883 (_Array<_Tp>(_M_data), __gs._M_index->_M_index);
886 template<
typename _Tp>
891 size_t __e = __m.
size();
892 for (
size_t __i=0; __i<__e; ++__i)
895 _Array<bool> (__m)));
898 template<
typename _Tp>
903 size_t __e = __m.
size();
904 for (
size_t __i=0; __i<__e; ++__i)
909 template<
typename _Tp>
910 inline _Expr<_IClos<_ValArray,_Tp>, _Tp>
913 typedef _IClos<_ValArray,_Tp> _Closure;
914 return _Expr<_Closure, _Tp>(_Closure(*
this, __i));
917 template<
typename _Tp>
922 _Array<size_t>(__i));
925 #if __cplusplus >= 201103L
930 std::swap(_M_size, __v._M_size);
931 std::swap(_M_data, __v._M_data);
944 __glibcxx_assert(_M_size > 0);
945 return std::__valarray_sum(_M_data, _M_data + _M_size);
957 _Tp* __restrict__ __tmp_M_data =
958 std::__valarray_get_storage<_Tp>(_M_size);
961 std::__valarray_copy_construct(_M_data,
962 _M_data + _M_size, __tmp_M_data);
965 if (
size_t(__n) > _M_size)
968 std::__valarray_copy_construct(_M_data + __n,
969 _M_data + _M_size, __tmp_M_data);
970 std::__valarray_default_construct(__tmp_M_data + _M_size - __n,
971 __tmp_M_data + _M_size);
975 if (-
size_t(__n) > _M_size)
978 std::__valarray_copy_construct(_M_data, _M_data + _M_size + __n,
980 std::__valarray_default_construct(__tmp_M_data,
984 __ret._M_size = _M_size;
985 __ret._M_data = __tmp_M_data;
998 _Tp* __restrict__ __tmp_M_data =
999 std::__valarray_get_storage<_Tp>(_M_size);
1002 std::__valarray_copy_construct(_M_data,
1003 _M_data + _M_size, __tmp_M_data);
1006 if (
size_t(__n) > _M_size)
1007 __n = int(__n % _M_size);
1009 std::__valarray_copy_construct(_M_data, _M_data + __n,
1010 __tmp_M_data + _M_size - __n);
1011 std::__valarray_copy_construct(_M_data + __n, _M_data + _M_size,
1016 if (-
size_t(__n) > _M_size)
1017 __n = -int(-
size_t(__n) % _M_size);
1019 std::__valarray_copy_construct(_M_data + _M_size + __n,
1020 _M_data + _M_size, __tmp_M_data);
1021 std::__valarray_copy_construct(_M_data, _M_data + _M_size + __n,
1022 __tmp_M_data - __n);
1025 __ret._M_size = _M_size;
1026 __ret._M_data = __tmp_M_data;
1037 std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
1040 std::__valarray_release_memory(_M_data);
1042 _M_data = __valarray_get_storage<_Tp>(__n);
1044 std::__valarray_fill_construct(_M_data, _M_data + __n, __c);
1047 template<
typename _Tp>
1051 __glibcxx_assert(_M_size > 0);
1055 template<
typename _Tp>
1059 __glibcxx_assert(_M_size > 0);
1064 inline _Expr<_ValFunClos<_ValArray, _Tp>, _Tp>
1067 typedef _ValFunClos<_ValArray, _Tp> _Closure;
1068 return _Expr<_Closure, _Tp>(_Closure(*
this, func));
1072 inline _Expr<_RefFunClos<_ValArray, _Tp>, _Tp>
1075 typedef _RefFunClos<_ValArray, _Tp> _Closure;
1076 return _Expr<_Closure, _Tp>(_Closure(*
this, func));
1079 #define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op, _Name) \
1080 template<typename _Tp> \
1081 inline typename valarray<_Tp>::template _UnaryOp<_Name>::_Rt \
1082 valarray<_Tp>::operator _Op() const \
1084 typedef _UnClos<_Name, _ValArray, _Tp> _Closure; \
1085 typedef typename __fun<_Name, _Tp>::result_type _Rt; \
1086 return _Expr<_Closure, _Rt>(_Closure(*this)); \
1089 _DEFINE_VALARRAY_UNARY_OPERATOR(+, __unary_plus)
1090 _DEFINE_VALARRAY_UNARY_OPERATOR(-, __negate)
1091 _DEFINE_VALARRAY_UNARY_OPERATOR(~, __bitwise_not)
1092 _DEFINE_VALARRAY_UNARY_OPERATOR (!, __logical_not)
1094 #undef _DEFINE_VALARRAY_UNARY_OPERATOR
1096 #define _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(_Op, _Name) \
1097 template<class _Tp> \
1098 inline valarray<_Tp>& \
1099 valarray<_Tp>::operator _Op##=(const _Tp &__t) \
1101 _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, __t); \
1105 template<class _Tp> \
1106 inline valarray<_Tp>& \
1107 valarray<_Tp>::operator _Op##=(const valarray<_Tp> &__v) \
1109 __glibcxx_assert(_M_size == __v._M_size); \
1110 _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, \
1111 _Array<_Tp>(__v._M_data)); \
1115 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(+, __plus)
1116 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(-, __minus)
1117 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(*, __multiplies)
1118 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(/, __divides)
1119 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(%, __modulus)
1120 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(^, __bitwise_xor)
1121 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(&, __bitwise_and)
1122 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(|, __bitwise_or)
1123 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(<<, __shift_left)
1124 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(>>, __shift_right)
1126 #undef _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT
1128 #define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op, _Name) \
1129 template<class _Tp> template<class _Dom> \
1130 inline valarray<_Tp>& \
1131 valarray<_Tp>::operator _Op##=(const _Expr<_Dom, _Tp>& __e) \
1133 _Array_augmented_##_Name(_Array<_Tp>(_M_data), __e, _M_size); \
1137 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(+, __plus)
1138 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(-, __minus)
1139 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(*, __multiplies)
1140 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(/, __divides)
1141 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(%, __modulus)
1142 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(^, __bitwise_xor)
1143 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(&, __bitwise_and)
1144 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(|, __bitwise_or)
1145 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(<<, __shift_left)
1146 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right)
1148 #undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT
1151 #define _DEFINE_BINARY_OPERATOR(_Op, _Name) \
1152 template<typename _Tp> \
1153 inline _Expr<_BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp>, \
1154 typename __fun<_Name, _Tp>::result_type> \
1155 operator _Op(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \
1157 __glibcxx_assert(__v.size() == __w.size()); \
1158 typedef _BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp> _Closure; \
1159 typedef typename __fun<_Name, _Tp>::result_type _Rt; \
1160 return _Expr<_Closure, _Rt>(_Closure(__v, __w)); \
1163 template<typename _Tp> \
1164 inline _Expr<_BinClos<_Name, _ValArray,_Constant, _Tp, _Tp>, \
1165 typename __fun<_Name, _Tp>::result_type> \
1166 operator _Op(const valarray<_Tp>& __v, \
1167 const typename valarray<_Tp>::value_type& __t) \
1169 typedef _BinClos<_Name, _ValArray, _Constant, _Tp, _Tp> _Closure; \
1170 typedef typename __fun<_Name, _Tp>::result_type _Rt; \
1171 return _Expr<_Closure, _Rt>(_Closure(__v, __t)); \
1174 template<typename _Tp> \
1175 inline _Expr<_BinClos<_Name, _Constant, _ValArray, _Tp, _Tp>, \
1176 typename __fun<_Name, _Tp>::result_type> \
1177 operator _Op(const typename valarray<_Tp>::value_type& __t, \
1178 const valarray<_Tp>& __v) \
1180 typedef _BinClos<_Name, _Constant, _ValArray, _Tp, _Tp> _Closure; \
1181 typedef typename __fun<_Name, _Tp>::result_type _Rt; \
1182 return _Expr<_Closure, _Rt>(_Closure(__t, __v)); \
1185 _DEFINE_BINARY_OPERATOR(+, __plus)
1186 _DEFINE_BINARY_OPERATOR(-, __minus)
1187 _DEFINE_BINARY_OPERATOR(*, __multiplies)
1188 _DEFINE_BINARY_OPERATOR(/, __divides)
1189 _DEFINE_BINARY_OPERATOR(%, __modulus)
1190 _DEFINE_BINARY_OPERATOR(^, __bitwise_xor)
1191 _DEFINE_BINARY_OPERATOR(&, __bitwise_and)
1192 _DEFINE_BINARY_OPERATOR(|, __bitwise_or)
1193 _DEFINE_BINARY_OPERATOR(<<, __shift_left)
1194 _DEFINE_BINARY_OPERATOR(>>, __shift_right)
1195 _DEFINE_BINARY_OPERATOR(&&, __logical_and)
1196 _DEFINE_BINARY_OPERATOR(||, __logical_or)
1197 _DEFINE_BINARY_OPERATOR(==, __equal_to)
1198 _DEFINE_BINARY_OPERATOR(!=, __not_equal_to)
1199 _DEFINE_BINARY_OPERATOR(<, __less)
1200 _DEFINE_BINARY_OPERATOR(>, __greater)
1201 _DEFINE_BINARY_OPERATOR(<=, __less_equal)
1202 _DEFINE_BINARY_OPERATOR(>=, __greater_equal)
1204 #undef _DEFINE_BINARY_OPERATOR
1206 #if __cplusplus >= 201103L
1250 _GLIBCXX_END_NAMESPACE_VERSION
valarray< _Tp > & operator|=(const _Tp &)
Set each element e of array to e | t.
valarray< _Tp > & operator%=(const _Tp &)
Set each element e of array to e % t.
_Expr< _ValFunClos< _ValArray, _Tp >, _Tp > apply(_Tp func(_Tp)) const
Apply a function to the array.
_Tp * begin(valarray< _Tp > &__va)
Return an iterator pointing to the first element of the valarray.
valarray< _Tp > & operator*=(const _Tp &)
Multiply each element of array by t.
valarray< _Tp > shift(int __n) const
Return a shifted array.
Reference to selected subset of an array.
Class defining one-dimensional subset of an array.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
valarray< _Tp > & operator<<=(const _Tp &)
Left shift each element e of array by t bits.
void resize(size_t __size, _Tp __c=_Tp())
Resize array.
_Tp min() const
Return the minimum element using operator<().
Reference to arbitrary subset of an array.
_UnaryOp< __bitwise_not >::_Rt operator~() const
Return a new valarray by applying unary ~ to each element.
void swap(valarray< _Tp > &__v) noexcept
Swap.
Reference to multi-dimensional subset of an array.
valarray< _Tp > & operator=(const valarray< _Tp > &__v)
Assign elements to an array.
_Tp max() const
Return the maximum element using operator<().
valarray()
Construct an empty array.
constexpr _ForwardIterator max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
Return the maximum element in a range using comparison functor.
size_t size() const
Return the number of elements in array.
valarray< _Tp > & operator-=(const _Tp &)
Subtract t to each element of array.
constexpr _ForwardIterator min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
Return the minimum element in a range using comparison functor.
_Tp sum() const
Return the sum of all elements in the array.
valarray< _Tp > & operator+=(const _Tp &)
Add t to each element of array.
_UnaryOp< __unary_plus >::_Rt operator+() const
Return a new valarray by applying unary + to each element.
_Tp * end(valarray< _Tp > &__va)
Return an iterator pointing to one past the last element of the valarray.
valarray< _Tp > & operator/=(const _Tp &)
Divide each element of array by t.
Class defining multi-dimensional subset of an array.
Reference to one-dimensional subset of an array.
Smart array designed to support numeric processing.
_Tp & operator[](size_t __i)
valarray< _Tp > & operator^=(const _Tp &)
Set each element e of array to e ^ t.
_UnaryOp< __logical_not >::_Rt operator!() const
Return a new valarray by applying unary ! to each element.
valarray< _Tp > & operator&=(const _Tp &)
Set each element e of array to e & t.
valarray< _Tp > cshift(int __n) const
Return a rotated array.
valarray< _Tp > & operator>>=(const _Tp &)
Right shift each element e of array by t bits.
_UnaryOp< __negate >::_Rt operator-() const
Return a new valarray by applying unary - to each element.