libstdc++
valarray_array.h
Go to the documentation of this file.
1// The template and inlines for the -*- C++ -*- internal _Array helper class.
2
3// Copyright (C) 1997-2024 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/valarray_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 _VALARRAY_ARRAY_H
33#define _VALARRAY_ARRAY_H 1
34
35#pragma GCC system_header
36
37#include <bits/c++config.h>
38#include <bits/cpp_type_traits.h>
39#include <cstdlib>
40#include <new>
41
42namespace std _GLIBCXX_VISIBILITY(default)
43{
44_GLIBCXX_BEGIN_NAMESPACE_VERSION
45
46 //
47 // Helper functions on raw pointers
48 //
49
50 // We get memory the old fashioned way
51 template<typename _Tp>
52 _Tp*
53 __valarray_get_storage(size_t) __attribute__((__malloc__));
54
55 template<typename _Tp>
56 inline _Tp*
57 __valarray_get_storage(size_t __n)
58 { return static_cast<_Tp*>(operator new(__n * sizeof(_Tp))); }
59
60 // Return memory to the system
61 inline void
62 __valarray_release_memory(void* __p)
63 { operator delete(__p); }
64
65 // Turn raw-memory into an array of _Tp filled with _Tp().
66 // This is used in `valarray<T> v(n);` and in `valarray<T>::shift(n)`.
67 template<typename _Tp>
68 inline void
69 __valarray_default_construct(_Tp* __b, _Tp* __e)
70 {
71 if _GLIBCXX17_CONSTEXPR (__is_trivial(_Tp))
72 __builtin_memset(__b, 0, (__e - __b) * sizeof(_Tp));
73 else
74 while (__b != __e)
75 ::new(static_cast<void*>(__b++)) _Tp();
76 }
77
78 // Turn a raw-memory into an array of _Tp filled with __t
79 // This is the required in valarray<T> v(n, t). Also
80 // used in valarray<>::resize().
81 template<typename _Tp>
82 inline void
83 __valarray_fill_construct(_Tp* __b, _Tp* __e, const _Tp __t)
84 {
85 while (__b != __e)
86 ::new(static_cast<void*>(__b++)) _Tp(__t);
87 }
88
89 // copy-construct raw array [__o, *) from plain array [__b, __e)
90 template<typename _Tp>
91 inline void
92 __valarray_copy_construct(const _Tp* __b, const _Tp* __e,
93 _Tp* __restrict__ __o)
94 {
95 if _GLIBCXX17_CONSTEXPR (__is_trivial(_Tp))
96 {
97 if (__b)
98 __builtin_memcpy(__o, __b, (__e - __b) * sizeof(_Tp));
99 }
100 else
101 while (__b != __e)
102 ::new(static_cast<void*>(__o++)) _Tp(*__b++);
103 }
104
105 // copy-construct raw array [__o, *) from strided array __a[<__n : __s>]
106 template<typename _Tp>
107 inline void
108 __valarray_copy_construct (const _Tp* __restrict__ __a, size_t __n,
109 size_t __s, _Tp* __restrict__ __o)
110 {
111 if _GLIBCXX17_CONSTEXPR (__is_trivial(_Tp))
112 while (__n--)
113 {
114 *__o++ = *__a;
115 __a += __s;
116 }
117 else
118 while (__n--)
119 {
120 new(__o++) _Tp(*__a);
121 __a += __s;
122 }
123 }
124
125 // copy-construct raw array [__o, *) from indexed array __a[__i[<__n>]]
126 template<typename _Tp>
127 inline void
128 __valarray_copy_construct (const _Tp* __restrict__ __a,
129 const size_t* __restrict__ __i,
130 _Tp* __restrict__ __o, size_t __n)
131 {
132 if (__is_trivial(_Tp))
133 while (__n--)
134 *__o++ = __a[*__i++];
135 else
136 while (__n--)
137 new (__o++) _Tp(__a[*__i++]);
138 }
139
140 // Do the necessary cleanup when we're done with arrays.
141 template<typename _Tp>
142 inline void
143 __valarray_destroy_elements(_Tp* __b, _Tp* __e)
144 {
145 if (!__is_trivial(_Tp))
146 while (__b != __e)
147 {
148 __b->~_Tp();
149 ++__b;
150 }
151 }
152
153 // Fill a plain array __a[<__n>] with __t
154 template<typename _Tp>
155 inline void
156 __valarray_fill(_Tp* __restrict__ __a, size_t __n, const _Tp& __t)
157 {
158 while (__n--)
159 *__a++ = __t;
160 }
161
162 // fill strided array __a[<__n-1 : __s>] with __t
163 template<typename _Tp>
164 inline void
165 __valarray_fill(_Tp* __restrict__ __a, size_t __n,
166 size_t __s, const _Tp& __t)
167 {
168 for (size_t __i = 0; __i < __n; ++__i, __a += __s)
169 *__a = __t;
170 }
171
172 // fill indirect array __a[__i[<__n>]] with __i
173 template<typename _Tp>
174 inline void
175 __valarray_fill(_Tp* __restrict__ __a, const size_t* __restrict__ __i,
176 size_t __n, const _Tp& __t)
177 {
178 for (size_t __j = 0; __j < __n; ++__j, ++__i)
179 __a[*__i] = __t;
180 }
181
182 // copy plain array __a[<__n>] in __b[<__n>]
183 // For non-fundamental types, it is wrong to say 'memcpy()'
184 template<typename _Tp, bool>
185 struct _Array_copier
186 {
187 inline static void
188 _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b)
189 {
190 while(__n--)
191 *__b++ = *__a++;
192 }
193 };
194
195 template<typename _Tp>
196 struct _Array_copier<_Tp, true>
197 {
198 inline static void
199 _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b)
200 {
201 if (__n != 0)
202 __builtin_memcpy(__b, __a, __n * sizeof (_Tp));
203 }
204 };
205
206 // Copy a plain array __a[<__n>] into a play array __b[<>]
207 template<typename _Tp>
208 inline void
209 __valarray_copy(const _Tp* __restrict__ __a, size_t __n,
210 _Tp* __restrict__ __b)
211 {
212 _Array_copier<_Tp, __is_trivial(_Tp)>::_S_do_it(__a, __n, __b);
213 }
214
215 // Copy strided array __a[<__n : __s>] in plain __b[<__n>]
216 template<typename _Tp>
217 inline void
218 __valarray_copy(const _Tp* __restrict__ __a, size_t __n, size_t __s,
219 _Tp* __restrict__ __b)
220 {
221 for (size_t __i = 0; __i < __n; ++__i, ++__b, __a += __s)
222 *__b = *__a;
223 }
224
225 // Copy a plain array __a[<__n>] into a strided array __b[<__n : __s>]
226 template<typename _Tp>
227 inline void
228 __valarray_copy(const _Tp* __restrict__ __a, _Tp* __restrict__ __b,
229 size_t __n, size_t __s)
230 {
231 for (size_t __i = 0; __i < __n; ++__i, ++__a, __b += __s)
232 *__b = *__a;
233 }
234
235 // Copy strided array __src[<__n : __s1>] into another
236 // strided array __dst[< : __s2>]. Their sizes must match.
237 template<typename _Tp>
238 inline void
239 __valarray_copy(const _Tp* __restrict__ __src, size_t __n, size_t __s1,
240 _Tp* __restrict__ __dst, size_t __s2)
241 {
242 for (size_t __i = 0; __i < __n; ++__i)
243 __dst[__i * __s2] = __src[__i * __s1];
244 }
245
246 // Copy an indexed array __a[__i[<__n>]] in plain array __b[<__n>]
247 template<typename _Tp>
248 inline void
249 __valarray_copy(const _Tp* __restrict__ __a,
250 const size_t* __restrict__ __i,
251 _Tp* __restrict__ __b, size_t __n)
252 {
253 for (size_t __j = 0; __j < __n; ++__j, ++__b, ++__i)
254 *__b = __a[*__i];
255 }
256
257 // Copy a plain array __a[<__n>] in an indexed array __b[__i[<__n>]]
258 template<typename _Tp>
259 inline void
260 __valarray_copy(const _Tp* __restrict__ __a, size_t __n,
261 _Tp* __restrict__ __b, const size_t* __restrict__ __i)
262 {
263 for (size_t __j = 0; __j < __n; ++__j, ++__a, ++__i)
264 __b[*__i] = *__a;
265 }
266
267 // Copy the __n first elements of an indexed array __src[<__i>] into
268 // another indexed array __dst[<__j>].
269 template<typename _Tp>
270 inline void
271 __valarray_copy(const _Tp* __restrict__ __src, size_t __n,
272 const size_t* __restrict__ __i,
273 _Tp* __restrict__ __dst, const size_t* __restrict__ __j)
274 {
275 for (size_t __k = 0; __k < __n; ++__k)
276 __dst[*__j++] = __src[*__i++];
277 }
278
279 //
280 // Compute the sum of elements in range [__f, __l) which must not be empty.
281 // This is a naive algorithm. It suffers from cancelling.
282 // In the future try to specialize for _Tp = float, double, long double
283 // using a more accurate algorithm.
284 //
285 template<typename _Tp>
286 inline _Tp
287 __valarray_sum(const _Tp* __f, const _Tp* __l)
288 {
289 _Tp __r = *__f++;
290 while (__f != __l)
291 __r += *__f++;
292 return __r;
293 }
294
295 // Compute the min/max of an array-expression
296 template<typename _Ta>
297 inline typename _Ta::value_type
298 __valarray_min(const _Ta& __a)
299 {
300 size_t __s = __a.size();
301 typedef typename _Ta::value_type _Value_type;
302 _Value_type __r = __s == 0 ? _Value_type() : __a[0];
303 for (size_t __i = 1; __i < __s; ++__i)
304 {
305 _Value_type __t = __a[__i];
306 if (__t < __r)
307 __r = __t;
308 }
309 return __r;
310 }
311
312 template<typename _Ta>
313 inline typename _Ta::value_type
314 __valarray_max(const _Ta& __a)
315 {
316 size_t __s = __a.size();
317 typedef typename _Ta::value_type _Value_type;
318 _Value_type __r = __s == 0 ? _Value_type() : __a[0];
319 for (size_t __i = 1; __i < __s; ++__i)
320 {
321 _Value_type __t = __a[__i];
322 if (__t > __r)
323 __r = __t;
324 }
325 return __r;
326 }
327
328 //
329 // Helper class _Array, first layer of valarray abstraction.
330 // All operations on valarray should be forwarded to this class
331 // whenever possible. -- gdr
332 //
333
334 template<typename _Tp>
335 struct _Array
336 {
337 explicit _Array(_Tp* const __restrict__);
338 explicit _Array(const valarray<_Tp>&);
339 _Array(const _Tp* __restrict__, size_t);
340
341 _Tp* begin() const;
342
343 _Tp* const __restrict__ _M_data;
344 };
345
346
347 // Copy-construct plain array __b[<__n>] from indexed array __a[__i[<__n>]]
348 template<typename _Tp>
349 inline void
350 __valarray_copy_construct(_Array<_Tp> __a, _Array<size_t> __i,
351 _Array<_Tp> __b, size_t __n)
352 { std::__valarray_copy_construct(__a._M_data, __i._M_data,
353 __b._M_data, __n); }
354
355 // Copy-construct plain array __b[<__n>] from strided array __a[<__n : __s>]
356 template<typename _Tp>
357 inline void
358 __valarray_copy_construct(_Array<_Tp> __a, size_t __n, size_t __s,
359 _Array<_Tp> __b)
360 { std::__valarray_copy_construct(__a._M_data, __n, __s, __b._M_data); }
361
362 template<typename _Tp>
363 inline void
364 __valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t)
365 { std::__valarray_fill(__a._M_data, __n, __t); }
366
367 template<typename _Tp>
368 inline void
369 __valarray_fill(_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t)
370 { std::__valarray_fill(__a._M_data, __n, __s, __t); }
371
372 template<typename _Tp>
373 inline void
374 __valarray_fill(_Array<_Tp> __a, _Array<size_t> __i,
375 size_t __n, const _Tp& __t)
376 { std::__valarray_fill(__a._M_data, __i._M_data, __n, __t); }
377
378 // Copy a plain array __a[<__n>] into a play array __b[<>]
379 template<typename _Tp>
380 inline void
381 __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b)
382 { std::__valarray_copy(__a._M_data, __n, __b._M_data); }
383
384 // Copy strided array __a[<__n : __s>] in plain __b[<__n>]
385 template<typename _Tp>
386 inline void
387 __valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b)
388 { std::__valarray_copy(__a._M_data, __n, __s, __b._M_data); }
389
390 // Copy a plain array __a[<__n>] into a strided array __b[<__n : __s>]
391 template<typename _Tp>
392 inline void
393 __valarray_copy(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s)
394 { __valarray_copy(__a._M_data, __b._M_data, __n, __s); }
395
396 // Copy strided array __src[<__n : __s1>] into another
397 // strided array __dst[< : __s2>]. Their sizes must match.
398 template<typename _Tp>
399 inline void
400 __valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s1,
401 _Array<_Tp> __b, size_t __s2)
402 { std::__valarray_copy(__a._M_data, __n, __s1, __b._M_data, __s2); }
403
404 // Copy an indexed array __a[__i[<__n>]] in plain array __b[<__n>]
405 template<typename _Tp>
406 inline void
407 __valarray_copy(_Array<_Tp> __a, _Array<size_t> __i,
408 _Array<_Tp> __b, size_t __n)
409 { std::__valarray_copy(__a._M_data, __i._M_data, __b._M_data, __n); }
410
411 // Copy a plain array __a[<__n>] in an indexed array __b[__i[<__n>]]
412 template<typename _Tp>
413 inline void
414 __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
415 _Array<size_t> __i)
416 { std::__valarray_copy(__a._M_data, __n, __b._M_data, __i._M_data); }
417
418 // Copy the __n first elements of an indexed array __src[<__i>] into
419 // another indexed array __dst[<__j>].
420 template<typename _Tp>
421 inline void
422 __valarray_copy(_Array<_Tp> __src, size_t __n, _Array<size_t> __i,
423 _Array<_Tp> __dst, _Array<size_t> __j)
424 {
425 std::__valarray_copy(__src._M_data, __n, __i._M_data,
426 __dst._M_data, __j._M_data);
427 }
428
429 template<typename _Tp>
430 inline
431 _Array<_Tp>::_Array(_Tp* const __restrict__ __p)
432 : _M_data (__p) {}
433
434 template<typename _Tp>
435 inline
436 _Array<_Tp>::_Array(const valarray<_Tp>& __v)
437 : _M_data (__v._M_data) {}
438
439 template<typename _Tp>
440 inline
441 _Array<_Tp>::_Array(const _Tp* __restrict__ __b, size_t __s)
442 : _M_data(__valarray_get_storage<_Tp>(__s))
443 { std::__valarray_copy_construct(__b, __s, _M_data); }
444
445 template<typename _Tp>
446 inline _Tp*
447 _Array<_Tp>::begin () const
448 { return _M_data; }
449
450#define _DEFINE_ARRAY_FUNCTION(_Op, _Name) \
451 template<typename _Tp> \
452 inline void \
453 _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, const _Tp& __t) \
454 { \
455 for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) \
456 *__p _Op##= __t; \
457 } \
458 \
459 template<typename _Tp> \
460 inline void \
461 _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) \
462 { \
463 _Tp* __p = __a._M_data; \
464 for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) \
465 *__p _Op##= *__q; \
466 } \
467 \
468 template<typename _Tp, class _Dom> \
469 void \
470 _Array_augmented_##_Name(_Array<_Tp> __a, \
471 const _Expr<_Dom, _Tp>& __e, size_t __n) \
472 { \
473 _Tp* __p(__a._M_data); \
474 for (size_t __i = 0; __i < __n; ++__i, ++__p) \
475 *__p _Op##= __e[__i]; \
476 } \
477 \
478 template<typename _Tp> \
479 inline void \
480 _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, size_t __s, \
481 _Array<_Tp> __b) \
482 { \
483 _Tp* __q(__b._M_data); \
484 for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; \
485 __p += __s, ++__q) \
486 *__p _Op##= *__q; \
487 } \
488 \
489 template<typename _Tp> \
490 inline void \
491 _Array_augmented_##_Name(_Array<_Tp> __a, _Array<_Tp> __b, \
492 size_t __n, size_t __s) \
493 { \
494 _Tp* __q(__b._M_data); \
495 for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; \
496 ++__p, __q += __s) \
497 *__p _Op##= *__q; \
498 } \
499 \
500 template<typename _Tp, class _Dom> \
501 void \
502 _Array_augmented_##_Name(_Array<_Tp> __a, size_t __s, \
503 const _Expr<_Dom, _Tp>& __e, size_t __n) \
504 { \
505 _Tp* __p(__a._M_data); \
506 for (size_t __i = 0; __i < __n; ++__i, __p += __s) \
507 *__p _Op##= __e[__i]; \
508 } \
509 \
510 template<typename _Tp> \
511 inline void \
512 _Array_augmented_##_Name(_Array<_Tp> __a, _Array<size_t> __i, \
513 _Array<_Tp> __b, size_t __n) \
514 { \
515 _Tp* __q(__b._M_data); \
516 for (size_t* __j = __i._M_data; __j < __i._M_data + __n; \
517 ++__j, ++__q) \
518 __a._M_data[*__j] _Op##= *__q; \
519 } \
520 \
521 template<typename _Tp> \
522 inline void \
523 _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, \
524 _Array<_Tp> __b, _Array<size_t> __i) \
525 { \
526 _Tp* __p(__a._M_data); \
527 for (size_t* __j = __i._M_data; __j<__i._M_data + __n; \
528 ++__j, ++__p) \
529 *__p _Op##= __b._M_data[*__j]; \
530 } \
531 \
532 template<typename _Tp, class _Dom> \
533 void \
534 _Array_augmented_##_Name(_Array<_Tp> __a, _Array<size_t> __i, \
535 const _Expr<_Dom, _Tp>& __e, size_t __n) \
536 { \
537 size_t* __j(__i._M_data); \
538 for (size_t __k = 0; __k<__n; ++__k, ++__j) \
539 __a._M_data[*__j] _Op##= __e[__k]; \
540 } \
541 \
542 template<typename _Tp> \
543 void \
544 _Array_augmented_##_Name(_Array<_Tp> __a, _Array<bool> __m, \
545 _Array<_Tp> __b, size_t __n) \
546 { \
547 bool* __ok(__m._M_data); \
548 _Tp* __p(__a._M_data); \
549 for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; \
550 ++__q, ++__ok, ++__p) \
551 { \
552 while (! *__ok) \
553 { \
554 ++__ok; \
555 ++__p; \
556 } \
557 *__p _Op##= *__q; \
558 } \
559 } \
560 \
561 template<typename _Tp> \
562 void \
563 _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, \
564 _Array<_Tp> __b, _Array<bool> __m) \
565 { \
566 bool* __ok(__m._M_data); \
567 _Tp* __q(__b._M_data); \
568 for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; \
569 ++__p, ++__ok, ++__q) \
570 { \
571 while (! *__ok) \
572 { \
573 ++__ok; \
574 ++__q; \
575 } \
576 *__p _Op##= *__q; \
577 } \
578 } \
579 \
580 template<typename _Tp, class _Dom> \
581 void \
582 _Array_augmented_##_Name(_Array<_Tp> __a, _Array<bool> __m, \
583 const _Expr<_Dom, _Tp>& __e, size_t __n) \
584 { \
585 bool* __ok(__m._M_data); \
586 _Tp* __p(__a._M_data); \
587 for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) \
588 { \
589 while (! *__ok) \
590 { \
591 ++__ok; \
592 ++__p; \
593 } \
594 *__p _Op##= __e[__i]; \
595 } \
596 }
597
598 _DEFINE_ARRAY_FUNCTION(+, __plus)
599 _DEFINE_ARRAY_FUNCTION(-, __minus)
600 _DEFINE_ARRAY_FUNCTION(*, __multiplies)
601 _DEFINE_ARRAY_FUNCTION(/, __divides)
602 _DEFINE_ARRAY_FUNCTION(%, __modulus)
603 _DEFINE_ARRAY_FUNCTION(^, __bitwise_xor)
604 _DEFINE_ARRAY_FUNCTION(|, __bitwise_or)
605 _DEFINE_ARRAY_FUNCTION(&, __bitwise_and)
606 _DEFINE_ARRAY_FUNCTION(<<, __shift_left)
607 _DEFINE_ARRAY_FUNCTION(>>, __shift_right)
608
609#undef _DEFINE_ARRAY_FUNCTION
610
611_GLIBCXX_END_NAMESPACE_VERSION
612} // namespace
613
614# include <bits/valarray_array.tcc>
615
616#endif /* _ARRAY_H */
std::begin
_Tp * begin(valarray< _Tp > &__va) noexcept
Return an iterator pointing to the first element of the valarray.
Definition valarray:1227
std
ISO C++ entities toplevel namespace is std.