]>
Commit | Line | Data |
---|---|---|
54c1bf78 | 1 | // The template and inlines for the -*- C++ -*- valarray class. |
de96ac46 | 2 | |
ffe94f83 PE |
3 | // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 |
4 | // Free Software Foundation, Inc. | |
de96ac46 BK |
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 2, 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 | // You should have received a copy of the GNU General Public License along | |
18 | // with this library; see the file COPYING. If not, write to the Free | |
19 | // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, | |
20 | // USA. | |
21 | ||
22 | // As a special exception, you may use this file as part of a free software | |
23 | // library without restriction. Specifically, if other files instantiate | |
24 | // templates or use macros or inline functions from this file, or you compile | |
25 | // this file and link it with other files to produce an executable, this | |
26 | // file does not by itself cause the resulting executable to be covered by | |
27 | // the GNU General Public License. This exception does not however | |
28 | // invalidate any other reasons why the executable file might be covered by | |
29 | // the GNU General Public License. | |
30 | ||
54c1bf78 BK |
31 | // Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr> |
32 | ||
ffe94f83 PE |
33 | /** @file valarray |
34 | * This is a Standard C++ Library header. You should @c #include this header | |
35 | * in your programs, rather than any of the "st[dl]_*.h" implementation files. | |
2f9d51b8 PE |
36 | */ |
37 | ||
1143680e SE |
38 | #ifndef _GLIBCXX_VALARRAY |
39 | #define _GLIBCXX_VALARRAY 1 | |
54c1bf78 BK |
40 | |
41 | #pragma GCC system_header | |
42 | ||
43 | #include <bits/c++config.h> | |
44 | #include <cstddef> | |
45 | #include <cmath> | |
46 | #include <cstdlib> | |
47 | #include <numeric> | |
54c1bf78 | 48 | #include <algorithm> |
285b36d6 | 49 | #include <debug/debug.h> |
54c1bf78 BK |
50 | |
51 | namespace std | |
52 | { | |
74d6b8ca GDR |
53 | template<class _Clos, typename _Tp> |
54 | class _Expr; | |
54c1bf78 | 55 | |
74d6b8ca GDR |
56 | template<typename _Tp1, typename _Tp2> |
57 | class _ValArray; | |
54c1bf78 | 58 | |
74d6b8ca GDR |
59 | template<class _Oper, template<class, class> class _Meta, class _Dom> |
60 | struct _UnClos; | |
54c1bf78 | 61 | |
971cfc6f | 62 | template<class _Oper, |
54c1bf78 BK |
63 | template<class, class> class _Meta1, |
64 | template<class, class> class _Meta2, | |
74d6b8ca GDR |
65 | class _Dom1, class _Dom2> |
66 | class _BinClos; | |
54c1bf78 | 67 | |
74d6b8ca GDR |
68 | template<template<class, class> class _Meta, class _Dom> |
69 | class _SClos; | |
54c1bf78 | 70 | |
74d6b8ca GDR |
71 | template<template<class, class> class _Meta, class _Dom> |
72 | class _GClos; | |
54c1bf78 | 73 | |
74d6b8ca GDR |
74 | template<template<class, class> class _Meta, class _Dom> |
75 | class _IClos; | |
54c1bf78 | 76 | |
74d6b8ca GDR |
77 | template<template<class, class> class _Meta, class _Dom> |
78 | class _ValFunClos; | |
54c1bf78 | 79 | |
74d6b8ca GDR |
80 | template<template<class, class> class _Meta, class _Dom> |
81 | class _RefFunClos; | |
82 | ||
74d6b8ca GDR |
83 | template<class _Tp> class valarray; // An array of type _Tp |
84 | class slice; // BLAS-like slice out of an array | |
85 | template<class _Tp> class slice_array; | |
86 | class gslice; // generalized slice out of an array | |
87 | template<class _Tp> class gslice_array; | |
88 | template<class _Tp> class mask_array; // masked array | |
89 | template<class _Tp> class indirect_array; // indirected array | |
54c1bf78 BK |
90 | |
91 | } // namespace std | |
92 | ||
93 | #include <bits/valarray_array.h> | |
c13bea50 | 94 | #include <bits/valarray_before.h> |
54c1bf78 BK |
95 | |
96 | namespace std | |
97 | { | |
74d6b8ca GDR |
98 | template<class _Tp> |
99 | class valarray | |
100 | { | |
101 | template<class _Op> | |
102 | struct _UnaryOp | |
103 | { | |
104 | typedef typename __fun<_Op, _Tp>::result_type __rt; | |
105 | typedef _Expr<_UnClos<_Op, _ValArray, _Tp>, __rt> _Rt; | |
106 | }; | |
107 | public: | |
54c1bf78 | 108 | typedef _Tp value_type; |
74d6b8ca GDR |
109 | |
110 | // _lib.valarray.cons_ construct/destroy: | |
54c1bf78 BK |
111 | valarray(); |
112 | explicit valarray(size_t); | |
113 | valarray(const _Tp&, size_t); | |
114 | valarray(const _Tp* __restrict__, size_t); | |
115 | valarray(const valarray&); | |
116 | valarray(const slice_array<_Tp>&); | |
117 | valarray(const gslice_array<_Tp>&); | |
118 | valarray(const mask_array<_Tp>&); | |
119 | valarray(const indirect_array<_Tp>&); | |
120 | template<class _Dom> | |
74d6b8ca GDR |
121 | valarray(const _Expr<_Dom,_Tp>& __e); |
122 | ~valarray(); | |
54c1bf78 BK |
123 | |
124 | // _lib.valarray.assign_ assignment: | |
125 | valarray<_Tp>& operator=(const valarray<_Tp>&); | |
126 | valarray<_Tp>& operator=(const _Tp&); | |
127 | valarray<_Tp>& operator=(const slice_array<_Tp>&); | |
128 | valarray<_Tp>& operator=(const gslice_array<_Tp>&); | |
129 | valarray<_Tp>& operator=(const mask_array<_Tp>&); | |
130 | valarray<_Tp>& operator=(const indirect_array<_Tp>&); | |
131 | ||
132 | template<class _Dom> valarray<_Tp>& | |
74d6b8ca | 133 | operator= (const _Expr<_Dom,_Tp>&); |
54c1bf78 BK |
134 | |
135 | // _lib.valarray.access_ element access: | |
136 | // XXX: LWG to be resolved. | |
137 | const _Tp& operator[](size_t) const; | |
138 | _Tp& operator[](size_t); | |
139 | // _lib.valarray.sub_ subset operations: | |
140 | _Expr<_SClos<_ValArray,_Tp>, _Tp> operator[](slice) const; | |
141 | slice_array<_Tp> operator[](slice); | |
142 | _Expr<_GClos<_ValArray,_Tp>, _Tp> operator[](const gslice&) const; | |
143 | gslice_array<_Tp> operator[](const gslice&); | |
144 | valarray<_Tp> operator[](const valarray<bool>&) const; | |
145 | mask_array<_Tp> operator[](const valarray<bool>&); | |
146 | _Expr<_IClos<_ValArray, _Tp>, _Tp> | |
74d6b8ca | 147 | operator[](const valarray<size_t>&) const; |
54c1bf78 BK |
148 | indirect_array<_Tp> operator[](const valarray<size_t>&); |
149 | ||
150 | // _lib.valarray.unary_ unary operators: | |
74d6b8ca GDR |
151 | typename _UnaryOp<__unary_plus>::_Rt operator+() const; |
152 | typename _UnaryOp<__negate>::_Rt operator-() const; | |
153 | typename _UnaryOp<__bitwise_not>::_Rt operator~() const; | |
154 | typename _UnaryOp<__logical_not>::_Rt operator!() const; | |
155 | ||
54c1bf78 | 156 | // _lib.valarray.cassign_ computed assignment: |
74d6b8ca GDR |
157 | valarray<_Tp>& operator*=(const _Tp&); |
158 | valarray<_Tp>& operator/=(const _Tp&); | |
159 | valarray<_Tp>& operator%=(const _Tp&); | |
160 | valarray<_Tp>& operator+=(const _Tp&); | |
161 | valarray<_Tp>& operator-=(const _Tp&); | |
162 | valarray<_Tp>& operator^=(const _Tp&); | |
163 | valarray<_Tp>& operator&=(const _Tp&); | |
164 | valarray<_Tp>& operator|=(const _Tp&); | |
54c1bf78 BK |
165 | valarray<_Tp>& operator<<=(const _Tp&); |
166 | valarray<_Tp>& operator>>=(const _Tp&); | |
74d6b8ca GDR |
167 | valarray<_Tp>& operator*=(const valarray<_Tp>&); |
168 | valarray<_Tp>& operator/=(const valarray<_Tp>&); | |
169 | valarray<_Tp>& operator%=(const valarray<_Tp>&); | |
170 | valarray<_Tp>& operator+=(const valarray<_Tp>&); | |
171 | valarray<_Tp>& operator-=(const valarray<_Tp>&); | |
172 | valarray<_Tp>& operator^=(const valarray<_Tp>&); | |
173 | valarray<_Tp>& operator|=(const valarray<_Tp>&); | |
174 | valarray<_Tp>& operator&=(const valarray<_Tp>&); | |
54c1bf78 BK |
175 | valarray<_Tp>& operator<<=(const valarray<_Tp>&); |
176 | valarray<_Tp>& operator>>=(const valarray<_Tp>&); | |
177 | ||
178 | template<class _Dom> | |
74d6b8ca | 179 | valarray<_Tp>& operator*=(const _Expr<_Dom,_Tp>&); |
54c1bf78 | 180 | template<class _Dom> |
74d6b8ca | 181 | valarray<_Tp>& operator/=(const _Expr<_Dom,_Tp>&); |
54c1bf78 | 182 | template<class _Dom> |
74d6b8ca | 183 | valarray<_Tp>& operator%=(const _Expr<_Dom,_Tp>&); |
54c1bf78 | 184 | template<class _Dom> |
74d6b8ca | 185 | valarray<_Tp>& operator+=(const _Expr<_Dom,_Tp>&); |
54c1bf78 | 186 | template<class _Dom> |
74d6b8ca | 187 | valarray<_Tp>& operator-=(const _Expr<_Dom,_Tp>&); |
54c1bf78 | 188 | template<class _Dom> |
74d6b8ca | 189 | valarray<_Tp>& operator^=(const _Expr<_Dom,_Tp>&); |
54c1bf78 | 190 | template<class _Dom> |
74d6b8ca | 191 | valarray<_Tp>& operator|=(const _Expr<_Dom,_Tp>&); |
54c1bf78 | 192 | template<class _Dom> |
74d6b8ca | 193 | valarray<_Tp>& operator&=(const _Expr<_Dom,_Tp>&); |
54c1bf78 | 194 | template<class _Dom> |
74d6b8ca | 195 | valarray<_Tp>& operator<<=(const _Expr<_Dom,_Tp>&); |
54c1bf78 | 196 | template<class _Dom> |
74d6b8ca GDR |
197 | valarray<_Tp>& operator>>=(const _Expr<_Dom,_Tp>&); |
198 | ||
54c1bf78 | 199 | |
54c1bf78 BK |
200 | // _lib.valarray.members_ member functions: |
201 | size_t size() const; | |
202 | _Tp sum() const; | |
203 | _Tp min() const; | |
204 | _Tp max() const; | |
205 | ||
74d6b8ca GDR |
206 | // // FIXME: Extension |
207 | // _Tp product () const; | |
54c1bf78 BK |
208 | |
209 | valarray<_Tp> shift (int) const; | |
210 | valarray<_Tp> cshift(int) const; | |
211 | _Expr<_ValFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(_Tp)) const; | |
212 | _Expr<_RefFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(const _Tp&)) const; | |
213 | void resize(size_t __size, _Tp __c = _Tp()); | |
214 | ||
74d6b8ca | 215 | private: |
54c1bf78 BK |
216 | size_t _M_size; |
217 | _Tp* __restrict__ _M_data; | |
74d6b8ca | 218 | |
54c1bf78 | 219 | friend class _Array<_Tp>; |
74d6b8ca | 220 | }; |
54c1bf78 BK |
221 | |
222 | template<typename _Tp> | |
74d6b8ca GDR |
223 | inline const _Tp& |
224 | valarray<_Tp>::operator[](size_t __i) const | |
285b36d6 BK |
225 | { |
226 | __glibcxx_requires_subscript(__i); | |
227 | return _M_data[__i]; | |
228 | } | |
54c1bf78 BK |
229 | |
230 | template<typename _Tp> | |
74d6b8ca GDR |
231 | inline _Tp& |
232 | valarray<_Tp>::operator[](size_t __i) | |
285b36d6 BK |
233 | { |
234 | __glibcxx_requires_subscript(__i); | |
235 | return _M_data[__i]; | |
236 | } | |
54c1bf78 BK |
237 | |
238 | } // std:: | |
c13bea50 NS |
239 | |
240 | #include <bits/valarray_after.h> | |
241 | ||
54c1bf78 BK |
242 | #include <bits/slice_array.h> |
243 | #include <bits/gslice.h> | |
244 | #include <bits/gslice_array.h> | |
245 | #include <bits/mask_array.h> | |
246 | #include <bits/indirect_array.h> | |
247 | ||
248 | namespace std | |
249 | { | |
250 | template<typename _Tp> | |
74d6b8ca GDR |
251 | inline |
252 | valarray<_Tp>::valarray() : _M_size(0), _M_data(0) {} | |
54c1bf78 BK |
253 | |
254 | template<typename _Tp> | |
74d6b8ca GDR |
255 | inline |
256 | valarray<_Tp>::valarray(size_t __n) | |
257 | : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) | |
eb9a4231 | 258 | { std::__valarray_default_construct(_M_data, _M_data + __n); } |
54c1bf78 BK |
259 | |
260 | template<typename _Tp> | |
74d6b8ca GDR |
261 | inline |
262 | valarray<_Tp>::valarray(const _Tp& __t, size_t __n) | |
263 | : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) | |
eb9a4231 | 264 | { std::__valarray_fill_construct(_M_data, _M_data + __n, __t); } |
54c1bf78 BK |
265 | |
266 | template<typename _Tp> | |
74d6b8ca GDR |
267 | inline |
268 | valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n) | |
269 | : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) | |
285b36d6 BK |
270 | { |
271 | _GLIBCXX_DEBUG_ASSERT(__p != 0 || __n == 0); | |
272 | std::__valarray_copy_construct(__p, __p + __n, _M_data); | |
273 | } | |
54c1bf78 BK |
274 | |
275 | template<typename _Tp> | |
74d6b8ca GDR |
276 | inline |
277 | valarray<_Tp>::valarray(const valarray<_Tp>& __v) | |
278 | : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size)) | |
eb9a4231 | 279 | { std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size, _M_data); } |
54c1bf78 BK |
280 | |
281 | template<typename _Tp> | |
74d6b8ca GDR |
282 | inline |
283 | valarray<_Tp>::valarray(const slice_array<_Tp>& __sa) | |
284 | : _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz)) | |
285 | { | |
eb9a4231 | 286 | std::__valarray_copy |
74d6b8ca GDR |
287 | (__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data)); |
288 | } | |
54c1bf78 BK |
289 | |
290 | template<typename _Tp> | |
74d6b8ca GDR |
291 | inline |
292 | valarray<_Tp>::valarray(const gslice_array<_Tp>& __ga) | |
293 | : _M_size(__ga._M_index.size()), | |
294 | _M_data(__valarray_get_storage<_Tp>(_M_size)) | |
295 | { | |
eb9a4231 | 296 | std::__valarray_copy |
74d6b8ca GDR |
297 | (__ga._M_array, _Array<size_t>(__ga._M_index), |
298 | _Array<_Tp>(_M_data), _M_size); | |
299 | } | |
54c1bf78 BK |
300 | |
301 | template<typename _Tp> | |
74d6b8ca GDR |
302 | inline |
303 | valarray<_Tp>::valarray(const mask_array<_Tp>& __ma) | |
304 | : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz)) | |
305 | { | |
eb9a4231 | 306 | std::__valarray_copy |
74d6b8ca GDR |
307 | (__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size); |
308 | } | |
54c1bf78 BK |
309 | |
310 | template<typename _Tp> | |
74d6b8ca GDR |
311 | inline |
312 | valarray<_Tp>::valarray(const indirect_array<_Tp>& __ia) | |
313 | : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz)) | |
314 | { | |
eb9a4231 | 315 | std::__valarray_copy |
74d6b8ca GDR |
316 | (__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size); |
317 | } | |
54c1bf78 BK |
318 | |
319 | template<typename _Tp> template<class _Dom> | |
74d6b8ca GDR |
320 | inline |
321 | valarray<_Tp>::valarray(const _Expr<_Dom, _Tp>& __e) | |
322 | : _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size)) | |
eb9a4231 | 323 | { std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); } |
54c1bf78 BK |
324 | |
325 | template<typename _Tp> | |
74d6b8ca GDR |
326 | inline |
327 | valarray<_Tp>::~valarray() | |
328 | { | |
eb9a4231 PC |
329 | std::__valarray_destroy_elements(_M_data, _M_data + _M_size); |
330 | std::__valarray_release_memory(_M_data); | |
74d6b8ca | 331 | } |
54c1bf78 BK |
332 | |
333 | template<typename _Tp> | |
74d6b8ca GDR |
334 | inline valarray<_Tp>& |
335 | valarray<_Tp>::operator=(const valarray<_Tp>& __v) | |
336 | { | |
285b36d6 | 337 | _GLIBCXX_DEBUG_ASSERT(_M_size == __v._M_size); |
eb9a4231 | 338 | std::__valarray_copy(__v._M_data, _M_size, _M_data); |
54c1bf78 | 339 | return *this; |
74d6b8ca | 340 | } |
54c1bf78 BK |
341 | |
342 | template<typename _Tp> | |
74d6b8ca GDR |
343 | inline valarray<_Tp>& |
344 | valarray<_Tp>::operator=(const _Tp& __t) | |
345 | { | |
eb9a4231 | 346 | std::__valarray_fill(_M_data, _M_size, __t); |
54c1bf78 | 347 | return *this; |
74d6b8ca | 348 | } |
54c1bf78 BK |
349 | |
350 | template<typename _Tp> | |
74d6b8ca GDR |
351 | inline valarray<_Tp>& |
352 | valarray<_Tp>::operator=(const slice_array<_Tp>& __sa) | |
353 | { | |
285b36d6 | 354 | _GLIBCXX_DEBUG_ASSERT(_M_size == __sa._M_sz); |
eb9a4231 PC |
355 | std::__valarray_copy(__sa._M_array, __sa._M_sz, |
356 | __sa._M_stride, _Array<_Tp>(_M_data)); | |
54c1bf78 | 357 | return *this; |
74d6b8ca | 358 | } |
54c1bf78 BK |
359 | |
360 | template<typename _Tp> | |
74d6b8ca GDR |
361 | inline valarray<_Tp>& |
362 | valarray<_Tp>::operator=(const gslice_array<_Tp>& __ga) | |
363 | { | |
285b36d6 | 364 | _GLIBCXX_DEBUG_ASSERT(_M_size == __ga._M_index.size()); |
eb9a4231 PC |
365 | std::__valarray_copy(__ga._M_array, _Array<size_t>(__ga._M_index), |
366 | _Array<_Tp>(_M_data), _M_size); | |
54c1bf78 | 367 | return *this; |
74d6b8ca | 368 | } |
54c1bf78 BK |
369 | |
370 | template<typename _Tp> | |
74d6b8ca GDR |
371 | inline valarray<_Tp>& |
372 | valarray<_Tp>::operator=(const mask_array<_Tp>& __ma) | |
373 | { | |
285b36d6 | 374 | _GLIBCXX_DEBUG_ASSERT(_M_size == __ma._M_sz); |
eb9a4231 PC |
375 | std::__valarray_copy(__ma._M_array, __ma._M_mask, |
376 | _Array<_Tp>(_M_data), _M_size); | |
54c1bf78 | 377 | return *this; |
74d6b8ca | 378 | } |
54c1bf78 BK |
379 | |
380 | template<typename _Tp> | |
74d6b8ca GDR |
381 | inline valarray<_Tp>& |
382 | valarray<_Tp>::operator=(const indirect_array<_Tp>& __ia) | |
383 | { | |
285b36d6 | 384 | _GLIBCXX_DEBUG_ASSERT(_M_size == __ia._M_sz); |
eb9a4231 PC |
385 | std::__valarray_copy(__ia._M_array, __ia._M_index, |
386 | _Array<_Tp>(_M_data), _M_size); | |
54c1bf78 | 387 | return *this; |
74d6b8ca | 388 | } |
54c1bf78 BK |
389 | |
390 | template<typename _Tp> template<class _Dom> | |
74d6b8ca GDR |
391 | inline valarray<_Tp>& |
392 | valarray<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) | |
393 | { | |
285b36d6 | 394 | _GLIBCXX_DEBUG_ASSERT(_M_size == __e.size()); |
eb9a4231 PC |
395 | std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); |
396 | return *this; | |
74d6b8ca | 397 | } |
54c1bf78 BK |
398 | |
399 | template<typename _Tp> | |
74d6b8ca GDR |
400 | inline _Expr<_SClos<_ValArray,_Tp>, _Tp> |
401 | valarray<_Tp>::operator[](slice __s) const | |
402 | { | |
54c1bf78 | 403 | typedef _SClos<_ValArray,_Tp> _Closure; |
74d6b8ca GDR |
404 | return _Expr<_Closure, _Tp>(_Closure (_Array<_Tp>(_M_data), __s)); |
405 | } | |
54c1bf78 BK |
406 | |
407 | template<typename _Tp> | |
74d6b8ca GDR |
408 | inline slice_array<_Tp> |
409 | valarray<_Tp>::operator[](slice __s) | |
410 | { | |
411 | return slice_array<_Tp>(_Array<_Tp>(_M_data), __s); | |
412 | } | |
54c1bf78 BK |
413 | |
414 | template<typename _Tp> | |
74d6b8ca GDR |
415 | inline _Expr<_GClos<_ValArray,_Tp>, _Tp> |
416 | valarray<_Tp>::operator[](const gslice& __gs) const | |
417 | { | |
54c1bf78 BK |
418 | typedef _GClos<_ValArray,_Tp> _Closure; |
419 | return _Expr<_Closure, _Tp> | |
74d6b8ca GDR |
420 | (_Closure(_Array<_Tp>(_M_data), __gs._M_index->_M_index)); |
421 | } | |
54c1bf78 BK |
422 | |
423 | template<typename _Tp> | |
74d6b8ca GDR |
424 | inline gslice_array<_Tp> |
425 | valarray<_Tp>::operator[](const gslice& __gs) | |
426 | { | |
54c1bf78 | 427 | return gslice_array<_Tp> |
74d6b8ca GDR |
428 | (_Array<_Tp>(_M_data), __gs._M_index->_M_index); |
429 | } | |
54c1bf78 BK |
430 | |
431 | template<typename _Tp> | |
74d6b8ca GDR |
432 | inline valarray<_Tp> |
433 | valarray<_Tp>::operator[](const valarray<bool>& __m) const | |
434 | { | |
435 | size_t __s = 0; | |
436 | size_t __e = __m.size(); | |
54c1bf78 | 437 | for (size_t __i=0; __i<__e; ++__i) |
74d6b8ca GDR |
438 | if (__m[__i]) ++__s; |
439 | return valarray<_Tp>(mask_array<_Tp>(_Array<_Tp>(_M_data), __s, | |
440 | _Array<bool> (__m))); | |
441 | } | |
54c1bf78 BK |
442 | |
443 | template<typename _Tp> | |
74d6b8ca GDR |
444 | inline mask_array<_Tp> |
445 | valarray<_Tp>::operator[](const valarray<bool>& __m) | |
446 | { | |
447 | size_t __s = 0; | |
448 | size_t __e = __m.size(); | |
54c1bf78 | 449 | for (size_t __i=0; __i<__e; ++__i) |
74d6b8ca GDR |
450 | if (__m[__i]) ++__s; |
451 | return mask_array<_Tp>(_Array<_Tp>(_M_data), __s, _Array<bool>(__m)); | |
452 | } | |
54c1bf78 BK |
453 | |
454 | template<typename _Tp> | |
74d6b8ca GDR |
455 | inline _Expr<_IClos<_ValArray,_Tp>, _Tp> |
456 | valarray<_Tp>::operator[](const valarray<size_t>& __i) const | |
457 | { | |
54c1bf78 | 458 | typedef _IClos<_ValArray,_Tp> _Closure; |
74d6b8ca GDR |
459 | return _Expr<_Closure, _Tp>(_Closure(*this, __i)); |
460 | } | |
54c1bf78 BK |
461 | |
462 | template<typename _Tp> | |
74d6b8ca GDR |
463 | inline indirect_array<_Tp> |
464 | valarray<_Tp>::operator[](const valarray<size_t>& __i) | |
465 | { | |
466 | return indirect_array<_Tp>(_Array<_Tp>(_M_data), __i.size(), | |
467 | _Array<size_t>(__i)); | |
468 | } | |
54c1bf78 BK |
469 | |
470 | template<class _Tp> | |
74d6b8ca GDR |
471 | inline size_t |
472 | valarray<_Tp>::size() const | |
473 | { return _M_size; } | |
54c1bf78 BK |
474 | |
475 | template<class _Tp> | |
74d6b8ca GDR |
476 | inline _Tp |
477 | valarray<_Tp>::sum() const | |
478 | { | |
285b36d6 | 479 | _GLIBCXX_DEBUG_ASSERT(_M_size > 0); |
eb9a4231 | 480 | return std::__valarray_sum(_M_data, _M_data + _M_size); |
74d6b8ca | 481 | } |
54c1bf78 BK |
482 | |
483 | // template<typename _Tp> | |
484 | // inline _Tp | |
485 | // valarray<_Tp>::product () const | |
486 | // { | |
487 | // return __valarray_product(_M_data, _M_data + _M_size); | |
488 | // } | |
489 | ||
490 | template <class _Tp> | |
491 | inline valarray<_Tp> | |
492 | valarray<_Tp>::shift(int __n) const | |
493 | { | |
494 | _Tp* const __a = static_cast<_Tp*> | |
495 | (__builtin_alloca(sizeof(_Tp) * _M_size)); | |
496 | if (__n == 0) // no shift | |
eb9a4231 | 497 | std::__valarray_copy_construct(_M_data, _M_data + _M_size, __a); |
54c1bf78 BK |
498 | else if (__n > 0) // __n > 0: shift left |
499 | { | |
500 | if (size_t(__n) > _M_size) | |
eb9a4231 | 501 | std::__valarray_default_construct(__a, __a + __n); |
54c1bf78 BK |
502 | else |
503 | { | |
eb9a4231 PC |
504 | std::__valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a); |
505 | std::__valarray_default_construct(__a+_M_size-__n, __a + _M_size); | |
54c1bf78 BK |
506 | } |
507 | } | |
508 | else // __n < 0: shift right | |
509 | { | |
eb9a4231 PC |
510 | std::__valarray_copy_construct (_M_data, _M_data+_M_size+__n, __a-__n); |
511 | std::__valarray_default_construct(__a, __a - __n); | |
54c1bf78 BK |
512 | } |
513 | return valarray<_Tp> (__a, _M_size); | |
514 | } | |
515 | ||
516 | template <class _Tp> | |
517 | inline valarray<_Tp> | |
518 | valarray<_Tp>::cshift (int __n) const | |
519 | { | |
520 | _Tp* const __a = static_cast<_Tp*> | |
521 | (__builtin_alloca (sizeof(_Tp) * _M_size)); | |
522 | if (__n == 0) // no cshift | |
eb9a4231 | 523 | std::__valarray_copy_construct(_M_data, _M_data + _M_size, __a); |
54c1bf78 BK |
524 | else if (__n > 0) // cshift left |
525 | { | |
eb9a4231 PC |
526 | std::__valarray_copy_construct(_M_data, _M_data+__n, __a+_M_size-__n); |
527 | std::__valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a); | |
54c1bf78 BK |
528 | } |
529 | else // cshift right | |
530 | { | |
eb9a4231 | 531 | std::__valarray_copy_construct |
54c1bf78 | 532 | (_M_data + _M_size+__n, _M_data + _M_size, __a); |
eb9a4231 | 533 | std::__valarray_copy_construct |
54c1bf78 BK |
534 | (_M_data, _M_data + _M_size+__n, __a - __n); |
535 | } | |
536 | return valarray<_Tp>(__a, _M_size); | |
537 | } | |
538 | ||
539 | template <class _Tp> | |
74d6b8ca GDR |
540 | inline void |
541 | valarray<_Tp>::resize (size_t __n, _Tp __c) | |
542 | { | |
543 | // This complication is so to make valarray<valarray<T> > work | |
544 | // even though it is not required by the standard. Nobody should | |
545 | // be saying valarray<valarray<T> > anyway. See the specs. | |
eb9a4231 | 546 | std::__valarray_destroy_elements(_M_data, _M_data + _M_size); |
74d6b8ca GDR |
547 | if (_M_size != __n) |
548 | { | |
eb9a4231 | 549 | std::__valarray_release_memory(_M_data); |
74d6b8ca GDR |
550 | _M_size = __n; |
551 | _M_data = __valarray_get_storage<_Tp>(__n); | |
552 | } | |
eb9a4231 | 553 | std::__valarray_fill_construct(_M_data, _M_data + __n, __c); |
74d6b8ca | 554 | } |
54c1bf78 BK |
555 | |
556 | template<typename _Tp> | |
74d6b8ca GDR |
557 | inline _Tp |
558 | valarray<_Tp>::min() const | |
559 | { | |
285b36d6 | 560 | _GLIBCXX_DEBUG_ASSERT(_M_size > 0); |
eb9a4231 | 561 | return *std::min_element (_M_data, _M_data+_M_size); |
74d6b8ca | 562 | } |
54c1bf78 BK |
563 | |
564 | template<typename _Tp> | |
74d6b8ca GDR |
565 | inline _Tp |
566 | valarray<_Tp>::max() const | |
567 | { | |
285b36d6 | 568 | _GLIBCXX_DEBUG_ASSERT(_M_size > 0); |
eb9a4231 | 569 | return *std::max_element (_M_data, _M_data+_M_size); |
74d6b8ca | 570 | } |
54c1bf78 BK |
571 | |
572 | template<class _Tp> | |
74d6b8ca GDR |
573 | inline _Expr<_ValFunClos<_ValArray,_Tp>,_Tp> |
574 | valarray<_Tp>::apply(_Tp func(_Tp)) const | |
575 | { | |
54c1bf78 | 576 | typedef _ValFunClos<_ValArray,_Tp> _Closure; |
74d6b8ca GDR |
577 | return _Expr<_Closure,_Tp>(_Closure(*this, func)); |
578 | } | |
54c1bf78 BK |
579 | |
580 | template<class _Tp> | |
74d6b8ca GDR |
581 | inline _Expr<_RefFunClos<_ValArray,_Tp>,_Tp> |
582 | valarray<_Tp>::apply(_Tp func(const _Tp &)) const | |
583 | { | |
54c1bf78 | 584 | typedef _RefFunClos<_ValArray,_Tp> _Closure; |
74d6b8ca GDR |
585 | return _Expr<_Closure,_Tp>(_Closure(*this, func)); |
586 | } | |
54c1bf78 BK |
587 | |
588 | #define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op, _Name) \ | |
589 | template<typename _Tp> \ | |
74d6b8ca | 590 | inline typename valarray<_Tp>::template _UnaryOp<_Name>::_Rt \ |
54c1bf78 BK |
591 | valarray<_Tp>::operator _Op() const \ |
592 | { \ | |
74d6b8ca GDR |
593 | typedef _UnClos<_Name,_ValArray,_Tp> _Closure; \ |
594 | typedef typename __fun<_Name, _Tp>::result_type _Rt; \ | |
595 | return _Expr<_Closure, _Rt>(_Closure(*this)); \ | |
54c1bf78 BK |
596 | } |
597 | ||
74d6b8ca GDR |
598 | _DEFINE_VALARRAY_UNARY_OPERATOR(+, __unary_plus) |
599 | _DEFINE_VALARRAY_UNARY_OPERATOR(-, __negate) | |
600 | _DEFINE_VALARRAY_UNARY_OPERATOR(~, __bitwise_not) | |
601 | _DEFINE_VALARRAY_UNARY_OPERATOR (!, __logical_not) | |
54c1bf78 BK |
602 | |
603 | #undef _DEFINE_VALARRAY_UNARY_OPERATOR | |
54c1bf78 BK |
604 | |
605 | #define _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(_Op, _Name) \ | |
606 | template<class _Tp> \ | |
971cfc6f GDR |
607 | inline valarray<_Tp>& \ |
608 | valarray<_Tp>::operator _Op##=(const _Tp &__t) \ | |
609 | { \ | |
610 | _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, __t); \ | |
54c1bf78 | 611 | return *this; \ |
971cfc6f | 612 | } \ |
54c1bf78 BK |
613 | \ |
614 | template<class _Tp> \ | |
971cfc6f GDR |
615 | inline valarray<_Tp>& \ |
616 | valarray<_Tp>::operator _Op##=(const valarray<_Tp> &__v) \ | |
617 | { \ | |
285b36d6 | 618 | _GLIBCXX_DEBUG_ASSERT(_M_size == __v._M_size); \ |
971cfc6f GDR |
619 | _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, \ |
620 | _Array<_Tp>(__v._M_data)); \ | |
54c1bf78 | 621 | return *this; \ |
971cfc6f | 622 | } |
54c1bf78 | 623 | |
971cfc6f GDR |
624 | _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(+, __plus) |
625 | _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(-, __minus) | |
626 | _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(*, __multiplies) | |
627 | _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(/, __divides) | |
628 | _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(%, __modulus) | |
629 | _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(^, __bitwise_xor) | |
630 | _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(&, __bitwise_and) | |
631 | _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(|, __bitwise_or) | |
632 | _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(<<, __shift_left) | |
633 | _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(>>, __shift_right) | |
54c1bf78 BK |
634 | |
635 | #undef _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT | |
636 | ||
54c1bf78 BK |
637 | #define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op, _Name) \ |
638 | template<class _Tp> template<class _Dom> \ | |
971cfc6f GDR |
639 | inline valarray<_Tp>& \ |
640 | valarray<_Tp>::operator _Op##=(const _Expr<_Dom,_Tp>& __e) \ | |
641 | { \ | |
642 | _Array_augmented_##_Name(_Array<_Tp>(_M_data), __e, _M_size); \ | |
54c1bf78 | 643 | return *this; \ |
971cfc6f | 644 | } |
54c1bf78 | 645 | |
971cfc6f GDR |
646 | _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(+, __plus) |
647 | _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(-, __minus) | |
648 | _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(*, __multiplies) | |
649 | _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(/, __divides) | |
650 | _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(%, __modulus) | |
651 | _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(^, __bitwise_xor) | |
652 | _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(&, __bitwise_and) | |
653 | _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(|, __bitwise_or) | |
654 | _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(<<, __shift_left) | |
655 | _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right) | |
54c1bf78 BK |
656 | |
657 | #undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT | |
658 | ||
659 | ||
660 | #define _DEFINE_BINARY_OPERATOR(_Op, _Name) \ | |
661 | template<typename _Tp> \ | |
971cfc6f GDR |
662 | inline _Expr<_BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp>, \ |
663 | typename __fun<_Name, _Tp>::result_type> \ | |
664 | operator _Op(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \ | |
665 | { \ | |
285b36d6 | 666 | _GLIBCXX_DEBUG_ASSERT(__v.size() == __w.size()); \ |
54c1bf78 | 667 | typedef _BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp> _Closure; \ |
971cfc6f GDR |
668 | typedef typename __fun<_Name, _Tp>::result_type _Rt; \ |
669 | return _Expr<_Closure, _Rt>(_Closure(__v, __w)); \ | |
670 | } \ | |
54c1bf78 BK |
671 | \ |
672 | template<typename _Tp> \ | |
971cfc6f GDR |
673 | inline _Expr<_BinClos<_Name,_ValArray,_Constant,_Tp,_Tp>, \ |
674 | typename __fun<_Name, _Tp>::result_type> \ | |
675 | operator _Op(const valarray<_Tp>& __v, const _Tp& __t) \ | |
54c1bf78 | 676 | { \ |
971cfc6f GDR |
677 | typedef _BinClos<_Name,_ValArray,_Constant,_Tp,_Tp> _Closure; \ |
678 | typedef typename __fun<_Name, _Tp>::result_type _Rt; \ | |
679 | return _Expr<_Closure, _Rt>(_Closure(__v, __t)); \ | |
54c1bf78 BK |
680 | } \ |
681 | \ | |
682 | template<typename _Tp> \ | |
971cfc6f GDR |
683 | inline _Expr<_BinClos<_Name,_Constant,_ValArray,_Tp,_Tp>, \ |
684 | typename __fun<_Name, _Tp>::result_type> \ | |
685 | operator _Op(const _Tp& __t, const valarray<_Tp>& __v) \ | |
54c1bf78 | 686 | { \ |
971cfc6f GDR |
687 | typedef _BinClos<_Name,_Constant,_ValArray,_Tp,_Tp> _Closure; \ |
688 | typedef typename __fun<_Name, _Tp>::result_type _Rt; \ | |
689 | return _Expr<_Closure, _Tp>(_Closure(__t, __v)); \ | |
54c1bf78 BK |
690 | } |
691 | ||
971cfc6f GDR |
692 | _DEFINE_BINARY_OPERATOR(+, __plus) |
693 | _DEFINE_BINARY_OPERATOR(-, __minus) | |
694 | _DEFINE_BINARY_OPERATOR(*, __multiplies) | |
695 | _DEFINE_BINARY_OPERATOR(/, __divides) | |
696 | _DEFINE_BINARY_OPERATOR(%, __modulus) | |
697 | _DEFINE_BINARY_OPERATOR(^, __bitwise_xor) | |
698 | _DEFINE_BINARY_OPERATOR(&, __bitwise_and) | |
699 | _DEFINE_BINARY_OPERATOR(|, __bitwise_or) | |
700 | _DEFINE_BINARY_OPERATOR(<<, __shift_left) | |
701 | _DEFINE_BINARY_OPERATOR(>>, __shift_right) | |
702 | _DEFINE_BINARY_OPERATOR(&&, __logical_and) | |
703 | _DEFINE_BINARY_OPERATOR(||, __logical_or) | |
704 | _DEFINE_BINARY_OPERATOR(==, __equal_to) | |
705 | _DEFINE_BINARY_OPERATOR(!=, __not_equal_to) | |
706 | _DEFINE_BINARY_OPERATOR(<, __less) | |
707 | _DEFINE_BINARY_OPERATOR(>, __greater) | |
708 | _DEFINE_BINARY_OPERATOR(<=, __less_equal) | |
709 | _DEFINE_BINARY_OPERATOR(>=, __greater_equal) | |
54c1bf78 BK |
710 | |
711 | } // namespace std | |
712 | ||
1143680e | 713 | #endif /* _GLIBCXX_VALARRAY */ |