1 // -*- C++ -*-
2
3 // Copyright (C) 2007-2023 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 terms
7 // of the GNU General Public License as published by the Free Software
8 // Foundation; either version 3, or (at your option) any later
9 // version.
10
11 // This library is distributed in the hope that it will be useful, but
12 // WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // 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 parallel/for_each_selectors.h
26 * @brief Functors representing different tasks to be plugged into the
27 * generic parallelization methods for embarrassingly parallel functions.
28 * This file is a GNU parallel extension to the Standard C++ Library.
29 */
30
31 // Written by Felix Putze.
32
33 #ifndef _GLIBCXX_PARALLEL_FOR_EACH_SELECTORS_H
34 #define _GLIBCXX_PARALLEL_FOR_EACH_SELECTORS_H 1
35
36 #include <parallel/basic_iterator.h>
37
38 namespace __gnu_parallel
39 {
40 /** @brief Generic __selector for embarrassingly parallel functions. */
41 template<typename _It>
42 struct __generic_for_each_selector
43 {
44 /** @brief _Iterator on last element processed; needed for some
45 * algorithms (e. g. std::transform()).
46 */
47 _It _M_finish_iterator;
48 };
49
50 /** @brief std::for_each() selector. */
51 template<typename _It>
52 struct __for_each_selector : public __generic_for_each_selector<_It>
53 {
54 /** @brief Functor execution.
55 * @param __o Operator.
56 * @param __i iterator referencing object. */
57 template<typename _Op>
58 bool
59 operator()(_Op& __o, _It __i)
60 {
61 __o(*__i);
62 return true;
63 }
64 };
65
66 /** @brief std::generate() selector. */
67 template<typename _It>
68 struct __generate_selector : public __generic_for_each_selector<_It>
69 {
70 /** @brief Functor execution.
71 * @param __o Operator.
72 * @param __i iterator referencing object. */
73 template<typename _Op>
74 bool
75 operator()(_Op& __o, _It __i)
76 {
77 *__i = __o();
78 return true;
79 }
80 };
81
82 /** @brief std::fill() selector. */
83 template<typename _It>
84 struct __fill_selector : public __generic_for_each_selector<_It>
85 {
86 /** @brief Functor execution.
87 * @param __v Current value.
88 * @param __i iterator referencing object. */
89 template<typename _ValueType>
90 bool
91 operator()(_ValueType& __v, _It __i)
92 {
93 *__i = __v;
94 return true;
95 }
96 };
97
98 /** @brief std::transform() __selector, one input sequence variant. */
99 template<typename _It>
100 struct __transform1_selector : public __generic_for_each_selector<_It>
101 {
102 /** @brief Functor execution.
103 * @param __o Operator.
104 * @param __i iterator referencing object. */
105 template<typename _Op>
106 bool
107 operator()(_Op& __o, _It __i)
108 {
109 *__i.second = __o(*__i.first);
110 return true;
111 }
112 };
113
114 /** @brief std::transform() __selector, two input sequences variant. */
115 template<typename _It>
116 struct __transform2_selector : public __generic_for_each_selector<_It>
117 {
118 /** @brief Functor execution.
119 * @param __o Operator.
120 * @param __i iterator referencing object. */
121 template<typename _Op>
122 bool
123 operator()(_Op& __o, _It __i)
124 {
125 *__i._M_third = __o(*__i._M_first, *__i._M_second);
126 return true;
127 }
128 };
129
130 /** @brief std::replace() selector. */
131 template<typename _It, typename _Tp>
132 struct __replace_selector : public __generic_for_each_selector<_It>
133 {
134 /** @brief Value to replace with. */
135 const _Tp& __new_val;
136
137 /** @brief Constructor
138 * @param __new_val Value to replace with. */
139 explicit
140 __replace_selector(const _Tp &__new_val) : __new_val(__new_val) {}
141
142 /** @brief Functor execution.
143 * @param __v Current value.
144 * @param __i iterator referencing object. */
145 bool
146 operator()(_Tp& __v, _It __i)
147 {
148 if (*__i == __v)
149 *__i = __new_val;
150 return true;
151 }
152 };
153
154 /** @brief std::replace() selector. */
155 template<typename _It, typename _Op, typename _Tp>
156 struct __replace_if_selector : public __generic_for_each_selector<_It>
157 {
158 /** @brief Value to replace with. */
159 const _Tp& __new_val;
160
161 /** @brief Constructor.
162 * @param __new_val Value to replace with. */
163 explicit
164 __replace_if_selector(const _Tp &__new_val) : __new_val(__new_val) { }
165
166 /** @brief Functor execution.
167 * @param __o Operator.
168 * @param __i iterator referencing object. */
169 bool
170 operator()(_Op& __o, _It __i)
171 {
172 if (__o(*__i))
173 *__i = __new_val;
174 return true;
175 }
176 };
177
178 /** @brief std::count() selector. */
179 template<typename _It, typename _Diff>
180 struct __count_selector : public __generic_for_each_selector<_It>
181 {
182 /** @brief Functor execution.
183 * @param __v Current value.
184 * @param __i iterator referencing object.
185 * @return 1 if count, 0 if does not count. */
186 template<typename _ValueType>
187 _Diff
188 operator()(_ValueType& __v, _It __i)
189 { return (__v == *__i) ? 1 : 0; }
190 };
191
192 /** @brief std::count_if () selector. */
193 template<typename _It, typename _Diff>
194 struct __count_if_selector : public __generic_for_each_selector<_It>
195 {
196 /** @brief Functor execution.
197 * @param __o Operator.
198 * @param __i iterator referencing object.
199 * @return 1 if count, 0 if does not count. */
200 template<typename _Op>
201 _Diff
202 operator()(_Op& __o, _It __i)
203 { return (__o(*__i)) ? 1 : 0; }
204 };
205
206 /** @brief std::accumulate() selector. */
207 template<typename _It>
208 struct __accumulate_selector : public __generic_for_each_selector<_It>
209 {
210 /** @brief Functor execution.
211 * @param __o Operator (unused).
212 * @param __i iterator referencing object.
213 * @return The current value. */
214 template<typename _Op>
215 typename std::iterator_traits<_It>::value_type
216 operator()(_Op __o, _It __i)
217 { return *__i; }
218 };
219
220 /** @brief std::inner_product() selector. */
221 template<typename _It, typename _It2, typename _Tp>
222 struct __inner_product_selector : public __generic_for_each_selector<_It>
223 {
224 /** @brief Begin iterator of first sequence. */
225 _It __begin1_iterator;
226
227 /** @brief Begin iterator of second sequence. */
228 _It2 __begin2_iterator;
229
230 /** @brief Constructor.
231 * @param __b1 Begin iterator of first sequence.
232 * @param __b2 Begin iterator of second sequence. */
233 explicit
234 __inner_product_selector(_It __b1, _It2 __b2)
235 : __begin1_iterator(__b1), __begin2_iterator(__b2) { }
236
237 /** @brief Functor execution.
238 * @param __mult Multiplication functor.
239 * @param __current iterator referencing object.
240 * @return Inner product elemental __result. */
241 template<typename _Op>
242 _Tp
243 operator()(_Op __mult, _It __current)
244 {
245 typename std::iterator_traits<_It>::difference_type __position
246 = __current - __begin1_iterator;
247 return __mult(*__current, *(__begin2_iterator + __position));
248 }
249 };
250
251 /** @brief Selector that just returns the passed iterator. */
252 template<typename _It>
253 struct __identity_selector : public __generic_for_each_selector<_It>
254 {
255 /** @brief Functor execution.
256 * @param __o Operator (unused).
257 * @param __i iterator referencing object.
258 * @return Passed iterator. */
259 template<typename _Op>
260 _It
261 operator()(_Op __o, _It __i)
262 { return __i; }
263 };
264
265 /** @brief Selector that returns the difference between two adjacent
266 * __elements.
267 */
268 template<typename _It>
269 struct __adjacent_difference_selector
270 : public __generic_for_each_selector<_It>
271 {
272 template<typename _Op>
273 bool
274 operator()(_Op& __o, _It __i)
275 {
276 typename _It::first_type __go_back_one = __i.first;
277 --__go_back_one;
278 *__i.second = __o(*__i.first, *__go_back_one);
279 return true;
280 }
281 };
282
283 /** @brief Functor doing nothing
284 *
285 * For some __reduction tasks (this is not a function object, but is
286 * passed as __selector __dummy parameter.
287 */
288 struct _Nothing
289 {
290 /** @brief Functor execution.
291 * @param __i iterator referencing object. */
292 template<typename _It>
293 void
294 operator()(_It __i) { }
295 };
296
297 /** @brief Reduction function doing nothing. */
298 struct _DummyReduct
299 {
300 bool
301 operator()(bool, bool) const
302 { return true; }
303 };
304
305 /** @brief Reduction for finding the maximum element, using a comparator. */
306 template<typename _Compare, typename _It>
307 struct __min_element_reduct
308 {
309 _Compare& __comp;
310
311 explicit
312 __min_element_reduct(_Compare &__c) : __comp(__c) { }
313
314 _It
315 operator()(_It __x, _It __y)
316 { return (__comp(*__x, *__y)) ? __x : __y; }
317 };
318
319 /** @brief Reduction for finding the maximum element, using a comparator. */
320 template<typename _Compare, typename _It>
321 struct __max_element_reduct
322 {
323 _Compare& __comp;
324
325 explicit
326 __max_element_reduct(_Compare& __c) : __comp(__c) { }
327
328 _It
329 operator()(_It __x, _It __y)
330 { return (__comp(*__x, *__y)) ? __y : __x; }
331 };
332
333 /** @brief General reduction, using a binary operator. */
334 template<typename _BinOp>
335 struct __accumulate_binop_reduct
336 {
337 _BinOp& __binop;
338
339 explicit
340 __accumulate_binop_reduct(_BinOp& __b) : __binop(__b) { }
341
342 template<typename _Result, typename _Addend>
343 _Result
344 operator()(const _Result& __x, const _Addend& __y)
345 { return __binop(__x, __y); }
346 };
347 }
348
349 #endif /* _GLIBCXX_PARALLEL_FOR_EACH_SELECTORS_H */