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