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 171 #if __cplusplus >= 201103L 177 valarray(
const _Expr<_Dom, _Tp>& __e);
191 #if __cplusplus >= 201103L 251 #if __cplusplus >= 201103L 264 operator= (
const _Expr<_Dom, _Tp>&);
273 _Tp& operator[](
size_t __i);
277 const _Tp& operator[](
size_t)
const;
290 _Expr<_SClos<_ValArray, _Tp>, _Tp> operator[](
slice __s)
const;
313 _Expr<_GClos<_ValArray, _Tp>, _Tp> operator[](
const gslice& __s)
const;
366 _Expr<_IClos<_ValArray, _Tp>, _Tp>
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;
479 #if __cplusplus >= 201103L 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>
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>
718 std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
719 std::__valarray_release_memory(_M_data);
722 template<
typename _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
_GLIBCXX14_CONSTEXPR _ForwardIterator min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
Return the minimum element in a range using comparison functor.
const _Tp * begin(const valarray< _Tp > &__va)
Return an iterator pointing to the first element of the const valarray.
Reference to arbitrary subset of an array.
size_t size() const
Return the number of elements in array.
_Tp & operator[](size_t __i)
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
ISO C++ entities toplevel namespace is std.
Reference to one-dimensional subset of an array.
valarray()
Construct an empty array.
_GLIBCXX14_CONSTEXPR _ForwardIterator max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
Return the maximum element in a range using comparison functor.
_GLIBCXX20_CONSTEXPR complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
Reference to selected subset of an array.
Smart array designed to support numeric processing.
_GLIBCXX14_CONSTEXPR const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
Reference to multi-dimensional subset of an array.
const _Tp * end(const valarray< _Tp > &__va)
Return an iterator pointing to one past the last element of the const valarray.
_GLIBCXX20_CONSTEXPR complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
Class defining one-dimensional subset of an array.
Class defining multi-dimensional subset of an array.
_GLIBCXX14_CONSTEXPR const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.