1 // The template and inlines for the -*- C++ -*- gslice_array class.
2 
3 // Copyright (C) 1997-2020 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library.  This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file bits/gslice_array.h
26  *  This is an internal header file, included by other library headers.
27  *  Do not attempt to use it directly. @headername{valarray}
28  */
29 
30 // Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
31 
32 #ifndef _GSLICE_ARRAY_H
33 #define _GSLICE_ARRAY_H 1
34 
35 #pragma GCC system_header
36 
_GLIBCXX_VISIBILITY(default)37 namespace std _GLIBCXX_VISIBILITY(default)
38 {
39 _GLIBCXX_BEGIN_NAMESPACE_VERSION
40 
41   /**
42    * @addtogroup numeric_arrays
43    * @{
44    */
45 
46   /**
47    *  @brief  Reference to multi-dimensional subset of an array.
48    *
49    *  A gslice_array is a reference to the actual elements of an array
50    *  specified by a gslice.  The way to get a gslice_array is to call
51    *  operator[](gslice) on a valarray.  The returned gslice_array then
52    *  permits carrying operations out on the referenced subset of elements in
53    *  the original valarray.  For example, operator+=(valarray) will add
54    *  values to the subset of elements in the underlying valarray this
55    *  gslice_array refers to.
56    *
57    *  @param  Tp  Element type.
58    */
59   template<typename _Tp>
60     class gslice_array
61     {
62     public:
63       typedef _Tp value_type;
64 
65       // _GLIBCXX_RESOLVE_LIB_DEFECTS
66       // 253. valarray helper functions are almost entirely useless
67 
68       ///  Copy constructor.  Both slices refer to the same underlying array.
69       gslice_array(const gslice_array&);
70 
71       ///  Assignment operator.  Assigns slice elements to corresponding
72       ///  elements of @a a.
73       gslice_array& operator=(const gslice_array&);
74 
75       ///  Assign slice elements to corresponding elements of @a v.
76       void operator=(const valarray<_Tp>&) const;
77       ///  Multiply slice elements by corresponding elements of @a v.
78       void operator*=(const valarray<_Tp>&) const;
79       ///  Divide slice elements by corresponding elements of @a v.
80       void operator/=(const valarray<_Tp>&) const;
81       ///  Modulo slice elements by corresponding elements of @a v.
82       void operator%=(const valarray<_Tp>&) const;
83       ///  Add corresponding elements of @a v to slice elements.
84       void operator+=(const valarray<_Tp>&) const;
85       ///  Subtract corresponding elements of @a v from slice elements.
86       void operator-=(const valarray<_Tp>&) const;
87       ///  Logical xor slice elements with corresponding elements of @a v.
88       void operator^=(const valarray<_Tp>&) const;
89       ///  Logical and slice elements with corresponding elements of @a v.
90       void operator&=(const valarray<_Tp>&) const;
91       ///  Logical or slice elements with corresponding elements of @a v.
92       void operator|=(const valarray<_Tp>&) const;
93       ///  Left shift slice elements by corresponding elements of @a v.
94       void operator<<=(const valarray<_Tp>&) const;
95       ///  Right shift slice elements by corresponding elements of @a v.
96       void operator>>=(const valarray<_Tp>&) const;
97       ///  Assign all slice elements to @a t.
98       void operator=(const _Tp&) const;
99 
100       template<class _Dom>
101         void operator=(const _Expr<_Dom, _Tp>&) const;
102       template<class _Dom>
103         void operator*=(const _Expr<_Dom, _Tp>&) const;
104       template<class _Dom>
105         void operator/=(const _Expr<_Dom, _Tp>&) const;
106       template<class _Dom>
107         void operator%=(const _Expr<_Dom, _Tp>&) const;
108       template<class _Dom>
109         void operator+=(const _Expr<_Dom, _Tp>&) const;
110       template<class _Dom>
111         void operator-=(const _Expr<_Dom, _Tp>&) const;
112       template<class _Dom>
113         void operator^=(const _Expr<_Dom, _Tp>&) const;
114       template<class _Dom>
115         void operator&=(const _Expr<_Dom, _Tp>&) const;
116       template<class _Dom>
117         void operator|=(const _Expr<_Dom, _Tp>&) const;
118       template<class _Dom>
119         void operator<<=(const _Expr<_Dom, _Tp>&) const;
120       template<class _Dom>
121         void operator>>=(const _Expr<_Dom, _Tp>&) const;
122 
123     private:
124       _Array<_Tp>    _M_array;
125       const valarray<size_t>& _M_index;
126 
127       friend class valarray<_Tp>;
128 
129       gslice_array(_Array<_Tp>, const valarray<size_t>&);
130 
131 #if __cplusplus < 201103L
132       // not implemented
133       gslice_array();
134 #else
135     public:
136       gslice_array() = delete;
137 #endif
138     };
139 
140   template<typename _Tp>
141     inline
142     gslice_array<_Tp>::gslice_array(_Array<_Tp> __a,
143 				    const valarray<size_t>& __i)
144     : _M_array(__a), _M_index(__i) {}
145 
146   template<typename _Tp>
147     inline
148     gslice_array<_Tp>::gslice_array(const gslice_array<_Tp>& __a)
149     : _M_array(__a._M_array), _M_index(__a._M_index) {}
150 
151   template<typename _Tp>
152     inline gslice_array<_Tp>&
153     gslice_array<_Tp>::operator=(const gslice_array<_Tp>& __a)
154     {
155       std::__valarray_copy(_Array<_Tp>(__a._M_array),
156 			   _Array<size_t>(__a._M_index), _M_index.size(),
157 			   _M_array, _Array<size_t>(_M_index));
158       return *this;
159     }
160 
161   template<typename _Tp>
162     inline void
163     gslice_array<_Tp>::operator=(const _Tp& __t) const
164     {
165       std::__valarray_fill(_M_array, _Array<size_t>(_M_index),
166 			   _M_index.size(), __t);
167     }
168 
169   template<typename _Tp>
170     inline void
171     gslice_array<_Tp>::operator=(const valarray<_Tp>& __v) const
172     {
173       std::__valarray_copy(_Array<_Tp>(__v), __v.size(),
174 			   _M_array, _Array<size_t>(_M_index));
175     }
176 
177   template<typename _Tp>
178     template<class _Dom>
179       inline void
180       gslice_array<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) const
181       {
182 	std::__valarray_copy (__e, _M_index.size(), _M_array,
183 			      _Array<size_t>(_M_index));
184       }
185 
186 #undef _DEFINE_VALARRAY_OPERATOR
187 #define _DEFINE_VALARRAY_OPERATOR(_Op, _Name)				\
188   template<typename _Tp>						\
189     inline void								\
190     gslice_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const	\
191     {									\
192       _Array_augmented_##_Name(_M_array, _Array<size_t>(_M_index),	\
193 			       _Array<_Tp>(__v), __v.size());		\
194     }									\
195 									\
196   template<typename _Tp>                                                \
197     template<class _Dom>				                \
198       inline void							\
199       gslice_array<_Tp>::operator _Op##= (const _Expr<_Dom, _Tp>& __e) const\
200       {									\
201 	_Array_augmented_##_Name(_M_array, _Array<size_t>(_M_index), __e,\
202 				 _M_index.size());			\
203       }
204 
205 _DEFINE_VALARRAY_OPERATOR(*, __multiplies)
206 _DEFINE_VALARRAY_OPERATOR(/, __divides)
207 _DEFINE_VALARRAY_OPERATOR(%, __modulus)
208 _DEFINE_VALARRAY_OPERATOR(+, __plus)
209 _DEFINE_VALARRAY_OPERATOR(-, __minus)
210 _DEFINE_VALARRAY_OPERATOR(^, __bitwise_xor)
211 _DEFINE_VALARRAY_OPERATOR(&, __bitwise_and)
212 _DEFINE_VALARRAY_OPERATOR(|, __bitwise_or)
213 _DEFINE_VALARRAY_OPERATOR(<<, __shift_left)
214 _DEFINE_VALARRAY_OPERATOR(>>, __shift_right)
215 
216 #undef _DEFINE_VALARRAY_OPERATOR
217 
218   /// @} group numeric_arrays
219 
220 _GLIBCXX_END_NAMESPACE_VERSION
221 } // namespace
222 
223 #endif /* _GSLICE_ARRAY_H */
224