Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / libcxx / 73d21a4f0774d3fadab98e690619a359cfb160a3 / . / include / valarray
blob: 2cac7331e349adcd6f79b4397d23f3ce363f0dc6 [file] [log] [blame]
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]1// -*- C++ -*-
2//===-------------------------- valarray ----------------------------------===//
3//
Howard Hinnantf5256e12010-05-11 21:36:01 +0000[diff] [blame]4// The LLVM Compiler Infrastructure
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]5//
6// This file is distributed under the University of Illinois Open Source
7// License. See LICENSE.TXT for details.
8//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_VALARRAY
12#define _LIBCPP_VALARRAY
13
14/*
15 valarray synopsis
16
17namespace std
18{
19
20template<class T>
21class valarray
22{
23public:
24 typedef T value_type;
25
26 // construct/destroy:
27 valarray();
28 explicit valarray(size_t n);
29 valarray(const value_type& x, size_t n);
30 valarray(const value_type* px, size_t n);
31 valarray(const valarray& v);
32 valarray(valarray&& v);
33 valarray(const slice_array<value_type>& sa);
34 valarray(const gslice_array<value_type>& ga);
35 valarray(const mask_array<value_type>& ma);
36 valarray(const indirect_array<value_type>& ia);
37 valarray(initializer_list<value_type> il);
38 ~valarray();
39
40 // assignment:
41 valarray& operator=(const valarray& v);
42 valarray& operator=(valarray&& v);
43 valarray& operator=(initializer_list<value_type> il);
44 valarray& operator=(const value_type& x);
45 valarray& operator=(const slice_array<value_type>& sa);
46 valarray& operator=(const gslice_array<value_type>& ga);
47 valarray& operator=(const mask_array<value_type>& ma);
48 valarray& operator=(const indirect_array<value_type>& ia);
49
50 // element access:
51 const value_type& operator[](size_t i) const;
52 value_type& operator[](size_t i);
53
54 // subset operations:
55 valarray operator[](slice s) const;
56 slice_array<value_type> operator[](slice s);
57 valarray operator[](const gslice& gs) const;
58 gslice_array<value_type> operator[](const gslice& gs);
59 valarray operator[](const valarray<bool>& vb) const;
60 mask_array<value_type> operator[](const valarray<bool>& vb);
61 valarray operator[](const valarray<size_t>& vs) const;
62 indirect_array<value_type> operator[](const valarray<size_t>& vs);
63
64 // unary operators:
65 valarray operator+() const;
66 valarray operator-() const;
67 valarray operator~() const;
68 valarray<bool> operator!() const;
69
70 // computed assignment:
71 valarray& operator*= (const value_type& x);
72 valarray& operator/= (const value_type& x);
73 valarray& operator%= (const value_type& x);
74 valarray& operator+= (const value_type& x);
75 valarray& operator-= (const value_type& x);
76 valarray& operator^= (const value_type& x);
77 valarray& operator&= (const value_type& x);
78 valarray& operator|= (const value_type& x);
79 valarray& operator<<=(const value_type& x);
80 valarray& operator>>=(const value_type& x);
81
82 valarray& operator*= (const valarray& v);
83 valarray& operator/= (const valarray& v);
84 valarray& operator%= (const valarray& v);
85 valarray& operator+= (const valarray& v);
86 valarray& operator-= (const valarray& v);
87 valarray& operator^= (const valarray& v);
88 valarray& operator|= (const valarray& v);
89 valarray& operator&= (const valarray& v);
90 valarray& operator<<=(const valarray& v);
91 valarray& operator>>=(const valarray& v);
92
93 // member functions:
94 void swap(valarray& v);
95
96 size_t size() const;
97
98 value_type sum() const;
99 value_type min() const;
100 value_type max() const;
101
102 valarray shift (int i) const;
103 valarray cshift(int i) const;
104 valarray apply(value_type f(value_type)) const;
105 valarray apply(value_type f(const value_type&)) const;
106 void resize(size_t n, value_type x = value_type());
107};
108
109class slice
110{
111public:
112 slice();
113 slice(size_t start, size_t size, size_t stride);
114
115 size_t start() const;
116 size_t size() const;
117 size_t stride() const;
118};
119
120template <class T>
121class slice_array
122{
123public:
124 typedef T value_type;
125
126 const slice_array& operator=(const slice_array& sa) const;
127 void operator= (const valarray<value_type>& v) const;
128 void operator*= (const valarray<value_type>& v) const;
129 void operator/= (const valarray<value_type>& v) const;
130 void operator%= (const valarray<value_type>& v) const;
131 void operator+= (const valarray<value_type>& v) const;
132 void operator-= (const valarray<value_type>& v) const;
133 void operator^= (const valarray<value_type>& v) const;
134 void operator&= (const valarray<value_type>& v) const;
135 void operator|= (const valarray<value_type>& v) const;
136 void operator<<=(const valarray<value_type>& v) const;
137 void operator>>=(const valarray<value_type>& v) const;
138
139 void operator=(const value_type& x) const;
140
141 slice_array() = delete;
142};
143
144class gslice
145{
146public:
147 gslice();
148 gslice(size_t start, const valarray<size_t>& size,
149 const valarray<size_t>& stride);
150
151 size_t start() const;
152 valarray<size_t> size() const;
153 valarray<size_t> stride() const;
154};
155
156template <class T>
157class gslice_array
158{
159public:
160 typedef T value_type;
161
162 void operator= (const valarray<value_type>& v) const;
163 void operator*= (const valarray<value_type>& v) const;
164 void operator/= (const valarray<value_type>& v) const;
165 void operator%= (const valarray<value_type>& v) const;
166 void operator+= (const valarray<value_type>& v) const;
167 void operator-= (const valarray<value_type>& v) const;
168 void operator^= (const valarray<value_type>& v) const;
169 void operator&= (const valarray<value_type>& v) const;
170 void operator|= (const valarray<value_type>& v) const;
171 void operator<<=(const valarray<value_type>& v) const;
172 void operator>>=(const valarray<value_type>& v) const;
173
174 gslice_array(const gslice_array& ga);
175 ~gslice_array();
176 const gslice_array& operator=(const gslice_array& ga) const;
177 void operator=(const value_type& x) const;
178
179 gslice_array() = delete;
180};
181
182template <class T>
183class mask_array
184{
185public:
186 typedef T value_type;
187
188 void operator= (const valarray<value_type>& v) const;
189 void operator*= (const valarray<value_type>& v) const;
190 void operator/= (const valarray<value_type>& v) const;
191 void operator%= (const valarray<value_type>& v) const;
192 void operator+= (const valarray<value_type>& v) const;
193 void operator-= (const valarray<value_type>& v) const;
194 void operator^= (const valarray<value_type>& v) const;
195 void operator&= (const valarray<value_type>& v) const;
196 void operator|= (const valarray<value_type>& v) const;
197 void operator<<=(const valarray<value_type>& v) const;
198 void operator>>=(const valarray<value_type>& v) const;
199
200 mask_array(const mask_array& ma);
201 ~mask_array();
202 const mask_array& operator=(const mask_array& ma) const;
203 void operator=(const value_type& x) const;
204
205 mask_array() = delete;
206};
207
208template <class T>
209class indirect_array
210{
211public:
212 typedef T value_type;
213
214 void operator= (const valarray<value_type>& v) const;
215 void operator*= (const valarray<value_type>& v) const;
216 void operator/= (const valarray<value_type>& v) const;
217 void operator%= (const valarray<value_type>& v) const;
218 void operator+= (const valarray<value_type>& v) const;
219 void operator-= (const valarray<value_type>& v) const;
220 void operator^= (const valarray<value_type>& v) const;
221 void operator&= (const valarray<value_type>& v) const;
222 void operator|= (const valarray<value_type>& v) const;
223 void operator<<=(const valarray<value_type>& v) const;
224 void operator>>=(const valarray<value_type>& v) const;
225
226 indirect_array(const indirect_array& ia);
227 ~indirect_array();
228 const indirect_array& operator=(const indirect_array& ia) const;
229 void operator=(const value_type& x) const;
230
231 indirect_array() = delete;
232};
233
234template<class T> void swap(valarray<T>& x, valarray<T>& y);
235
236template<class T> valarray<T> operator* (const valarray<T>& x, const valarray<T>& y);
237template<class T> valarray<T> operator* (const valarray<T>& x, const T& y);
238template<class T> valarray<T> operator* (const T& x, const valarray<T>& y);
239
240template<class T> valarray<T> operator/ (const valarray<T>& x, const valarray<T>& y);
241template<class T> valarray<T> operator/ (const valarray<T>& x, const T& y);
242template<class T> valarray<T> operator/ (const T& x, const valarray<T>& y);
243
244template<class T> valarray<T> operator% (const valarray<T>& x, const valarray<T>& y);
245template<class T> valarray<T> operator% (const valarray<T>& x, const T& y);
246template<class T> valarray<T> operator% (const T& x, const valarray<T>& y);
247
248template<class T> valarray<T> operator+ (const valarray<T>& x, const valarray<T>& y);
249template<class T> valarray<T> operator+ (const valarray<T>& x, const T& y);
250template<class T> valarray<T> operator+ (const T& x, const valarray<T>& y);
251
252template<class T> valarray<T> operator- (const valarray<T>& x, const valarray<T>& y);
253template<class T> valarray<T> operator- (const valarray<T>& x, const T& y);
254template<class T> valarray<T> operator- (const T& x, const valarray<T>& y);
255
256template<class T> valarray<T> operator^ (const valarray<T>& x, const valarray<T>& y);
257template<class T> valarray<T> operator^ (const valarray<T>& x, const T& y);
258template<class T> valarray<T> operator^ (const T& x, const valarray<T>& y);
259
260template<class T> valarray<T> operator& (const valarray<T>& x, const valarray<T>& y);
261template<class T> valarray<T> operator& (const valarray<T>& x, const T& y);
262template<class T> valarray<T> operator& (const T& x, const valarray<T>& y);
263
264template<class T> valarray<T> operator| (const valarray<T>& x, const valarray<T>& y);
265template<class T> valarray<T> operator| (const valarray<T>& x, const T& y);
266template<class T> valarray<T> operator| (const T& x, const valarray<T>& y);
267
268template<class T> valarray<T> operator<<(const valarray<T>& x, const valarray<T>& y);
269template<class T> valarray<T> operator<<(const valarray<T>& x, const T& y);
270template<class T> valarray<T> operator<<(const T& x, const valarray<T>& y);
271
272template<class T> valarray<T> operator>>(const valarray<T>& x, const valarray<T>& y);
273template<class T> valarray<T> operator>>(const valarray<T>& x, const T& y);
274template<class T> valarray<T> operator>>(const T& x, const valarray<T>& y);
275
276template<class T> valarray<bool> operator&&(const valarray<T>& x, const valarray<T>& y);
277template<class T> valarray<bool> operator&&(const valarray<T>& x, const T& y);
278template<class T> valarray<bool> operator&&(const T& x, const valarray<T>& y);
279
280template<class T> valarray<bool> operator||(const valarray<T>& x, const valarray<T>& y);
281template<class T> valarray<bool> operator||(const valarray<T>& x, const T& y);
282template<class T> valarray<bool> operator||(const T& x, const valarray<T>& y);
283
284template<class T> valarray<bool> operator==(const valarray<T>& x, const valarray<T>& y);
285template<class T> valarray<bool> operator==(const valarray<T>& x, const T& y);
286template<class T> valarray<bool> operator==(const T& x, const valarray<T>& y);
287
288template<class T> valarray<bool> operator!=(const valarray<T>& x, const valarray<T>& y);
289template<class T> valarray<bool> operator!=(const valarray<T>& x, const T& y);
290template<class T> valarray<bool> operator!=(const T& x, const valarray<T>& y);
291
292template<class T> valarray<bool> operator< (const valarray<T>& x, const valarray<T>& y);
293template<class T> valarray<bool> operator< (const valarray<T>& x, const T& y);
294template<class T> valarray<bool> operator< (const T& x, const valarray<T>& y);
295
296template<class T> valarray<bool> operator> (const valarray<T>& x, const valarray<T>& y);
297template<class T> valarray<bool> operator> (const valarray<T>& x, const T& y);
298template<class T> valarray<bool> operator> (const T& x, const valarray<T>& y);
299
300template<class T> valarray<bool> operator<=(const valarray<T>& x, const valarray<T>& y);
301template<class T> valarray<bool> operator<=(const valarray<T>& x, const T& y);
302template<class T> valarray<bool> operator<=(const T& x, const valarray<T>& y);
303
304template<class T> valarray<bool> operator>=(const valarray<T>& x, const valarray<T>& y);
305template<class T> valarray<bool> operator>=(const valarray<T>& x, const T& y);
306template<class T> valarray<bool> operator>=(const T& x, const valarray<T>& y);
307
308template<class T> valarray<T> abs (const valarray<T>& x);
309template<class T> valarray<T> acos (const valarray<T>& x);
310template<class T> valarray<T> asin (const valarray<T>& x);
311template<class T> valarray<T> atan (const valarray<T>& x);
312
313template<class T> valarray<T> atan2(const valarray<T>& x, const valarray<T>& y);
314template<class T> valarray<T> atan2(const valarray<T>& x, const T& y);
315template<class T> valarray<T> atan2(const T& x, const valarray<T>& y);
316
317template<class T> valarray<T> cos (const valarray<T>& x);
318template<class T> valarray<T> cosh (const valarray<T>& x);
319template<class T> valarray<T> exp (const valarray<T>& x);
320template<class T> valarray<T> log (const valarray<T>& x);
321template<class T> valarray<T> log10(const valarray<T>& x);
322
323template<class T> valarray<T> pow(const valarray<T>& x, const valarray<T>& y);
324template<class T> valarray<T> pow(const valarray<T>& x, const T& y);
325template<class T> valarray<T> pow(const T& x, const valarray<T>& y);
326
327template<class T> valarray<T> sin (const valarray<T>& x);
328template<class T> valarray<T> sinh (const valarray<T>& x);
329template<class T> valarray<T> sqrt (const valarray<T>& x);
330template<class T> valarray<T> tan (const valarray<T>& x);
331template<class T> valarray<T> tanh (const valarray<T>& x);
332
333template <class T> unspecified1 begin(valarray<T>& v);
334template <class T> unspecified2 begin(const valarray<T>& v);
335template <class T> unspecified1 end(valarray<T>& v);
336template <class T> unspecified2 end(const valarray<T>& v);
337
338} // std
339
340*/
341
342#include <__config>
343#include <cstddef>
344#include <cmath>
345#include <initializer_list>
346#include <algorithm>
347#include <functional>
348
349#pragma GCC system_header
350
351_LIBCPP_BEGIN_NAMESPACE_STD
352
353template<class _Tp> class valarray;
354
355class slice
356{
357 size_t __start_;
358 size_t __size_;
359 size_t __stride_;
360public:
361 _LIBCPP_ALWAYS_INLINE
362 slice()
363 : __start_(0),
364 __size_(0),
365 __stride_(0)
366 {}
367
368 _LIBCPP_ALWAYS_INLINE
369 slice(size_t __start, size_t __size, size_t __stride)
370 : __start_(__start),
371 __size_(__size),
372 __stride_(__stride)
373 {}
374
375 _LIBCPP_ALWAYS_INLINE size_t start() const {return __start_;}
376 _LIBCPP_ALWAYS_INLINE size_t size() const {return __size_;}
377 _LIBCPP_ALWAYS_INLINE size_t stride() const {return __stride_;}
378};
379
380template <class _Tp> class slice_array;
381class gslice;
382template <class _Tp> class gslice_array;
383template <class _Tp> class mask_array;
384template <class _Tp> class indirect_array;
385
386template <class _Tp>
387_Tp*
388begin(valarray<_Tp>& __v);
389
390template <class _Tp>
391const _Tp*
392begin(const valarray<_Tp>& __v);
393
394template <class _Tp>
395_Tp*
396end(valarray<_Tp>& __v);
397
398template <class _Tp>
399const _Tp*
400end(const valarray<_Tp>& __v);
401
402template <class _Op, class _A0>
403struct _UnaryOp
404{
405 typedef typename _Op::result_type result_type;
406 typedef typename _A0::value_type value_type;
407
408 _Op __op_;
409 _A0 __a0_;
410
411 _LIBCPP_ALWAYS_INLINE
412 _UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {}
413
414 _LIBCPP_ALWAYS_INLINE
415 result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}
416
417 _LIBCPP_ALWAYS_INLINE
418 size_t size() const {return __a0_.size();}
419};
420
421template <class _Op, class _A0, class _A1>
422struct _BinaryOp
423{
424 typedef typename _Op::result_type result_type;
425 typedef typename _A0::value_type value_type;
426
427 _Op __op_;
428 _A0 __a0_;
429 _A1 __a1_;
430
431 _LIBCPP_ALWAYS_INLINE
432 _BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1)
433 : __op_(__op), __a0_(__a0), __a1_(__a1) {}
434
435 _LIBCPP_ALWAYS_INLINE
436 value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
437
438 _LIBCPP_ALWAYS_INLINE
439 size_t size() const {return __a0_.size();}
440};
441
442template <class _Tp>
443class __scalar_expr
444{
445public:
446 typedef _Tp value_type;
447 typedef const _Tp& result_type;
448private:
449 const value_type& __t_;
450 size_t __s_;
451public:
452 _LIBCPP_ALWAYS_INLINE
453 explicit __scalar_expr(const value_type& __t, size_t __s) : __t_(__t), __s_(__s) {}
454
455 _LIBCPP_ALWAYS_INLINE
456 result_type operator[](size_t) const {return __t_;}
457
458 _LIBCPP_ALWAYS_INLINE
459 size_t size() const {return __s_;}
460};
461
462template <class _Tp>
463struct __unary_plus : unary_function<_Tp, _Tp>
464{
465 _LIBCPP_ALWAYS_INLINE
466 _Tp operator()(const _Tp& __x) const
467 {return +__x;}
468};
469
470template <class _Tp>
471struct __bit_not : unary_function<_Tp, _Tp>
472{
473 _LIBCPP_ALWAYS_INLINE
474 _Tp operator()(const _Tp& __x) const
475 {return ~__x;}
476};
477
478template <class _Tp>
479struct __bit_shift_left : binary_function<_Tp, _Tp, _Tp>
480{
481 _LIBCPP_ALWAYS_INLINE
482 _Tp operator()(const _Tp& __x, const _Tp& __y) const
483 {return __x << __y;}
484};
485
486template <class _Tp>
487struct __bit_shift_right : binary_function<_Tp, _Tp, _Tp>
488{
489 _LIBCPP_ALWAYS_INLINE
490 _Tp operator()(const _Tp& __x, const _Tp& __y) const
491 {return __x >> __y;}
492};
493
494template <class _Tp, class _F>
495struct __apply_expr : unary_function<_Tp, _Tp>
496{
497private:
498 _F __f_;
499public:
500 _LIBCPP_ALWAYS_INLINE
501 explicit __apply_expr(_F __f) : __f_(__f) {}
502
503 _LIBCPP_ALWAYS_INLINE
504 _Tp operator()(const _Tp& __x) const
505 {return __f_(__x);}
506};
507
508template <class _Tp>
509struct __abs_expr : unary_function<_Tp, _Tp>
510{
511 _LIBCPP_ALWAYS_INLINE
512 _Tp operator()(const _Tp& __x) const
513 {return abs(__x);}
514};
515
516template <class _Tp>
517struct __acos_expr : unary_function<_Tp, _Tp>
518{
519 _LIBCPP_ALWAYS_INLINE
520 _Tp operator()(const _Tp& __x) const
521 {return acos(__x);}
522};
523
524template <class _Tp>
525struct __asin_expr : unary_function<_Tp, _Tp>
526{
527 _LIBCPP_ALWAYS_INLINE
528 _Tp operator()(const _Tp& __x) const
529 {return asin(__x);}
530};
531
532template <class _Tp>
533struct __atan_expr : unary_function<_Tp, _Tp>
534{
535 _LIBCPP_ALWAYS_INLINE
536 _Tp operator()(const _Tp& __x) const
537 {return atan(__x);}
538};
539
540template <class _Tp>
541struct __atan2_expr : binary_function<_Tp, _Tp, _Tp>
542{
543 _LIBCPP_ALWAYS_INLINE
544 _Tp operator()(const _Tp& __x, const _Tp& __y) const
545 {return atan2(__x, __y);}
546};
547
548template <class _Tp>
549struct __cos_expr : unary_function<_Tp, _Tp>
550{
551 _LIBCPP_ALWAYS_INLINE
552 _Tp operator()(const _Tp& __x) const
553 {return cos(__x);}
554};
555
556template <class _Tp>
557struct __cosh_expr : unary_function<_Tp, _Tp>
558{
559 _LIBCPP_ALWAYS_INLINE
560 _Tp operator()(const _Tp& __x) const
561 {return cosh(__x);}
562};
563
564template <class _Tp>
565struct __exp_expr : unary_function<_Tp, _Tp>
566{
567 _LIBCPP_ALWAYS_INLINE
568 _Tp operator()(const _Tp& __x) const
569 {return exp(__x);}
570};
571
572template <class _Tp>
573struct __log_expr : unary_function<_Tp, _Tp>
574{
575 _LIBCPP_ALWAYS_INLINE
576 _Tp operator()(const _Tp& __x) const
577 {return log(__x);}
578};
579
580template <class _Tp>
581struct __log10_expr : unary_function<_Tp, _Tp>
582{
583 _LIBCPP_ALWAYS_INLINE
584 _Tp operator()(const _Tp& __x) const
585 {return log10(__x);}
586};
587
588template <class _Tp>
589struct __pow_expr : binary_function<_Tp, _Tp, _Tp>
590{
591 _LIBCPP_ALWAYS_INLINE
592 _Tp operator()(const _Tp& __x, const _Tp& __y) const
593 {return pow(__x, __y);}
594};
595
596template <class _Tp>
597struct __sin_expr : unary_function<_Tp, _Tp>
598{
599 _LIBCPP_ALWAYS_INLINE
600 _Tp operator()(const _Tp& __x) const
601 {return sin(__x);}
602};
603
604template <class _Tp>
605struct __sinh_expr : unary_function<_Tp, _Tp>
606{
607 _LIBCPP_ALWAYS_INLINE
608 _Tp operator()(const _Tp& __x) const
609 {return sinh(__x);}
610};
611
612template <class _Tp>
613struct __sqrt_expr : unary_function<_Tp, _Tp>
614{
615 _LIBCPP_ALWAYS_INLINE
616 _Tp operator()(const _Tp& __x) const
617 {return sqrt(__x);}
618};
619
620template <class _Tp>
621struct __tan_expr : unary_function<_Tp, _Tp>
622{
623 _LIBCPP_ALWAYS_INLINE
624 _Tp operator()(const _Tp& __x) const
625 {return tan(__x);}
626};
627
628template <class _Tp>
629struct __tanh_expr : unary_function<_Tp, _Tp>
630{
631 _LIBCPP_ALWAYS_INLINE
632 _Tp operator()(const _Tp& __x) const
633 {return tanh(__x);}
634};
635
636template <class _ValExpr>
637class __slice_expr
638{
639 typedef typename remove_reference<_ValExpr>::type _RmExpr;
640public:
641 typedef typename _RmExpr::value_type value_type;
642 typedef value_type result_type;
643
644private:
645 _ValExpr __expr_;
646 size_t __start_;
647 size_t __size_;
648 size_t __stride_;
649
650 _LIBCPP_ALWAYS_INLINE
651 __slice_expr(const slice& __sl, const _RmExpr& __e)
652 : __expr_(__e),
653 __start_(__sl.start()),
654 __size_(__sl.size()),
655 __stride_(__sl.stride())
656 {}
657public:
658
659 _LIBCPP_ALWAYS_INLINE
660 result_type operator[](size_t __i) const
661 {return __expr_[__start_ + __i * __stride_];}
662
663 _LIBCPP_ALWAYS_INLINE
664 size_t size() const {return __size_;}
665
666 template <class> friend class valarray;
667};
668
669template <class _ValExpr>
670class __mask_expr;
671
672template <class _ValExpr>
673class __indirect_expr;
674
675template <class _ValExpr>
676class __shift_expr
677{
678 typedef typename remove_reference<_ValExpr>::type _RmExpr;
679public:
680 typedef typename _RmExpr::value_type value_type;
681 typedef value_type result_type;
682
683private:
684 _ValExpr __expr_;
685 size_t __size_;
686 ptrdiff_t __ul_;
687 ptrdiff_t __sn_;
688 ptrdiff_t __n_;
689 static const ptrdiff_t _N = static_cast<ptrdiff_t>(
690 sizeof(ptrdiff_t) * __CHAR_BIT__ - 1);
691
692 _LIBCPP_ALWAYS_INLINE
693 __shift_expr(int __n, const _RmExpr& __e)
694 : __expr_(__e),
695 __size_(__e.size()),
696 __n_(__n)
697 {
698 ptrdiff_t __neg_n = static_cast<ptrdiff_t>(__n_ >> _N);
699 __sn_ = __neg_n | static_cast<ptrdiff_t>(static_cast<size_t>(-__n_) >> _N);
700 __ul_ = ((__size_ - __n_) & ~__neg_n) | ((__n_ + 1) & __neg_n);
701 }
702public:
703
704 _LIBCPP_ALWAYS_INLINE
705 result_type operator[](size_t __j) const
706 {
707 ptrdiff_t __i = static_cast<size_t>(__j);
708 ptrdiff_t __m = (__sn_ * __i - __ul_) >> _N;
709 return (__expr_[(__i + __n_) & __m] & __m) | (value_type() & ~__m);
710 }
711
712 _LIBCPP_ALWAYS_INLINE
713 size_t size() const {return __size_;}
714
715 template <class> friend class __val_expr;
716};
717
718template <class _ValExpr>
719class __cshift_expr
720{
721 typedef typename remove_reference<_ValExpr>::type _RmExpr;
722public:
723 typedef typename _RmExpr::value_type value_type;
724 typedef value_type result_type;
725
726private:
727 _ValExpr __expr_;
728 size_t __size_;
729 size_t __m_;
730 size_t __o1_;
731 size_t __o2_;
732
733 _LIBCPP_ALWAYS_INLINE
734 __cshift_expr(int __n, const _RmExpr& __e)
735 : __expr_(__e),
736 __size_(__e.size())
737 {
738 __n %= static_cast<int>(__size_);
739 if (__n >= 0)
740 {
741 __m_ = __size_ - __n;
742 __o1_ = __n;
743 __o2_ = __n - __size_;
744 }
745 else
746 {
747 __m_ = -__n;
748 __o1_ = __n + __size_;
749 __o2_ = __n;
750 }
751 }
752public:
753
754 _LIBCPP_ALWAYS_INLINE
755 result_type operator[](size_t __i) const
756 {
757 if (__i < __m_)
758 return __expr_[__i + __o1_];
759 return __expr_[__i + __o2_];
760 }
761
762 _LIBCPP_ALWAYS_INLINE
763 size_t size() const {return __size_;}
764
765 template <class> friend class __val_expr;
766};
767
768template<class _ValExpr>
769class __val_expr;
770
771template<class _ValExpr>
772struct __is_val_expr : false_type {};
773
774template<class _ValExpr>
775struct __is_val_expr<__val_expr<_ValExpr> > : true_type {};
776
777template<class _Tp>
778struct __is_val_expr<valarray<_Tp> > : true_type {};
779
780template<class _Tp>
781class valarray
782{
783public:
784 typedef _Tp value_type;
785 typedef _Tp result_type;
786
787private:
788 value_type* __begin_;
789 value_type* __end_;
790
791public:
792 // construct/destroy:
793 valarray() : __begin_(0), __end_(0) {}
794 explicit valarray(size_t __n);
795 valarray(const value_type& __x, size_t __n);
796 valarray(const value_type* __p, size_t __n);
797 valarray(const valarray& __v);
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]798#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]799 valarray(valarray&& __v);
800 valarray(initializer_list<value_type> __il);
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]801#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]802 valarray(const slice_array<value_type>& __sa);
803 valarray(const gslice_array<value_type>& __ga);
804 valarray(const mask_array<value_type>& __ma);
805 valarray(const indirect_array<value_type>& __ia);
806 ~valarray();
807
808 // assignment:
809 valarray& operator=(const valarray& __v);
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]810#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]811 valarray& operator=(valarray&& __v);
812 valarray& operator=(initializer_list<value_type>);
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]813#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]814 valarray& operator=(const value_type& __x);
815 valarray& operator=(const slice_array<value_type>& __sa);
816 valarray& operator=(const gslice_array<value_type>& __ga);
817 valarray& operator=(const mask_array<value_type>& __ma);
818 valarray& operator=(const indirect_array<value_type>& __ia);
819
820 // element access:
821 _LIBCPP_ALWAYS_INLINE
822 const value_type& operator[](size_t __i) const {return __begin_[__i];}
823
824 _LIBCPP_ALWAYS_INLINE
825 value_type& operator[](size_t __i) {return __begin_[__i];}
826
827 // subset operations:
828 __val_expr<__slice_expr<const valarray&> > operator[](slice __s) const;
829 slice_array<value_type> operator[](slice __s);
830 __val_expr<__indirect_expr<const valarray&> > operator[](const gslice& __gs) const;
831 gslice_array<value_type> operator[](const gslice& __gs);
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]832#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]833 __val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const;
834 gslice_array<value_type> operator[](gslice&& __gs);
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]835#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]836 __val_expr<__mask_expr<const valarray&> > operator[](const valarray<bool>& __vb) const;
837 mask_array<value_type> operator[](const valarray<bool>& __vb);
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]838#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]839 __val_expr<__mask_expr<const valarray&> > operator[](valarray<bool>&& __vb) const;
840 mask_array<value_type> operator[](valarray<bool>&& __vb);
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]841#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]842 __val_expr<__indirect_expr<const valarray&> > operator[](const valarray<size_t>& __vs) const;
843 indirect_array<value_type> operator[](const valarray<size_t>& __vs);
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]844#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]845 __val_expr<__indirect_expr<const valarray&> > operator[](valarray<size_t>&& __vs) const;
846 indirect_array<value_type> operator[](valarray<size_t>&& __vs);
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]847#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]848
849 // unary operators:
850 valarray operator+() const;
851 valarray operator-() const;
852 valarray operator~() const;
853 valarray<bool> operator!() const;
854
855 // computed assignment:
856 valarray& operator*= (const value_type& __x);
857 valarray& operator/= (const value_type& __x);
858 valarray& operator%= (const value_type& __x);
859 valarray& operator+= (const value_type& __x);
860 valarray& operator-= (const value_type& __x);
861 valarray& operator^= (const value_type& __x);
862 valarray& operator&= (const value_type& __x);
863 valarray& operator|= (const value_type& __x);
864 valarray& operator<<=(const value_type& __x);
865 valarray& operator>>=(const value_type& __x);
866
867 template <class _Expr>
868 typename enable_if
869 <
870 __is_val_expr<_Expr>::value,
871 valarray&
872 >::type
873 operator*= (const _Expr& __v);
874
875 template <class _Expr>
876 typename enable_if
877 <
878 __is_val_expr<_Expr>::value,
879 valarray&
880 >::type
881 operator/= (const _Expr& __v);
882
883 template <class _Expr>
884 typename enable_if
885 <
886 __is_val_expr<_Expr>::value,
887 valarray&
888 >::type
889 operator%= (const _Expr& __v);
890
891 template <class _Expr>
892 typename enable_if
893 <
894 __is_val_expr<_Expr>::value,
895 valarray&
896 >::type
897 operator+= (const _Expr& __v);
898
899 template <class _Expr>
900 typename enable_if
901 <
902 __is_val_expr<_Expr>::value,
903 valarray&
904 >::type
905 operator-= (const _Expr& __v);
906
907 template <class _Expr>
908 typename enable_if
909 <
910 __is_val_expr<_Expr>::value,
911 valarray&
912 >::type
913 operator^= (const _Expr& __v);
914
915 template <class _Expr>
916 typename enable_if
917 <
918 __is_val_expr<_Expr>::value,
919 valarray&
920 >::type
921 operator|= (const _Expr& __v);
922
923 template <class _Expr>
924 typename enable_if
925 <
926 __is_val_expr<_Expr>::value,
927 valarray&
928 >::type
929 operator&= (const _Expr& __v);
930
931 template <class _Expr>
932 typename enable_if
933 <
934 __is_val_expr<_Expr>::value,
935 valarray&
936 >::type
937 operator<<= (const _Expr& __v);
938
939 template <class _Expr>
940 typename enable_if
941 <
942 __is_val_expr<_Expr>::value,
943 valarray&
944 >::type
945 operator>>= (const _Expr& __v);
946
947 // member functions:
948 void swap(valarray& __v);
949
950 _LIBCPP_ALWAYS_INLINE
951 size_t size() const {return __end_ - __begin_;}
952
953 value_type sum() const;
954 value_type min() const;
955 value_type max() const;
956
957 valarray shift (int __i) const;
958 valarray cshift(int __i) const;
959 valarray apply(value_type __f(value_type)) const;
960 valarray apply(value_type __f(const value_type&)) const;
961 void resize(size_t __n, value_type __x = value_type());
962
963private:
964 template <class> friend class valarray;
965 template <class> friend class slice_array;
966 template <class> friend class gslice_array;
967 template <class> friend class mask_array;
968 template <class> friend class __mask_expr;
969 template <class> friend class indirect_array;
970 template <class> friend class __indirect_expr;
971 template <class> friend class __val_expr;
972
973 template <class _Up>
974 friend
975 _Up*
976 begin(valarray<_Up>& __v);
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]977
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]978 template <class _Up>
979 friend
980 const _Up*
981 begin(const valarray<_Up>& __v);
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]982
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]983 template <class _Up>
984 friend
985 _Up*
986 end(valarray<_Up>& __v);
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]987
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]988 template <class _Up>
989 friend
990 const _Up*
991 end(const valarray<_Up>& __v);
992};
993
994template <class _Op, class _Tp>
995struct _UnaryOp<_Op, valarray<_Tp> >
996{
997 typedef typename _Op::result_type result_type;
998 typedef _Tp value_type;
999
1000 _Op __op_;
1001 const valarray<_Tp>& __a0_;
1002
1003 _LIBCPP_ALWAYS_INLINE
1004 _UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {}
1005
1006 _LIBCPP_ALWAYS_INLINE
1007 result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}
1008
1009 _LIBCPP_ALWAYS_INLINE
1010 size_t size() const {return __a0_.size();}
1011};
1012
1013template <class _Op, class _Tp, class _A1>
1014struct _BinaryOp<_Op, valarray<_Tp>, _A1>
1015{
1016 typedef typename _Op::result_type result_type;
1017 typedef _Tp value_type;
1018
1019 _Op __op_;
1020 const valarray<_Tp>& __a0_;
1021 _A1 __a1_;
1022
1023 _LIBCPP_ALWAYS_INLINE
1024 _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1)
1025 : __op_(__op), __a0_(__a0), __a1_(__a1) {}
1026
1027 _LIBCPP_ALWAYS_INLINE
1028 value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
1029
1030 _LIBCPP_ALWAYS_INLINE
1031 size_t size() const {return __a0_.size();}
1032};
1033
1034template <class _Op, class _A0, class _Tp>
1035struct _BinaryOp<_Op, _A0, valarray<_Tp> >
1036{
1037 typedef typename _Op::result_type result_type;
1038 typedef _Tp value_type;
1039
1040 _Op __op_;
1041 _A0 __a0_;
1042 const valarray<_Tp>& __a1_;
1043
1044 _LIBCPP_ALWAYS_INLINE
1045 _BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1)
1046 : __op_(__op), __a0_(__a0), __a1_(__a1) {}
1047
1048 _LIBCPP_ALWAYS_INLINE
1049 value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
1050
1051 _LIBCPP_ALWAYS_INLINE
1052 size_t size() const {return __a0_.size();}
1053};
1054
1055template <class _Op, class _Tp>
1056struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> >
1057{
1058 typedef typename _Op::result_type result_type;
1059 typedef _Tp value_type;
1060
1061 _Op __op_;
1062 const valarray<_Tp>& __a0_;
1063 const valarray<_Tp>& __a1_;
1064
1065 _LIBCPP_ALWAYS_INLINE
1066 _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1)
1067 : __op_(__op), __a0_(__a0), __a1_(__a1) {}
1068
1069 _LIBCPP_ALWAYS_INLINE
1070 value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
1071
1072 _LIBCPP_ALWAYS_INLINE
1073 size_t size() const {return __a0_.size();}
1074};
1075
1076// slice_array
1077
1078template <class _Tp>
1079class slice_array
1080{
1081public:
1082 typedef _Tp value_type;
1083
1084private:
1085 value_type* __vp_;
1086 size_t __size_;
1087 size_t __stride_;
1088
1089public:
1090 template <class _Expr>
1091 typename enable_if
1092 <
1093 __is_val_expr<_Expr>::value,
1094 void
1095 >::type
1096 operator=(const _Expr& __v) const;
1097
1098 template <class _Expr>
1099 typename enable_if
1100 <
1101 __is_val_expr<_Expr>::value,
1102 void
1103 >::type
1104 operator*=(const _Expr& __v) const;
1105
1106 template <class _Expr>
1107 typename enable_if
1108 <
1109 __is_val_expr<_Expr>::value,
1110 void
1111 >::type
1112 operator/=(const _Expr& __v) const;
1113
1114 template <class _Expr>
1115 typename enable_if
1116 <
1117 __is_val_expr<_Expr>::value,
1118 void
1119 >::type
1120 operator%=(const _Expr& __v) const;
1121
1122 template <class _Expr>
1123 typename enable_if
1124 <
1125 __is_val_expr<_Expr>::value,
1126 void
1127 >::type
1128 operator+=(const _Expr& __v) const;
1129
1130 template <class _Expr>
1131 typename enable_if
1132 <
1133 __is_val_expr<_Expr>::value,
1134 void
1135 >::type
1136 operator-=(const _Expr& __v) const;
1137
1138 template <class _Expr>
1139 typename enable_if
1140 <
1141 __is_val_expr<_Expr>::value,
1142 void
1143 >::type
1144 operator^=(const _Expr& __v) const;
1145
1146 template <class _Expr>
1147 typename enable_if
1148 <
1149 __is_val_expr<_Expr>::value,
1150 void
1151 >::type
1152 operator&=(const _Expr& __v) const;
1153
1154 template <class _Expr>
1155 typename enable_if
1156 <
1157 __is_val_expr<_Expr>::value,
1158 void
1159 >::type
1160 operator|=(const _Expr& __v) const;
1161
1162 template <class _Expr>
1163 typename enable_if
1164 <
1165 __is_val_expr<_Expr>::value,
1166 void
1167 >::type
1168 operator<<=(const _Expr& __v) const;
1169
1170 template <class _Expr>
1171 typename enable_if
1172 <
1173 __is_val_expr<_Expr>::value,
1174 void
1175 >::type
1176 operator>>=(const _Expr& __v) const;
1177
1178 const slice_array& operator=(const slice_array& __sa) const;
1179
1180 void operator=(const value_type& __x) const;
1181
1182private:
1183 slice_array(const slice& __sl, const valarray<value_type>& __v)
1184 : __vp_(const_cast<value_type*>(__v.__begin_ + __sl.start())),
1185 __size_(__sl.size()),
1186 __stride_(__sl.stride())
1187 {}
1188
1189 template <class> friend class valarray;
1190 template <class> friend class sliceExpr;
1191};
1192
1193template <class _Tp>
1194inline _LIBCPP_ALWAYS_INLINE
1195const slice_array<_Tp>&
1196slice_array<_Tp>::operator=(const slice_array& __sa) const
1197{
1198 value_type* __t = __vp_;
1199 const value_type* __s = __sa.__vp_;
1200 for (size_t __n = __size_; __n; --__n, __t += __stride_, __s += __sa.__stride_)
1201 *__t = *__s;
1202}
1203
1204template <class _Tp>
1205template <class _Expr>
1206inline _LIBCPP_ALWAYS_INLINE
1207typename enable_if
1208<
1209 __is_val_expr<_Expr>::value,
1210 void
1211>::type
1212slice_array<_Tp>::operator=(const _Expr& __v) const
1213{
1214 value_type* __t = __vp_;
1215 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
1216 *__t = __v[__i];
1217}
1218
1219template <class _Tp>
1220template <class _Expr>
1221inline _LIBCPP_ALWAYS_INLINE
1222typename enable_if
1223<
1224 __is_val_expr<_Expr>::value,
1225 void
1226>::type
1227slice_array<_Tp>::operator*=(const _Expr& __v) const
1228{
1229 value_type* __t = __vp_;
1230 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
1231 *__t *= __v[__i];
1232}
1233
1234template <class _Tp>
1235template <class _Expr>
1236inline _LIBCPP_ALWAYS_INLINE
1237typename enable_if
1238<
1239 __is_val_expr<_Expr>::value,
1240 void
1241>::type
1242slice_array<_Tp>::operator/=(const _Expr& __v) const
1243{
1244 value_type* __t = __vp_;
1245 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
1246 *__t /= __v[__i];
1247}
1248
1249template <class _Tp>
1250template <class _Expr>
1251inline _LIBCPP_ALWAYS_INLINE
1252typename enable_if
1253<
1254 __is_val_expr<_Expr>::value,
1255 void
1256>::type
1257slice_array<_Tp>::operator%=(const _Expr& __v) const
1258{
1259 value_type* __t = __vp_;
1260 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
1261 *__t %= __v[__i];
1262}
1263
1264template <class _Tp>
1265template <class _Expr>
1266inline _LIBCPP_ALWAYS_INLINE
1267typename enable_if
1268<
1269 __is_val_expr<_Expr>::value,
1270 void
1271>::type
1272slice_array<_Tp>::operator+=(const _Expr& __v) const
1273{
1274 value_type* __t = __vp_;
1275 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
1276 *__t += __v[__i];
1277}
1278
1279template <class _Tp>
1280template <class _Expr>
1281inline _LIBCPP_ALWAYS_INLINE
1282typename enable_if
1283<
1284 __is_val_expr<_Expr>::value,
1285 void
1286>::type
1287slice_array<_Tp>::operator-=(const _Expr& __v) const
1288{
1289 value_type* __t = __vp_;
1290 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
1291 *__t -= __v[__i];
1292}
1293
1294template <class _Tp>
1295template <class _Expr>
1296inline _LIBCPP_ALWAYS_INLINE
1297typename enable_if
1298<
1299 __is_val_expr<_Expr>::value,
1300 void
1301>::type
1302slice_array<_Tp>::operator^=(const _Expr& __v) const
1303{
1304 value_type* __t = __vp_;
1305 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
1306 *__t ^= __v[__i];
1307}
1308
1309template <class _Tp>
1310template <class _Expr>
1311inline _LIBCPP_ALWAYS_INLINE
1312typename enable_if
1313<
1314 __is_val_expr<_Expr>::value,
1315 void
1316>::type
1317slice_array<_Tp>::operator&=(const _Expr& __v) const
1318{
1319 value_type* __t = __vp_;
1320 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
1321 *__t &= __v[__i];
1322}
1323
1324template <class _Tp>
1325template <class _Expr>
1326inline _LIBCPP_ALWAYS_INLINE
1327typename enable_if
1328<
1329 __is_val_expr<_Expr>::value,
1330 void
1331>::type
1332slice_array<_Tp>::operator|=(const _Expr& __v) const
1333{
1334 value_type* __t = __vp_;
1335 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
1336 *__t |= __v[__i];
1337}
1338
1339template <class _Tp>
1340template <class _Expr>
1341inline _LIBCPP_ALWAYS_INLINE
1342typename enable_if
1343<
1344 __is_val_expr<_Expr>::value,
1345 void
1346>::type
1347slice_array<_Tp>::operator<<=(const _Expr& __v) const
1348{
1349 value_type* __t = __vp_;
1350 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
1351 *__t <<= __v[__i];
1352}
1353
1354template <class _Tp>
1355template <class _Expr>
1356inline _LIBCPP_ALWAYS_INLINE
1357typename enable_if
1358<
1359 __is_val_expr<_Expr>::value,
1360 void
1361>::type
1362slice_array<_Tp>::operator>>=(const _Expr& __v) const
1363{
1364 value_type* __t = __vp_;
1365 for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
1366 *__t >>= __v[__i];
1367}
1368
1369template <class _Tp>
1370inline _LIBCPP_ALWAYS_INLINE
1371void
1372slice_array<_Tp>::operator=(const value_type& __x) const
1373{
1374 value_type* __t = __vp_;
1375 for (size_t __n = __size_; __n; --__n, __t += __stride_)
1376 *__t = __x;
1377}
1378
1379// gslice
1380
1381class gslice
1382{
1383 valarray<size_t> __size_;
1384 valarray<size_t> __stride_;
1385 valarray<size_t> __1d_;
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]1386
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]1387public:
1388 _LIBCPP_ALWAYS_INLINE
1389 gslice() {}
1390
1391 _LIBCPP_ALWAYS_INLINE
1392 gslice(size_t __start, const valarray<size_t>& __size,
1393 const valarray<size_t>& __stride)
1394 : __size_(__size),
1395 __stride_(__stride)
1396 {__init(__start);}
1397
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]1398#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]1399
1400 _LIBCPP_ALWAYS_INLINE
1401 gslice(size_t __start, const valarray<size_t>& __size,
1402 valarray<size_t>&& __stride)
1403 : __size_(__size),
1404 __stride_(move(__stride))
1405 {__init(__start);}
1406
1407 _LIBCPP_ALWAYS_INLINE
1408 gslice(size_t __start, valarray<size_t>&& __size,
1409 const valarray<size_t>& __stride)
1410 : __size_(move(__size)),
1411 __stride_(__stride)
1412 {__init(__start);}
1413
1414 _LIBCPP_ALWAYS_INLINE
1415 gslice(size_t __start, valarray<size_t>&& __size,
1416 valarray<size_t>&& __stride)
1417 : __size_(move(__size)),
1418 __stride_(move(__stride))
1419 {__init(__start);}
1420
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]1421#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]1422
1423// gslice(const gslice&) = default;
1424// gslice(gslice&&) = default;
1425// gslice& operator=(const gslice&) = default;
1426// gslice& operator=(gslice&&) = default;
1427
1428 _LIBCPP_ALWAYS_INLINE
1429 size_t start() const {return __1d_.size() ? __1d_[0] : 0;}
1430
1431 _LIBCPP_ALWAYS_INLINE
1432 valarray<size_t> size() const {return __size_;}
1433
1434 _LIBCPP_ALWAYS_INLINE
1435 valarray<size_t> stride() const {return __stride_;}
1436
1437private:
1438 void __init(size_t __start);
1439
1440 template <class> friend class gslice_array;
1441 template <class> friend class valarray;
1442 template <class> friend class __val_expr;
1443};
1444
1445// gslice_array
1446
1447template <class _Tp>
1448class gslice_array
1449{
1450public:
1451 typedef _Tp value_type;
1452
1453private:
1454 value_type* __vp_;
1455 valarray<size_t> __1d_;
1456
1457public:
1458 template <class _Expr>
1459 typename enable_if
1460 <
1461 __is_val_expr<_Expr>::value,
1462 void
1463 >::type
1464 operator=(const _Expr& __v) const;
1465
1466 template <class _Expr>
1467 typename enable_if
1468 <
1469 __is_val_expr<_Expr>::value,
1470 void
1471 >::type
1472 operator*=(const _Expr& __v) const;
1473
1474 template <class _Expr>
1475 typename enable_if
1476 <
1477 __is_val_expr<_Expr>::value,
1478 void
1479 >::type
1480 operator/=(const _Expr& __v) const;
1481
1482 template <class _Expr>
1483 typename enable_if
1484 <
1485 __is_val_expr<_Expr>::value,
1486 void
1487 >::type
1488 operator%=(const _Expr& __v) const;
1489
1490 template <class _Expr>
1491 typename enable_if
1492 <
1493 __is_val_expr<_Expr>::value,
1494 void
1495 >::type
1496 operator+=(const _Expr& __v) const;
1497
1498 template <class _Expr>
1499 typename enable_if
1500 <
1501 __is_val_expr<_Expr>::value,
1502 void
1503 >::type
1504 operator-=(const _Expr& __v) const;
1505
1506 template <class _Expr>
1507 typename enable_if
1508 <
1509 __is_val_expr<_Expr>::value,
1510 void
1511 >::type
1512 operator^=(const _Expr& __v) const;
1513
1514 template <class _Expr>
1515 typename enable_if
1516 <
1517 __is_val_expr<_Expr>::value,
1518 void
1519 >::type
1520 operator&=(const _Expr& __v) const;
1521
1522 template <class _Expr>
1523 typename enable_if
1524 <
1525 __is_val_expr<_Expr>::value,
1526 void
1527 >::type
1528 operator|=(const _Expr& __v) const;
1529
1530 template <class _Expr>
1531 typename enable_if
1532 <
1533 __is_val_expr<_Expr>::value,
1534 void
1535 >::type
1536 operator<<=(const _Expr& __v) const;
1537
1538 template <class _Expr>
1539 typename enable_if
1540 <
1541 __is_val_expr<_Expr>::value,
1542 void
1543 >::type
1544 operator>>=(const _Expr& __v) const;
1545
1546 const gslice_array& operator=(const gslice_array& __ga) const;
1547
1548 void operator=(const value_type& __x) const;
1549
1550// gslice_array(const gslice_array&) = default;
1551// gslice_array(gslice_array&&) = default;
1552// gslice_array& operator=(const gslice_array&) = default;
1553// gslice_array& operator=(gslice_array&&) = default;
1554
1555private:
1556 _LIBCPP_ALWAYS_INLINE
1557 gslice_array(const gslice& __gs, const valarray<value_type>& __v)
1558 : __vp_(const_cast<value_type*>(__v.__begin_)),
1559 __1d_(__gs.__1d_)
1560 {}
1561
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]1562#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]1563
1564 _LIBCPP_ALWAYS_INLINE
1565 gslice_array(gslice&& __gs, const valarray<value_type>& __v)
1566 : __vp_(const_cast<value_type*>(__v.__begin_)),
1567 __1d_(move(__gs.__1d_))
1568 {}
1569
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]1570#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]1571
1572 template <class> friend class valarray;
1573};
1574
1575template <class _Tp>
1576template <class _Expr>
1577inline _LIBCPP_ALWAYS_INLINE
1578typename enable_if
1579<
1580 __is_val_expr<_Expr>::value,
1581 void
1582>::type
1583gslice_array<_Tp>::operator=(const _Expr& __v) const
1584{
1585 typedef const size_t* _Ip;
1586 size_t __j = 0;
1587 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1588 __vp_[*__i] = __v[__j];
1589}
1590
1591template <class _Tp>
1592template <class _Expr>
1593inline _LIBCPP_ALWAYS_INLINE
1594typename enable_if
1595<
1596 __is_val_expr<_Expr>::value,
1597 void
1598>::type
1599gslice_array<_Tp>::operator*=(const _Expr& __v) const
1600{
1601 typedef const size_t* _Ip;
1602 size_t __j = 0;
1603 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1604 __vp_[*__i] *= __v[__j];
1605}
1606
1607template <class _Tp>
1608template <class _Expr>
1609inline _LIBCPP_ALWAYS_INLINE
1610typename enable_if
1611<
1612 __is_val_expr<_Expr>::value,
1613 void
1614>::type
1615gslice_array<_Tp>::operator/=(const _Expr& __v) const
1616{
1617 typedef const size_t* _Ip;
1618 size_t __j = 0;
1619 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1620 __vp_[*__i] /= __v[__j];
1621}
1622
1623template <class _Tp>
1624template <class _Expr>
1625inline _LIBCPP_ALWAYS_INLINE
1626typename enable_if
1627<
1628 __is_val_expr<_Expr>::value,
1629 void
1630>::type
1631gslice_array<_Tp>::operator%=(const _Expr& __v) const
1632{
1633 typedef const size_t* _Ip;
1634 size_t __j = 0;
1635 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1636 __vp_[*__i] %= __v[__j];
1637}
1638
1639template <class _Tp>
1640template <class _Expr>
1641inline _LIBCPP_ALWAYS_INLINE
1642typename enable_if
1643<
1644 __is_val_expr<_Expr>::value,
1645 void
1646>::type
1647gslice_array<_Tp>::operator+=(const _Expr& __v) const
1648{
1649 typedef const size_t* _Ip;
1650 size_t __j = 0;
1651 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1652 __vp_[*__i] += __v[__j];
1653}
1654
1655template <class _Tp>
1656template <class _Expr>
1657inline _LIBCPP_ALWAYS_INLINE
1658typename enable_if
1659<
1660 __is_val_expr<_Expr>::value,
1661 void
1662>::type
1663gslice_array<_Tp>::operator-=(const _Expr& __v) const
1664{
1665 typedef const size_t* _Ip;
1666 size_t __j = 0;
1667 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1668 __vp_[*__i] -= __v[__j];
1669}
1670
1671template <class _Tp>
1672template <class _Expr>
1673inline _LIBCPP_ALWAYS_INLINE
1674typename enable_if
1675<
1676 __is_val_expr<_Expr>::value,
1677 void
1678>::type
1679gslice_array<_Tp>::operator^=(const _Expr& __v) const
1680{
1681 typedef const size_t* _Ip;
1682 size_t __j = 0;
1683 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1684 __vp_[*__i] ^= __v[__j];
1685}
1686
1687template <class _Tp>
1688template <class _Expr>
1689inline _LIBCPP_ALWAYS_INLINE
1690typename enable_if
1691<
1692 __is_val_expr<_Expr>::value,
1693 void
1694>::type
1695gslice_array<_Tp>::operator&=(const _Expr& __v) const
1696{
1697 typedef const size_t* _Ip;
1698 size_t __j = 0;
1699 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1700 __vp_[*__i] &= __v[__j];
1701}
1702
1703template <class _Tp>
1704template <class _Expr>
1705inline _LIBCPP_ALWAYS_INLINE
1706typename enable_if
1707<
1708 __is_val_expr<_Expr>::value,
1709 void
1710>::type
1711gslice_array<_Tp>::operator|=(const _Expr& __v) const
1712{
1713 typedef const size_t* _Ip;
1714 size_t __j = 0;
1715 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1716 __vp_[*__i] |= __v[__j];
1717}
1718
1719template <class _Tp>
1720template <class _Expr>
1721inline _LIBCPP_ALWAYS_INLINE
1722typename enable_if
1723<
1724 __is_val_expr<_Expr>::value,
1725 void
1726>::type
1727gslice_array<_Tp>::operator<<=(const _Expr& __v) const
1728{
1729 typedef const size_t* _Ip;
1730 size_t __j = 0;
1731 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1732 __vp_[*__i] <<= __v[__j];
1733}
1734
1735template <class _Tp>
1736template <class _Expr>
1737inline _LIBCPP_ALWAYS_INLINE
1738typename enable_if
1739<
1740 __is_val_expr<_Expr>::value,
1741 void
1742>::type
1743gslice_array<_Tp>::operator>>=(const _Expr& __v) const
1744{
1745 typedef const size_t* _Ip;
1746 size_t __j = 0;
1747 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1748 __vp_[*__i] >>= __v[__j];
1749}
1750
1751template <class _Tp>
1752inline _LIBCPP_ALWAYS_INLINE
1753const gslice_array<_Tp>&
1754gslice_array<_Tp>::operator=(const gslice_array& __ga) const
1755{
1756 typedef const size_t* _Ip;
1757 const value_type* __s = __ga.__vp_;
1758 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ga.__1d_.__begin_;
1759 __i != __e; ++__i, ++__j)
1760 __vp_[*__i] = __s[*__j];
1761 return *this;
1762}
1763
1764template <class _Tp>
1765inline _LIBCPP_ALWAYS_INLINE
1766void
1767gslice_array<_Tp>::operator=(const value_type& __x) const
1768{
1769 typedef const size_t* _Ip;
1770 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
1771 __vp_[*__i] = __x;
1772}
1773
1774// mask_array
1775
1776template <class _Tp>
1777class mask_array
1778{
1779public:
1780 typedef _Tp value_type;
1781
1782private:
1783 value_type* __vp_;
1784 valarray<size_t> __1d_;
1785
1786public:
1787 template <class _Expr>
1788 typename enable_if
1789 <
1790 __is_val_expr<_Expr>::value,
1791 void
1792 >::type
1793 operator=(const _Expr& __v) const;
1794
1795 template <class _Expr>
1796 typename enable_if
1797 <
1798 __is_val_expr<_Expr>::value,
1799 void
1800 >::type
1801 operator*=(const _Expr& __v) const;
1802
1803 template <class _Expr>
1804 typename enable_if
1805 <
1806 __is_val_expr<_Expr>::value,
1807 void
1808 >::type
1809 operator/=(const _Expr& __v) const;
1810
1811 template <class _Expr>
1812 typename enable_if
1813 <
1814 __is_val_expr<_Expr>::value,
1815 void
1816 >::type
1817 operator%=(const _Expr& __v) const;
1818
1819 template <class _Expr>
1820 typename enable_if
1821 <
1822 __is_val_expr<_Expr>::value,
1823 void
1824 >::type
1825 operator+=(const _Expr& __v) const;
1826
1827 template <class _Expr>
1828 typename enable_if
1829 <
1830 __is_val_expr<_Expr>::value,
1831 void
1832 >::type
1833 operator-=(const _Expr& __v) const;
1834
1835 template <class _Expr>
1836 typename enable_if
1837 <
1838 __is_val_expr<_Expr>::value,
1839 void
1840 >::type
1841 operator^=(const _Expr& __v) const;
1842
1843 template <class _Expr>
1844 typename enable_if
1845 <
1846 __is_val_expr<_Expr>::value,
1847 void
1848 >::type
1849 operator&=(const _Expr& __v) const;
1850
1851 template <class _Expr>
1852 typename enable_if
1853 <
1854 __is_val_expr<_Expr>::value,
1855 void
1856 >::type
1857 operator|=(const _Expr& __v) const;
1858
1859 template <class _Expr>
1860 typename enable_if
1861 <
1862 __is_val_expr<_Expr>::value,
1863 void
1864 >::type
1865 operator<<=(const _Expr& __v) const;
1866
1867 template <class _Expr>
1868 typename enable_if
1869 <
1870 __is_val_expr<_Expr>::value,
1871 void
1872 >::type
1873 operator>>=(const _Expr& __v) const;
1874
1875 const mask_array& operator=(const mask_array& __ma) const;
1876
1877 void operator=(const value_type& __x) const;
1878
1879// mask_array(const mask_array&) = default;
1880// mask_array(mask_array&&) = default;
1881// mask_array& operator=(const mask_array&) = default;
1882// mask_array& operator=(mask_array&&) = default;
1883
1884private:
1885 _LIBCPP_ALWAYS_INLINE
1886 mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v)
1887 : __vp_(const_cast<value_type*>(__v.__begin_)),
1888 __1d_(count(__vb.__begin_, __vb.__end_, true))
1889 {
1890 size_t __j = 0;
1891 for (size_t __i = 0; __i < __vb.size(); ++__i)
1892 if (__vb[__i])
1893 __1d_[__j++] = __i;
1894 }
1895
1896 template <class> friend class valarray;
1897};
1898
1899template <class _Tp>
1900template <class _Expr>
1901inline _LIBCPP_ALWAYS_INLINE
1902typename enable_if
1903<
1904 __is_val_expr<_Expr>::value,
1905 void
1906>::type
1907mask_array<_Tp>::operator=(const _Expr& __v) const
1908{
1909 size_t __n = __1d_.size();
1910 for (size_t __i = 0; __i < __n; ++__i)
1911 __vp_[__1d_[__i]] = __v[__i];
1912}
1913
1914template <class _Tp>
1915template <class _Expr>
1916inline _LIBCPP_ALWAYS_INLINE
1917typename enable_if
1918<
1919 __is_val_expr<_Expr>::value,
1920 void
1921>::type
1922mask_array<_Tp>::operator*=(const _Expr& __v) const
1923{
1924 size_t __n = __1d_.size();
1925 for (size_t __i = 0; __i < __n; ++__i)
1926 __vp_[__1d_[__i]] *= __v[__i];
1927}
1928
1929template <class _Tp>
1930template <class _Expr>
1931inline _LIBCPP_ALWAYS_INLINE
1932typename enable_if
1933<
1934 __is_val_expr<_Expr>::value,
1935 void
1936>::type
1937mask_array<_Tp>::operator/=(const _Expr& __v) const
1938{
1939 size_t __n = __1d_.size();
1940 for (size_t __i = 0; __i < __n; ++__i)
1941 __vp_[__1d_[__i]] /= __v[__i];
1942}
1943
1944template <class _Tp>
1945template <class _Expr>
1946inline _LIBCPP_ALWAYS_INLINE
1947typename enable_if
1948<
1949 __is_val_expr<_Expr>::value,
1950 void
1951>::type
1952mask_array<_Tp>::operator%=(const _Expr& __v) const
1953{
1954 size_t __n = __1d_.size();
1955 for (size_t __i = 0; __i < __n; ++__i)
1956 __vp_[__1d_[__i]] %= __v[__i];
1957}
1958
1959template <class _Tp>
1960template <class _Expr>
1961inline _LIBCPP_ALWAYS_INLINE
1962typename enable_if
1963<
1964 __is_val_expr<_Expr>::value,
1965 void
1966>::type
1967mask_array<_Tp>::operator+=(const _Expr& __v) const
1968{
1969 size_t __n = __1d_.size();
1970 for (size_t __i = 0; __i < __n; ++__i)
1971 __vp_[__1d_[__i]] += __v[__i];
1972}
1973
1974template <class _Tp>
1975template <class _Expr>
1976inline _LIBCPP_ALWAYS_INLINE
1977typename enable_if
1978<
1979 __is_val_expr<_Expr>::value,
1980 void
1981>::type
1982mask_array<_Tp>::operator-=(const _Expr& __v) const
1983{
1984 size_t __n = __1d_.size();
1985 for (size_t __i = 0; __i < __n; ++__i)
1986 __vp_[__1d_[__i]] -= __v[__i];
1987}
1988
1989template <class _Tp>
1990template <class _Expr>
1991inline _LIBCPP_ALWAYS_INLINE
1992typename enable_if
1993<
1994 __is_val_expr<_Expr>::value,
1995 void
1996>::type
1997mask_array<_Tp>::operator^=(const _Expr& __v) const
1998{
1999 size_t __n = __1d_.size();
2000 for (size_t __i = 0; __i < __n; ++__i)
2001 __vp_[__1d_[__i]] ^= __v[__i];
2002}
2003
2004template <class _Tp>
2005template <class _Expr>
2006inline _LIBCPP_ALWAYS_INLINE
2007typename enable_if
2008<
2009 __is_val_expr<_Expr>::value,
2010 void
2011>::type
2012mask_array<_Tp>::operator&=(const _Expr& __v) const
2013{
2014 size_t __n = __1d_.size();
2015 for (size_t __i = 0; __i < __n; ++__i)
2016 __vp_[__1d_[__i]] &= __v[__i];
2017}
2018
2019template <class _Tp>
2020template <class _Expr>
2021inline _LIBCPP_ALWAYS_INLINE
2022typename enable_if
2023<
2024 __is_val_expr<_Expr>::value,
2025 void
2026>::type
2027mask_array<_Tp>::operator|=(const _Expr& __v) const
2028{
2029 size_t __n = __1d_.size();
2030 for (size_t __i = 0; __i < __n; ++__i)
2031 __vp_[__1d_[__i]] |= __v[__i];
2032}
2033
2034template <class _Tp>
2035template <class _Expr>
2036inline _LIBCPP_ALWAYS_INLINE
2037typename enable_if
2038<
2039 __is_val_expr<_Expr>::value,
2040 void
2041>::type
2042mask_array<_Tp>::operator<<=(const _Expr& __v) const
2043{
2044 size_t __n = __1d_.size();
2045 for (size_t __i = 0; __i < __n; ++__i)
2046 __vp_[__1d_[__i]] <<= __v[__i];
2047}
2048
2049template <class _Tp>
2050template <class _Expr>
2051inline _LIBCPP_ALWAYS_INLINE
2052typename enable_if
2053<
2054 __is_val_expr<_Expr>::value,
2055 void
2056>::type
2057mask_array<_Tp>::operator>>=(const _Expr& __v) const
2058{
2059 size_t __n = __1d_.size();
2060 for (size_t __i = 0; __i < __n; ++__i)
2061 __vp_[__1d_[__i]] >>= __v[__i];
2062}
2063
2064template <class _Tp>
2065inline _LIBCPP_ALWAYS_INLINE
2066const mask_array<_Tp>&
2067mask_array<_Tp>::operator=(const mask_array& __ma) const
2068{
2069 size_t __n = __1d_.size();
2070 for (size_t __i = 0; __i < __n; ++__i)
2071 __vp_[__1d_[__i]] = __ma.__vp_[__1d_[__i]];
2072}
2073
2074template <class _Tp>
2075inline _LIBCPP_ALWAYS_INLINE
2076void
2077mask_array<_Tp>::operator=(const value_type& __x) const
2078{
2079 size_t __n = __1d_.size();
2080 for (size_t __i = 0; __i < __n; ++__i)
2081 __vp_[__1d_[__i]] = __x;
2082}
2083
2084template <class _ValExpr>
2085class __mask_expr
2086{
2087 typedef typename remove_reference<_ValExpr>::type _RmExpr;
2088public:
2089 typedef typename _RmExpr::value_type value_type;
2090 typedef value_type result_type;
2091
2092private:
2093 _ValExpr __expr_;
2094 valarray<size_t> __1d_;
2095
2096 _LIBCPP_ALWAYS_INLINE
2097 __mask_expr(const valarray<bool>& __vb, const _RmExpr& __e)
2098 : __expr_(__e),
2099 __1d_(count(__vb.__begin_, __vb.__end_, true))
2100 {
2101 size_t __j = 0;
2102 for (size_t __i = 0; __i < __vb.size(); ++__i)
2103 if (__vb[__i])
2104 __1d_[__j++] = __i;
2105 }
2106
2107public:
2108 _LIBCPP_ALWAYS_INLINE
2109 result_type operator[](size_t __i) const
2110 {return __expr_[__1d_[__i]];}
2111
2112 _LIBCPP_ALWAYS_INLINE
2113 size_t size() const {return __1d_.size();}
2114
2115 template <class> friend class valarray;
2116};
2117
2118// indirect_array
2119
2120template <class _Tp>
2121class indirect_array
2122{
2123public:
2124 typedef _Tp value_type;
2125
2126private:
2127 value_type* __vp_;
2128 valarray<size_t> __1d_;
2129
2130public:
2131 template <class _Expr>
2132 typename enable_if
2133 <
2134 __is_val_expr<_Expr>::value,
2135 void
2136 >::type
2137 operator=(const _Expr& __v) const;
2138
2139 template <class _Expr>
2140 typename enable_if
2141 <
2142 __is_val_expr<_Expr>::value,
2143 void
2144 >::type
2145 operator*=(const _Expr& __v) const;
2146
2147 template <class _Expr>
2148 typename enable_if
2149 <
2150 __is_val_expr<_Expr>::value,
2151 void
2152 >::type
2153 operator/=(const _Expr& __v) const;
2154
2155 template <class _Expr>
2156 typename enable_if
2157 <
2158 __is_val_expr<_Expr>::value,
2159 void
2160 >::type
2161 operator%=(const _Expr& __v) const;
2162
2163 template <class _Expr>
2164 typename enable_if
2165 <
2166 __is_val_expr<_Expr>::value,
2167 void
2168 >::type
2169 operator+=(const _Expr& __v) const;
2170
2171 template <class _Expr>
2172 typename enable_if
2173 <
2174 __is_val_expr<_Expr>::value,
2175 void
2176 >::type
2177 operator-=(const _Expr& __v) const;
2178
2179 template <class _Expr>
2180 typename enable_if
2181 <
2182 __is_val_expr<_Expr>::value,
2183 void
2184 >::type
2185 operator^=(const _Expr& __v) const;
2186
2187 template <class _Expr>
2188 typename enable_if
2189 <
2190 __is_val_expr<_Expr>::value,
2191 void
2192 >::type
2193 operator&=(const _Expr& __v) const;
2194
2195 template <class _Expr>
2196 typename enable_if
2197 <
2198 __is_val_expr<_Expr>::value,
2199 void
2200 >::type
2201 operator|=(const _Expr& __v) const;
2202
2203 template <class _Expr>
2204 typename enable_if
2205 <
2206 __is_val_expr<_Expr>::value,
2207 void
2208 >::type
2209 operator<<=(const _Expr& __v) const;
2210
2211 template <class _Expr>
2212 typename enable_if
2213 <
2214 __is_val_expr<_Expr>::value,
2215 void
2216 >::type
2217 operator>>=(const _Expr& __v) const;
2218
2219 const indirect_array& operator=(const indirect_array& __ia) const;
2220
2221 void operator=(const value_type& __x) const;
2222
2223// indirect_array(const indirect_array&) = default;
2224// indirect_array(indirect_array&&) = default;
2225// indirect_array& operator=(const indirect_array&) = default;
2226// indirect_array& operator=(indirect_array&&) = default;
2227
2228private:
2229 _LIBCPP_ALWAYS_INLINE
2230 indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v)
2231 : __vp_(const_cast<value_type*>(__v.__begin_)),
2232 __1d_(__ia)
2233 {}
2234
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]2235#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2236
2237 _LIBCPP_ALWAYS_INLINE
2238 indirect_array(valarray<size_t>&& __ia, const valarray<value_type>& __v)
2239 : __vp_(const_cast<value_type*>(__v.__begin_)),
2240 __1d_(move(__ia))
2241 {}
2242
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]2243#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2244
2245 template <class> friend class valarray;
2246};
2247
2248template <class _Tp>
2249template <class _Expr>
2250inline _LIBCPP_ALWAYS_INLINE
2251typename enable_if
2252<
2253 __is_val_expr<_Expr>::value,
2254 void
2255>::type
2256indirect_array<_Tp>::operator=(const _Expr& __v) const
2257{
2258 size_t __n = __1d_.size();
2259 for (size_t __i = 0; __i < __n; ++__i)
2260 __vp_[__1d_[__i]] = __v[__i];
2261}
2262
2263template <class _Tp>
2264template <class _Expr>
2265inline _LIBCPP_ALWAYS_INLINE
2266typename enable_if
2267<
2268 __is_val_expr<_Expr>::value,
2269 void
2270>::type
2271indirect_array<_Tp>::operator*=(const _Expr& __v) const
2272{
2273 size_t __n = __1d_.size();
2274 for (size_t __i = 0; __i < __n; ++__i)
2275 __vp_[__1d_[__i]] *= __v[__i];
2276}
2277
2278template <class _Tp>
2279template <class _Expr>
2280inline _LIBCPP_ALWAYS_INLINE
2281typename enable_if
2282<
2283 __is_val_expr<_Expr>::value,
2284 void
2285>::type
2286indirect_array<_Tp>::operator/=(const _Expr& __v) const
2287{
2288 size_t __n = __1d_.size();
2289 for (size_t __i = 0; __i < __n; ++__i)
2290 __vp_[__1d_[__i]] /= __v[__i];
2291}
2292
2293template <class _Tp>
2294template <class _Expr>
2295inline _LIBCPP_ALWAYS_INLINE
2296typename enable_if
2297<
2298 __is_val_expr<_Expr>::value,
2299 void
2300>::type
2301indirect_array<_Tp>::operator%=(const _Expr& __v) const
2302{
2303 size_t __n = __1d_.size();
2304 for (size_t __i = 0; __i < __n; ++__i)
2305 __vp_[__1d_[__i]] %= __v[__i];
2306}
2307
2308template <class _Tp>
2309template <class _Expr>
2310inline _LIBCPP_ALWAYS_INLINE
2311typename enable_if
2312<
2313 __is_val_expr<_Expr>::value,
2314 void
2315>::type
2316indirect_array<_Tp>::operator+=(const _Expr& __v) const
2317{
2318 size_t __n = __1d_.size();
2319 for (size_t __i = 0; __i < __n; ++__i)
2320 __vp_[__1d_[__i]] += __v[__i];
2321}
2322
2323template <class _Tp>
2324template <class _Expr>
2325inline _LIBCPP_ALWAYS_INLINE
2326typename enable_if
2327<
2328 __is_val_expr<_Expr>::value,
2329 void
2330>::type
2331indirect_array<_Tp>::operator-=(const _Expr& __v) const
2332{
2333 size_t __n = __1d_.size();
2334 for (size_t __i = 0; __i < __n; ++__i)
2335 __vp_[__1d_[__i]] -= __v[__i];
2336}
2337
2338template <class _Tp>
2339template <class _Expr>
2340inline _LIBCPP_ALWAYS_INLINE
2341typename enable_if
2342<
2343 __is_val_expr<_Expr>::value,
2344 void
2345>::type
2346indirect_array<_Tp>::operator^=(const _Expr& __v) const
2347{
2348 size_t __n = __1d_.size();
2349 for (size_t __i = 0; __i < __n; ++__i)
2350 __vp_[__1d_[__i]] ^= __v[__i];
2351}
2352
2353template <class _Tp>
2354template <class _Expr>
2355inline _LIBCPP_ALWAYS_INLINE
2356typename enable_if
2357<
2358 __is_val_expr<_Expr>::value,
2359 void
2360>::type
2361indirect_array<_Tp>::operator&=(const _Expr& __v) const
2362{
2363 size_t __n = __1d_.size();
2364 for (size_t __i = 0; __i < __n; ++__i)
2365 __vp_[__1d_[__i]] &= __v[__i];
2366}
2367
2368template <class _Tp>
2369template <class _Expr>
2370inline _LIBCPP_ALWAYS_INLINE
2371typename enable_if
2372<
2373 __is_val_expr<_Expr>::value,
2374 void
2375>::type
2376indirect_array<_Tp>::operator|=(const _Expr& __v) const
2377{
2378 size_t __n = __1d_.size();
2379 for (size_t __i = 0; __i < __n; ++__i)
2380 __vp_[__1d_[__i]] |= __v[__i];
2381}
2382
2383template <class _Tp>
2384template <class _Expr>
2385inline _LIBCPP_ALWAYS_INLINE
2386typename enable_if
2387<
2388 __is_val_expr<_Expr>::value,
2389 void
2390>::type
2391indirect_array<_Tp>::operator<<=(const _Expr& __v) const
2392{
2393 size_t __n = __1d_.size();
2394 for (size_t __i = 0; __i < __n; ++__i)
2395 __vp_[__1d_[__i]] <<= __v[__i];
2396}
2397
2398template <class _Tp>
2399template <class _Expr>
2400inline _LIBCPP_ALWAYS_INLINE
2401typename enable_if
2402<
2403 __is_val_expr<_Expr>::value,
2404 void
2405>::type
2406indirect_array<_Tp>::operator>>=(const _Expr& __v) const
2407{
2408 size_t __n = __1d_.size();
2409 for (size_t __i = 0; __i < __n; ++__i)
2410 __vp_[__1d_[__i]] >>= __v[__i];
2411}
2412
2413template <class _Tp>
2414inline _LIBCPP_ALWAYS_INLINE
2415const indirect_array<_Tp>&
2416indirect_array<_Tp>::operator=(const indirect_array& __ia) const
2417{
2418 typedef const size_t* _Ip;
2419 const value_type* __s = __ia.__vp_;
2420 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ia.__1d_.__begin_;
2421 __i != __e; ++__i, ++__j)
2422 __vp_[*__i] = __s[*__j];
2423 return *this;
2424}
2425
2426template <class _Tp>
2427inline _LIBCPP_ALWAYS_INLINE
2428void
2429indirect_array<_Tp>::operator=(const value_type& __x) const
2430{
2431 typedef const size_t* _Ip;
2432 for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
2433 __vp_[*__i] = __x;
2434}
2435
2436template <class _ValExpr>
2437class __indirect_expr
2438{
2439 typedef typename remove_reference<_ValExpr>::type _RmExpr;
2440public:
2441 typedef typename _RmExpr::value_type value_type;
2442 typedef value_type result_type;
2443
2444private:
2445 _ValExpr __expr_;
2446 valarray<size_t> __1d_;
2447
2448 __indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e)
2449 : __expr_(__e),
2450 __1d_(__ia)
2451 {}
2452
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]2453#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2454
2455 __indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e)
2456 : __expr_(__e),
2457 __1d_(move(__ia))
2458 {}
2459
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]2460#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2461
2462public:
2463 _LIBCPP_ALWAYS_INLINE
2464 result_type operator[](size_t __i) const
2465 {return __expr_[__1d_[__i]];}
2466
2467 _LIBCPP_ALWAYS_INLINE
2468 size_t size() const {return __1d_.size();}
2469
2470 template <class> friend class valarray;
2471};
2472
2473template<class _ValExpr>
2474class __val_expr
2475{
2476 typedef typename remove_reference<_ValExpr>::type _RmExpr;
2477
2478 _ValExpr __expr_;
2479public:
2480 typedef typename _RmExpr::value_type value_type;
2481 typedef typename _RmExpr::result_type result_type;
2482
2483 _LIBCPP_ALWAYS_INLINE
2484 explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {}
2485
2486 _LIBCPP_ALWAYS_INLINE
2487 result_type operator[](size_t __i) const
2488 {return __expr_[__i];}
2489
2490 _LIBCPP_ALWAYS_INLINE
2491 __val_expr<__slice_expr<_ValExpr> > operator[](slice __s) const
2492 {return __val_expr<__slice_expr<_ValExpr> >(__expr_, __s);}
2493
2494 _LIBCPP_ALWAYS_INLINE
2495 __val_expr<__indirect_expr<_ValExpr> > operator[](const gslice& __gs) const
2496 {return __val_expr<__indirect_expr<_ValExpr> >(__expr_, __gs.__1d_);}
2497
2498 _LIBCPP_ALWAYS_INLINE
2499 __val_expr<__mask_expr<_ValExpr> > operator[](const valarray<bool>& __vb) const
2500 {return __val_expr<__mask_expr<_ValExpr> >(__expr_, __vb);}
2501
2502 _LIBCPP_ALWAYS_INLINE
2503 __val_expr<__indirect_expr<_ValExpr> > operator[](const valarray<size_t>& __vs) const
2504 {return __val_expr<__indirect_expr<_ValExpr> >(__expr_, __vs);}
2505
2506 _LIBCPP_ALWAYS_INLINE
2507 __val_expr<_UnaryOp<__unary_plus<value_type>, _ValExpr> >
2508 operator+() const
2509 {
2510 typedef _UnaryOp<__unary_plus<value_type>, _ValExpr> _NewExpr;
2511 return __val_expr<_NewExpr>(_NewExpr(__unary_plus<value_type>(), __expr_));
2512 }
2513
2514 _LIBCPP_ALWAYS_INLINE
2515 __val_expr<_UnaryOp<negate<value_type>, _ValExpr> >
2516 operator-() const
2517 {
2518 typedef _UnaryOp<negate<value_type>, _ValExpr> _NewExpr;
2519 return __val_expr<_NewExpr>(_NewExpr(negate<value_type>(), __expr_));
2520 }
2521
2522 _LIBCPP_ALWAYS_INLINE
2523 __val_expr<_UnaryOp<__bit_not<value_type>, _ValExpr> >
2524 operator~() const
2525 {
2526 typedef _UnaryOp<__bit_not<value_type>, _ValExpr> _NewExpr;
2527 return __val_expr<_NewExpr>(_NewExpr(__bit_not<value_type>(), __expr_));
2528 }
2529
2530 _LIBCPP_ALWAYS_INLINE
2531 __val_expr<_UnaryOp<logical_not<value_type>, _ValExpr> >
2532 operator!() const
2533 {
2534 typedef _UnaryOp<logical_not<value_type>, _ValExpr> _NewExpr;
2535 return __val_expr<_NewExpr>(_NewExpr(logical_not<value_type>(), __expr_));
2536 }
2537
2538 operator valarray<result_type>() const;
2539
2540 _LIBCPP_ALWAYS_INLINE
2541 size_t size() const {return __expr_.size();}
2542
2543 _LIBCPP_ALWAYS_INLINE
2544 result_type sum() const
2545 {
2546 size_t __n = __expr_.size();
2547 result_type __r = __n ? __expr_[0] : result_type();
2548 for (size_t __i = 1; __i < __n; ++__i)
2549 __r += __expr_[__i];
2550 return __r;
2551 }
2552
2553 _LIBCPP_ALWAYS_INLINE
2554 result_type min() const
2555 {
2556 size_t __n = size();
2557 result_type __r = __n ? (*this)[0] : result_type();
2558 for (size_t __i = 1; __i < __n; ++__i)
2559 {
2560 result_type __x = __expr_[__i];
2561 if (__x < __r)
2562 __r = __x;
2563 }
2564 return __r;
2565 }
2566
2567 _LIBCPP_ALWAYS_INLINE
2568 result_type max() const
2569 {
2570 size_t __n = size();
2571 result_type __r = __n ? (*this)[0] : result_type();
2572 for (size_t __i = 1; __i < __n; ++__i)
2573 {
2574 result_type __x = __expr_[__i];
2575 if (__r < __x)
2576 __r = __x;
2577 }
2578 return __r;
2579 }
2580
2581 _LIBCPP_ALWAYS_INLINE
2582 __val_expr<__shift_expr<_ValExpr> > shift (int __i) const
2583 {return __val_expr<__shift_expr<_ValExpr> >(__shift_expr<_ValExpr>(__i, __expr_));}
2584
2585 _LIBCPP_ALWAYS_INLINE
2586 __val_expr<__cshift_expr<_ValExpr> > cshift(int __i) const
2587 {return __val_expr<__cshift_expr<_ValExpr> >(__cshift_expr<_ValExpr>(__i, __expr_));}
2588
2589 _LIBCPP_ALWAYS_INLINE
2590 __val_expr<_UnaryOp<__apply_expr<value_type, value_type(*)(value_type)>, _ValExpr> >
2591 apply(value_type __f(value_type)) const
2592 {
2593 typedef __apply_expr<value_type, value_type(*)(value_type)> _Op;
2594 typedef _UnaryOp<_Op, _ValExpr> _NewExpr;
2595 return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_));
2596 }
2597
2598 _LIBCPP_ALWAYS_INLINE
2599 __val_expr<_UnaryOp<__apply_expr<value_type, value_type(*)(const value_type&)>, _ValExpr> >
2600 apply(value_type __f(const value_type&)) const
2601 {
2602 typedef __apply_expr<value_type, value_type(*)(const value_type&)> _Op;
2603 typedef _UnaryOp<_Op, _ValExpr> _NewExpr;
2604 return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_));
2605 }
2606};
2607
2608template<class _ValExpr>
2609__val_expr<_ValExpr>::operator valarray<result_type>() const
2610{
2611 valarray<result_type> __r;
2612 size_t __n = __expr_.size();
2613 if (__n)
2614 {
2615 __r.__begin_ =
2616 __r.__end_ =
2617 static_cast<result_type*>(::operator new(__n * sizeof(result_type)));
2618 for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i)
2619 ::new (__r.__end_) result_type(__expr_[__i]);
2620 }
2621 return __r;
2622}
2623
2624// valarray
2625
2626template <class _Tp>
2627inline _LIBCPP_ALWAYS_INLINE
2628valarray<_Tp>::valarray(size_t __n)
2629 : __begin_(0),
2630 __end_(0)
2631{
2632 resize(__n);
2633}
2634
2635template <class _Tp>
2636inline _LIBCPP_ALWAYS_INLINE
2637valarray<_Tp>::valarray(const value_type& __x, size_t __n)
2638 : __begin_(0),
2639 __end_(0)
2640{
2641 resize(__n, __x);
2642}
2643
2644template <class _Tp>
2645valarray<_Tp>::valarray(const value_type* __p, size_t __n)
2646 : __begin_(0),
2647 __end_(0)
2648{
2649 if (__n)
2650 {
2651 __begin_ = __end_ = static_cast<value_type*>(::operator new(__n * sizeof(value_type)));
2652#ifndef _LIBCPP_NO_EXCEPTIONS
2653 try
2654 {
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]2655#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2656 for (; __n; ++__end_, ++__p, --__n)
2657 ::new (__end_) value_type(*__p);
2658#ifndef _LIBCPP_NO_EXCEPTIONS
2659 }
2660 catch (...)
2661 {
2662 resize(0);
2663 throw;
2664 }
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]2665#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2666 }
2667}
2668
2669template <class _Tp>
2670valarray<_Tp>::valarray(const valarray& __v)
2671 : __begin_(0),
2672 __end_(0)
2673{
2674 if (__v.size())
2675 {
2676 __begin_ = __end_ = static_cast<value_type*>(::operator new(__v.size() * sizeof(value_type)));
2677#ifndef _LIBCPP_NO_EXCEPTIONS
2678 try
2679 {
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]2680#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2681 for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p)
2682 ::new (__end_) value_type(*__p);
2683#ifndef _LIBCPP_NO_EXCEPTIONS
2684 }
2685 catch (...)
2686 {
2687 resize(0);
2688 throw;
2689 }
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]2690#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2691 }
2692}
2693
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]2694#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2695
2696template <class _Tp>
2697inline _LIBCPP_ALWAYS_INLINE
2698valarray<_Tp>::valarray(valarray&& __v)
2699 : __begin_(__v.__begin_),
2700 __end_(__v.__end_)
2701{
2702 __v.__begin_ = __v.__end_ = nullptr;
2703}
2704
2705template <class _Tp>
2706valarray<_Tp>::valarray(initializer_list<value_type> __il)
2707 : __begin_(0),
2708 __end_(0)
2709{
2710 size_t __n = __il.size();
2711 if (__n)
2712 {
2713 __begin_ = __end_ = static_cast<value_type*>(::operator new(__n * sizeof(value_type)));
2714#ifndef _LIBCPP_NO_EXCEPTIONS
2715 try
2716 {
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]2717#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2718 for (const value_type* __p = __il.begin(); __n; ++__end_, ++__p, --__n)
2719 ::new (__end_) value_type(*__p);
2720#ifndef _LIBCPP_NO_EXCEPTIONS
2721 }
2722 catch (...)
2723 {
2724 resize(0);
2725 throw;
2726 }
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]2727#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2728 }
2729}
2730
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]2731#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2732
2733template <class _Tp>
2734valarray<_Tp>::valarray(const slice_array<value_type>& __sa)
2735 : __begin_(0),
2736 __end_(0)
2737{
2738 size_t __n = __sa.__size_;
2739 if (__n)
2740 {
2741 __begin_ = __end_ = static_cast<value_type*>(::operator new(__n * sizeof(value_type)));
2742#ifndef _LIBCPP_NO_EXCEPTIONS
2743 try
2744 {
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]2745#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2746 for (const value_type* __p = __sa.__vp_; __n; ++__end_, __p += __sa.__stride_, --__n)
2747 ::new (__end_) value_type(*__p);
2748#ifndef _LIBCPP_NO_EXCEPTIONS
2749 }
2750 catch (...)
2751 {
2752 resize(0);
2753 throw;
2754 }
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]2755#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2756 }
2757}
2758
2759template <class _Tp>
2760valarray<_Tp>::valarray(const gslice_array<value_type>& __ga)
2761 : __begin_(0),
2762 __end_(0)
2763{
2764 size_t __n = __ga.__1d_.size();
2765 if (__n)
2766 {
2767 __begin_ = __end_ = static_cast<value_type*>(::operator new(__n * sizeof(value_type)));
2768#ifndef _LIBCPP_NO_EXCEPTIONS
2769 try
2770 {
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]2771#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2772 typedef const size_t* _Ip;
2773 const value_type* __s = __ga.__vp_;
2774 for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_;
2775 __i != __e; ++__i, ++__end_)
2776 ::new (__end_) value_type(__s[*__i]);
2777#ifndef _LIBCPP_NO_EXCEPTIONS
2778 }
2779 catch (...)
2780 {
2781 resize(0);
2782 throw;
2783 }
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]2784#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2785 }
2786}
2787
2788template <class _Tp>
2789valarray<_Tp>::valarray(const mask_array<value_type>& __ma)
2790 : __begin_(0),
2791 __end_(0)
2792{
2793 size_t __n = __ma.__1d_.size();
2794 if (__n)
2795 {
2796 __begin_ = __end_ = static_cast<value_type*>(::operator new(__n * sizeof(value_type)));
2797#ifndef _LIBCPP_NO_EXCEPTIONS
2798 try
2799 {
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]2800#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2801 typedef const size_t* _Ip;
2802 const value_type* __s = __ma.__vp_;
2803 for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_;
2804 __i != __e; ++__i, ++__end_)
2805 ::new (__end_) value_type(__s[*__i]);
2806#ifndef _LIBCPP_NO_EXCEPTIONS
2807 }
2808 catch (...)
2809 {
2810 resize(0);
2811 throw;
2812 }
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]2813#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2814 }
2815}
2816
2817template <class _Tp>
2818valarray<_Tp>::valarray(const indirect_array<value_type>& __ia)
2819 : __begin_(0),
2820 __end_(0)
2821{
2822 size_t __n = __ia.__1d_.size();
2823 if (__n)
2824 {
2825 __begin_ = __end_ = static_cast<value_type*>(::operator new(__n * sizeof(value_type)));
2826#ifndef _LIBCPP_NO_EXCEPTIONS
2827 try
2828 {
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]2829#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2830 typedef const size_t* _Ip;
2831 const value_type* __s = __ia.__vp_;
2832 for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_;
2833 __i != __e; ++__i, ++__end_)
2834 ::new (__end_) value_type(__s[*__i]);
2835#ifndef _LIBCPP_NO_EXCEPTIONS
2836 }
2837 catch (...)
2838 {
2839 resize(0);
2840 throw;
2841 }
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]2842#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2843 }
2844}
2845
2846template <class _Tp>
2847inline _LIBCPP_ALWAYS_INLINE
2848valarray<_Tp>::~valarray()
2849{
2850 resize(0);
2851}
2852
2853template <class _Tp>
2854valarray<_Tp>&
2855valarray<_Tp>::operator=(const valarray& __v)
2856{
2857 if (this != &__v)
2858 {
2859 if (size() != __v.size())
2860 resize(__v.size());
2861 _STD::copy(__v.__begin_, __v.__end_, __begin_);
2862 }
2863 return *this;
2864}
2865
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]2866#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2867
2868template <class _Tp>
2869inline _LIBCPP_ALWAYS_INLINE
2870valarray<_Tp>&
2871valarray<_Tp>::operator=(valarray&& __v)
2872{
2873 resize(0);
2874 __begin_ = __v.__begin_;
2875 __end_ = __v.__end_;
2876 __v.__begin_ = nullptr;
2877 __v.__end_ = nullptr;
2878 return *this;
2879}
2880
2881template <class _Tp>
2882inline _LIBCPP_ALWAYS_INLINE
2883valarray<_Tp>&
2884valarray<_Tp>::operator=(initializer_list<value_type> __il)
2885{
2886 if (size() != __il.size())
2887 resize(__il.size());
2888 _STD::copy(__il.begin(), __il.end(), __begin_);
2889 return *this;
2890}
2891
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]2892#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2893
2894template <class _Tp>
2895inline _LIBCPP_ALWAYS_INLINE
2896valarray<_Tp>&
2897valarray<_Tp>::operator=(const value_type& __x)
2898{
2899 _STD::fill(__begin_, __end_, __x);
2900 return *this;
2901}
2902
2903template <class _Tp>
2904inline _LIBCPP_ALWAYS_INLINE
2905valarray<_Tp>&
2906valarray<_Tp>::operator=(const slice_array<value_type>& __sa)
2907{
2908 value_type* __t = __begin_;
2909 const value_type* __s = __sa.__vp_;
2910 for (size_t __n = __sa.__size_; __n; --__n, __s += __sa.__stride_, ++__t)
2911 *__t = *__s;
2912 return *this;
2913}
2914
2915template <class _Tp>
2916inline _LIBCPP_ALWAYS_INLINE
2917valarray<_Tp>&
2918valarray<_Tp>::operator=(const gslice_array<value_type>& __ga)
2919{
2920 typedef const size_t* _Ip;
2921 value_type* __t = __begin_;
2922 const value_type* __s = __ga.__vp_;
2923 for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_;
2924 __i != __e; ++__i, ++__t)
2925 *__t = __s[*__i];
2926 return *this;
2927}
2928
2929template <class _Tp>
2930inline _LIBCPP_ALWAYS_INLINE
2931valarray<_Tp>&
2932valarray<_Tp>::operator=(const mask_array<value_type>& __ma)
2933{
2934 typedef const size_t* _Ip;
2935 value_type* __t = __begin_;
2936 const value_type* __s = __ma.__vp_;
2937 for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_;
2938 __i != __e; ++__i, ++__t)
2939 *__t = __s[*__i];
2940 return *this;
2941}
2942
2943template <class _Tp>
2944inline _LIBCPP_ALWAYS_INLINE
2945valarray<_Tp>&
2946valarray<_Tp>::operator=(const indirect_array<value_type>& __ia)
2947{
2948 typedef const size_t* _Ip;
2949 value_type* __t = __begin_;
2950 const value_type* __s = __ia.__vp_;
2951 for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_;
2952 __i != __e; ++__i, ++__t)
2953 *__t = __s[*__i];
2954 return *this;
2955}
2956
2957template <class _Tp>
2958inline _LIBCPP_ALWAYS_INLINE
2959__val_expr<__slice_expr<const valarray<_Tp>&> >
2960valarray<_Tp>::operator[](slice __s) const
2961{
2962 return __val_expr<__slice_expr<const valarray&> >(__slice_expr<const valarray&>(__s, *this));
2963}
2964
2965template <class _Tp>
2966inline _LIBCPP_ALWAYS_INLINE
2967slice_array<_Tp>
2968valarray<_Tp>::operator[](slice __s)
2969{
2970 return slice_array<value_type>(__s, *this);
2971}
2972
2973template <class _Tp>
2974inline _LIBCPP_ALWAYS_INLINE
2975__val_expr<__indirect_expr<const valarray<_Tp>&> >
2976valarray<_Tp>::operator[](const gslice& __gs) const
2977{
2978 return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__gs.__1d_, *this));
2979}
2980
2981template <class _Tp>
2982inline _LIBCPP_ALWAYS_INLINE
2983gslice_array<_Tp>
2984valarray<_Tp>::operator[](const gslice& __gs)
2985{
2986 return gslice_array<value_type>(__gs, *this);
2987}
2988
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]2989#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]2990
2991template <class _Tp>
2992inline _LIBCPP_ALWAYS_INLINE
2993__val_expr<__indirect_expr<const valarray<_Tp>&> >
2994valarray<_Tp>::operator[](gslice&& __gs) const
2995{
2996 return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(move(__gs.__1d_), *this));
2997}
2998
2999template <class _Tp>
3000inline _LIBCPP_ALWAYS_INLINE
3001gslice_array<_Tp>
3002valarray<_Tp>::operator[](gslice&& __gs)
3003{
3004 return gslice_array<value_type>(move(__gs), *this);
3005}
3006
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]3007#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]3008
3009template <class _Tp>
3010inline _LIBCPP_ALWAYS_INLINE
3011__val_expr<__mask_expr<const valarray<_Tp>&> >
3012valarray<_Tp>::operator[](const valarray<bool>& __vb) const
3013{
3014 return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(__vb, *this));
3015}
3016
3017template <class _Tp>
3018inline _LIBCPP_ALWAYS_INLINE
3019mask_array<_Tp>
3020valarray<_Tp>::operator[](const valarray<bool>& __vb)
3021{
3022 return mask_array<value_type>(__vb, *this);
3023}
3024
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]3025#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]3026
3027template <class _Tp>
3028inline _LIBCPP_ALWAYS_INLINE
3029__val_expr<__mask_expr<const valarray<_Tp>&> >
3030valarray<_Tp>::operator[](valarray<bool>&& __vb) const
3031{
3032 return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(move(__vb), *this));
3033}
3034
3035template <class _Tp>
3036inline _LIBCPP_ALWAYS_INLINE
3037mask_array<_Tp>
3038valarray<_Tp>::operator[](valarray<bool>&& __vb)
3039{
3040 return mask_array<value_type>(move(__vb), *this);
3041}
3042
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]3043#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]3044
3045template <class _Tp>
3046inline _LIBCPP_ALWAYS_INLINE
3047__val_expr<__indirect_expr<const valarray<_Tp>&> >
3048valarray<_Tp>::operator[](const valarray<size_t>& __vs) const
3049{
3050 return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__vs, *this));
3051}
3052
3053template <class _Tp>
3054inline _LIBCPP_ALWAYS_INLINE
3055indirect_array<_Tp>
3056valarray<_Tp>::operator[](const valarray<size_t>& __vs)
3057{
3058 return indirect_array<value_type>(__vs, *this);
3059}
3060
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]3061#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]3062
3063template <class _Tp>
3064inline _LIBCPP_ALWAYS_INLINE
3065__val_expr<__indirect_expr<const valarray<_Tp>&> >
3066valarray<_Tp>::operator[](valarray<size_t>&& __vs) const
3067{
3068 return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(move(__vs), *this));
3069}
3070
3071template <class _Tp>
3072inline _LIBCPP_ALWAYS_INLINE
3073indirect_array<_Tp>
3074valarray<_Tp>::operator[](valarray<size_t>&& __vs)
3075{
3076 return indirect_array<value_type>(move(__vs), *this);
3077}
3078
Howard Hinnant73d21a42010-09-04 23:28:19 +0000[diff] [blame^]3079#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]3080
3081template <class _Tp>
3082valarray<_Tp>
3083valarray<_Tp>::operator+() const
3084{
3085 valarray<value_type> __r;
3086 size_t __n = size();
3087 if (__n)
3088 {
3089 __r.__begin_ =
3090 __r.__end_ =
3091 static_cast<value_type*>(::operator new(__n * sizeof(value_type)));
3092 for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
3093 ::new (__r.__end_) value_type(+*__p);
3094 }
3095 return __r;
3096}
3097
3098template <class _Tp>
3099valarray<_Tp>
3100valarray<_Tp>::operator-() const
3101{
3102 valarray<value_type> __r;
3103 size_t __n = size();
3104 if (__n)
3105 {
3106 __r.__begin_ =
3107 __r.__end_ =
3108 static_cast<value_type*>(::operator new(__n * sizeof(value_type)));
3109 for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
3110 ::new (__r.__end_) value_type(-*__p);
3111 }
3112 return __r;
3113}
3114
3115template <class _Tp>
3116valarray<_Tp>
3117valarray<_Tp>::operator~() const
3118{
3119 valarray<value_type> __r;
3120 size_t __n = size();
3121 if (__n)
3122 {
3123 __r.__begin_ =
3124 __r.__end_ =
3125 static_cast<value_type*>(::operator new(__n * sizeof(value_type)));
3126 for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
3127 ::new (__r.__end_) value_type(~*__p);
3128 }
3129 return __r;
3130}
3131
3132template <class _Tp>
3133valarray<bool>
3134valarray<_Tp>::operator!() const
3135{
3136 valarray<bool> __r;
3137 size_t __n = size();
3138 if (__n)
3139 {
3140 __r.__begin_ =
3141 __r.__end_ =
3142 static_cast<bool*>(::operator new(__n * sizeof(bool)));
3143 for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
3144 ::new (__r.__end_) bool(!*__p);
3145 }
3146 return __r;
3147}
3148
3149template <class _Tp>
3150inline _LIBCPP_ALWAYS_INLINE
3151valarray<_Tp>&
3152valarray<_Tp>::operator*=(const value_type& __x)
3153{
3154 for (value_type* __p = __begin_; __p != __end_; ++__p)
3155 *__p *= __x;
3156 return *this;
3157}
3158
3159template <class _Tp>
3160inline _LIBCPP_ALWAYS_INLINE
3161valarray<_Tp>&
3162valarray<_Tp>::operator/=(const value_type& __x)
3163{
3164 for (value_type* __p = __begin_; __p != __end_; ++__p)
3165 *__p /= __x;
3166 return *this;
3167}
3168
3169template <class _Tp>
3170inline _LIBCPP_ALWAYS_INLINE
3171valarray<_Tp>&
3172valarray<_Tp>::operator%=(const value_type& __x)
3173{
3174 for (value_type* __p = __begin_; __p != __end_; ++__p)
3175 *__p %= __x;
3176 return *this;
3177}
3178
3179template <class _Tp>
3180inline _LIBCPP_ALWAYS_INLINE
3181valarray<_Tp>&
3182valarray<_Tp>::operator+=(const value_type& __x)
3183{
3184 for (value_type* __p = __begin_; __p != __end_; ++__p)
3185 *__p += __x;
3186 return *this;
3187}
3188
3189template <class _Tp>
3190inline _LIBCPP_ALWAYS_INLINE
3191valarray<_Tp>&
3192valarray<_Tp>::operator-=(const value_type& __x)
3193{
3194 for (value_type* __p = __begin_; __p != __end_; ++__p)
3195 *__p -= __x;
3196 return *this;
3197}
3198
3199template <class _Tp>
3200inline _LIBCPP_ALWAYS_INLINE
3201valarray<_Tp>&
3202valarray<_Tp>::operator^=(const value_type& __x)
3203{
3204 for (value_type* __p = __begin_; __p != __end_; ++__p)
3205 *__p ^= __x;
3206 return *this;
3207}
3208
3209template <class _Tp>
3210inline _LIBCPP_ALWAYS_INLINE
3211valarray<_Tp>&
3212valarray<_Tp>::operator&=(const value_type& __x)
3213{
3214 for (value_type* __p = __begin_; __p != __end_; ++__p)
3215 *__p &= __x;
3216 return *this;
3217}
3218
3219template <class _Tp>
3220inline _LIBCPP_ALWAYS_INLINE
3221valarray<_Tp>&
3222valarray<_Tp>::operator|=(const value_type& __x)
3223{
3224 for (value_type* __p = __begin_; __p != __end_; ++__p)
3225 *__p |= __x;
3226 return *this;
3227}
3228
3229template <class _Tp>
3230inline _LIBCPP_ALWAYS_INLINE
3231valarray<_Tp>&
3232valarray<_Tp>::operator<<=(const value_type& __x)
3233{
3234 for (value_type* __p = __begin_; __p != __end_; ++__p)
3235 *__p <<= __x;
3236 return *this;
3237}
3238
3239template <class _Tp>
3240inline _LIBCPP_ALWAYS_INLINE
3241valarray<_Tp>&
3242valarray<_Tp>::operator>>=(const value_type& __x)
3243{
3244 for (value_type* __p = __begin_; __p != __end_; ++__p)
3245 *__p >>= __x;
3246 return *this;
3247}
3248
3249template <class _Tp>
3250template <class _Expr>
3251inline _LIBCPP_ALWAYS_INLINE
3252typename enable_if
3253<
3254 __is_val_expr<_Expr>::value,
3255 valarray<_Tp>&
3256>::type
3257valarray<_Tp>::operator*=(const _Expr& __v)
3258{
3259 size_t __i = 0;
3260 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
3261 *__t *= __v[__i];
3262 return *this;
3263}
3264
3265template <class _Tp>
3266template <class _Expr>
3267inline _LIBCPP_ALWAYS_INLINE
3268typename enable_if
3269<
3270 __is_val_expr<_Expr>::value,
3271 valarray<_Tp>&
3272>::type
3273valarray<_Tp>::operator/=(const _Expr& __v)
3274{
3275 size_t __i = 0;
3276 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
3277 *__t /= __v[__i];
3278 return *this;
3279}
3280
3281template <class _Tp>
3282template <class _Expr>
3283inline _LIBCPP_ALWAYS_INLINE
3284typename enable_if
3285<
3286 __is_val_expr<_Expr>::value,
3287 valarray<_Tp>&
3288>::type
3289valarray<_Tp>::operator%=(const _Expr& __v)
3290{
3291 size_t __i = 0;
3292 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
3293 *__t %= __v[__i];
3294 return *this;
3295}
3296
3297template <class _Tp>
3298template <class _Expr>
3299inline _LIBCPP_ALWAYS_INLINE
3300typename enable_if
3301<
3302 __is_val_expr<_Expr>::value,
3303 valarray<_Tp>&
3304>::type
3305valarray<_Tp>::operator+=(const _Expr& __v)
3306{
3307 size_t __i = 0;
3308 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
3309 *__t += __v[__i];
3310 return *this;
3311}
3312
3313template <class _Tp>
3314template <class _Expr>
3315inline _LIBCPP_ALWAYS_INLINE
3316typename enable_if
3317<
3318 __is_val_expr<_Expr>::value,
3319 valarray<_Tp>&
3320>::type
3321valarray<_Tp>::operator-=(const _Expr& __v)
3322{
3323 size_t __i = 0;
3324 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
3325 *__t -= __v[__i];
3326 return *this;
3327}
3328
3329template <class _Tp>
3330template <class _Expr>
3331inline _LIBCPP_ALWAYS_INLINE
3332typename enable_if
3333<
3334 __is_val_expr<_Expr>::value,
3335 valarray<_Tp>&
3336>::type
3337valarray<_Tp>::operator^=(const _Expr& __v)
3338{
3339 size_t __i = 0;
3340 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
3341 *__t ^= __v[__i];
3342 return *this;
3343}
3344
3345template <class _Tp>
3346template <class _Expr>
3347inline _LIBCPP_ALWAYS_INLINE
3348typename enable_if
3349<
3350 __is_val_expr<_Expr>::value,
3351 valarray<_Tp>&
3352>::type
3353valarray<_Tp>::operator|=(const _Expr& __v)
3354{
3355 size_t __i = 0;
3356 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
3357 *__t |= __v[__i];
3358 return *this;
3359}
3360
3361template <class _Tp>
3362template <class _Expr>
3363inline _LIBCPP_ALWAYS_INLINE
3364typename enable_if
3365<
3366 __is_val_expr<_Expr>::value,
3367 valarray<_Tp>&
3368>::type
3369valarray<_Tp>::operator&=(const _Expr& __v)
3370{
3371 size_t __i = 0;
3372 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
3373 *__t &= __v[__i];
3374 return *this;
3375}
3376
3377template <class _Tp>
3378template <class _Expr>
3379inline _LIBCPP_ALWAYS_INLINE
3380typename enable_if
3381<
3382 __is_val_expr<_Expr>::value,
3383 valarray<_Tp>&
3384>::type
3385valarray<_Tp>::operator<<=(const _Expr& __v)
3386{
3387 size_t __i = 0;
3388 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
3389 *__t <<= __v[__i];
3390 return *this;
3391}
3392
3393template <class _Tp>
3394template <class _Expr>
3395inline _LIBCPP_ALWAYS_INLINE
3396typename enable_if
3397<
3398 __is_val_expr<_Expr>::value,
3399 valarray<_Tp>&
3400>::type
3401valarray<_Tp>::operator>>=(const _Expr& __v)
3402{
3403 size_t __i = 0;
3404 for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
3405 *__t >>= __v[__i];
3406 return *this;
3407}
3408
3409template <class _Tp>
3410inline _LIBCPP_ALWAYS_INLINE
3411void
3412valarray<_Tp>::swap(valarray& __v)
3413{
3414 _STD::swap(__begin_, __v.__begin_);
3415 _STD::swap(__end_, __v.__end_);
3416}
3417
3418template <class _Tp>
3419inline _LIBCPP_ALWAYS_INLINE
3420_Tp
3421valarray<_Tp>::sum() const
3422{
3423 if (__begin_ == __end_)
3424 return value_type();
3425 const value_type* __p = __begin_;
3426 _Tp __r = *__p;
3427 for (++__p; __p != __end_; ++__p)
3428 __r += *__p;
3429 return __r;
3430}
3431
3432template <class _Tp>
3433inline _LIBCPP_ALWAYS_INLINE
3434_Tp
3435valarray<_Tp>::min() const
3436{
3437 if (__begin_ == __end_)
3438 return value_type();
3439 return *_STD::min_element(__begin_, __end_);
3440}
3441
3442template <class _Tp>
3443inline _LIBCPP_ALWAYS_INLINE
3444_Tp
3445valarray<_Tp>::max() const
3446{
3447 if (__begin_ == __end_)
3448 return value_type();
3449 return *_STD::max_element(__begin_, __end_);
3450}
3451
3452template <class _Tp>
3453valarray<_Tp>
3454valarray<_Tp>::shift(int __i) const
3455{
3456 valarray<value_type> __r;
3457 size_t __n = size();
3458 if (__n)
3459 {
3460 __r.__begin_ =
3461 __r.__end_ =
3462 static_cast<value_type*>(::operator new(__n * sizeof(value_type)));
3463 const value_type* __sb;
3464 value_type* __tb;
3465 value_type* __te;
3466 if (__i >= 0)
3467 {
3468 __i = _STD::min(__i, static_cast<int>(__n));
3469 __sb = __begin_ + __i;
3470 __tb = __r.__begin_;
3471 __te = __r.__begin_ + (__n - __i);
3472 }
3473 else
3474 {
3475 __i = _STD::min(-__i, static_cast<int>(__n));
3476 __sb = __begin_;
3477 __tb = __r.__begin_ + __i;
3478 __te = __r.__begin_ + __n;
3479 }
3480 for (; __r.__end_ != __tb; ++__r.__end_)
3481 ::new (__r.__end_) value_type();
3482 for (; __r.__end_ != __te; ++__r.__end_, ++__sb)
3483 ::new (__r.__end_) value_type(*__sb);
3484 for (__te = __r.__begin_ + __n; __r.__end_ != __te; ++__r.__end_)
3485 ::new (__r.__end_) value_type();
3486 }
3487 return __r;
3488}
3489
3490template <class _Tp>
3491valarray<_Tp>
3492valarray<_Tp>::cshift(int __i) const
3493{
3494 valarray<value_type> __r;
3495 size_t __n = size();
3496 if (__n)
3497 {
3498 __r.__begin_ =
3499 __r.__end_ =
3500 static_cast<value_type*>(::operator new(__n * sizeof(value_type)));
3501 __i %= static_cast<int>(__n);
3502 const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i;
3503 for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s)
3504 ::new (__r.__end_) value_type(*__s);
3505 for (const value_type* __s = __begin_; __s != __m; ++__r.__end_, ++__s)
3506 ::new (__r.__end_) value_type(*__s);
3507 }
3508 return __r;
3509}
3510
3511template <class _Tp>
3512valarray<_Tp>
3513valarray<_Tp>::apply(value_type __f(value_type)) const
3514{
3515 valarray<value_type> __r;
3516 size_t __n = size();
3517 if (__n)
3518 {
3519 __r.__begin_ =
3520 __r.__end_ =
3521 static_cast<value_type*>(::operator new(__n * sizeof(value_type)));
3522 for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
3523 ::new (__r.__end_) value_type(__f(*__p));
3524 }
3525 return __r;
3526}
3527
3528template <class _Tp>
3529valarray<_Tp>
3530valarray<_Tp>::apply(value_type __f(const value_type&)) const
3531{
3532 valarray<value_type> __r;
3533 size_t __n = size();
3534 if (__n)
3535 {
3536 __r.__begin_ =
3537 __r.__end_ =
3538 static_cast<value_type*>(::operator new(__n * sizeof(value_type)));
3539 for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
3540 ::new (__r.__end_) value_type(__f(*__p));
3541 }
3542 return __r;
3543}
3544
3545template <class _Tp>
3546void
3547valarray<_Tp>::resize(size_t __n, value_type __x)
3548{
3549 if (__begin_ != nullptr)
3550 {
3551 while (__end_ != __begin_)
3552 (--__end_)->~value_type();
3553 ::operator delete(__begin_);
3554 __begin_ = __end_ = nullptr;
3555 }
3556 if (__n)
3557 {
3558 __begin_ = __end_ = static_cast<value_type*>(::operator new(__n * sizeof(value_type)));
3559#ifndef _LIBCPP_NO_EXCEPTIONS
3560 try
3561 {
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]3562#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]3563 for (; __n; --__n, ++__end_)
3564 ::new (__end_) value_type(__x);
3565#ifndef _LIBCPP_NO_EXCEPTIONS
3566 }
3567 catch (...)
3568 {
3569 resize(0);
3570 throw;
3571 }
Howard Hinnant324bb032010-08-22 00:02:43 +0000[diff] [blame]3572#endif // _LIBCPP_NO_EXCEPTIONS
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000[diff] [blame]3573 }
3574}
3575
3576template<class _Tp>
3577inline _LIBCPP_ALWAYS_INLINE
3578void
3579swap(valarray<_Tp>& __x, valarray<_Tp>& __y)
3580{
3581 __x.swap(__y);
3582}
3583
3584template<class _Expr1, class _Expr2>
3585inline _LIBCPP_ALWAYS_INLINE
3586typename enable_if
3587<
3588 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
3589 __val_expr<_BinaryOp<multiplies<typename _Expr1::value_type>, _Expr1, _Expr2> >
3590>::type
3591operator*(const _Expr1& __x, const _Expr2& __y)
3592{
3593 typedef typename _Expr1::value_type value_type;
3594 typedef _BinaryOp<multiplies<value_type>, _Expr1, _Expr2> _Op;
3595 return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __y));
3596}
3597
3598template<class _Expr>
3599inline _LIBCPP_ALWAYS_INLINE
3600typename enable_if
3601<
3602 __is_val_expr<_Expr>::value,
3603 __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>,
3604 _Expr, __scalar_expr<typename _Expr::value_type> > >
3605>::type
3606operator*(const _Expr& __x, const typename _Expr::value_type& __y)
3607{
3608 typedef typename _Expr::value_type value_type;
3609 typedef _BinaryOp<multiplies<value_type>, _Expr, __scalar_expr<value_type> > _Op;
3610 return __val_expr<_Op>(_Op(multiplies<value_type>(),
3611 __x, __scalar_expr<value_type>(__y, __x.size())));
3612}
3613
3614template<class _Expr>
3615inline _LIBCPP_ALWAYS_INLINE
3616typename enable_if
3617<
3618 __is_val_expr<_Expr>::value,
3619 __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>,
3620 __scalar_expr<typename _Expr::value_type>, _Expr> >
3621>::type
3622operator*(const typename _Expr::value_type& __x, const _Expr& __y)
3623{
3624 typedef typename _Expr::value_type value_type;
3625 typedef _BinaryOp<multiplies<value_type>, __scalar_expr<value_type>, _Expr> _Op;
3626 return __val_expr<_Op>(_Op(multiplies<value_type>(),
3627 __scalar_expr<value_type>(__x, __y.size()), __y));
3628}
3629
3630template<class _Expr1, class _Expr2>
3631inline _LIBCPP_ALWAYS_INLINE
3632typename enable_if
3633<
3634 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
3635 __val_expr<_BinaryOp<divides<typename _Expr1::value_type>, _Expr1, _Expr2> >
3636>::type
3637operator/(const _Expr1& __x, const _Expr2& __y)
3638{
3639 typedef typename _Expr1::value_type value_type;
3640 typedef _BinaryOp<divides<value_type>, _Expr1, _Expr2> _Op;
3641 return __val_expr<_Op>(_Op(divides<value_type>(), __x, __y));
3642}
3643
3644template<class _Expr>
3645inline _LIBCPP_ALWAYS_INLINE
3646typename enable_if
3647<
3648 __is_val_expr<_Expr>::value,
3649 __val_expr<_BinaryOp<divides<typename _Expr::value_type>,
3650 _Expr, __scalar_expr<typename _Expr::value_type> > >
3651>::type
3652operator/(const _Expr& __x, const typename _Expr::value_type& __y)
3653{
3654 typedef typename _Expr::value_type value_type;
3655 typedef _BinaryOp<divides<value_type>, _Expr, __scalar_expr<value_type> > _Op;
3656 return __val_expr<_Op>(_Op(divides<value_type>(),
3657 __x, __scalar_expr<value_type>(__y, __x.size())));
3658}
3659
3660template<class _Expr>
3661inline _LIBCPP_ALWAYS_INLINE
3662typename enable_if
3663<
3664 __is_val_expr<_Expr>::value,
3665 __val_expr<_BinaryOp<divides<typename _Expr::value_type>,
3666 __scalar_expr<typename _Expr::value_type>, _Expr> >
3667>::type
3668operator/(const typename _Expr::value_type& __x, const _Expr& __y)
3669{
3670 typedef typename _Expr::value_type value_type;
3671 typedef _BinaryOp<divides<value_type>, __scalar_expr<value_type>, _Expr> _Op;
3672 return __val_expr<_Op>(_Op(divides<value_type>(),
3673 __scalar_expr<value_type>(__x, __y.size()), __y));
3674}
3675
3676template<class _Expr1, class _Expr2>
3677inline _LIBCPP_ALWAYS_INLINE
3678typename enable_if
3679<
3680 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
3681 __val_expr<_BinaryOp<modulus<typename _Expr1::value_type>, _Expr1, _Expr2> >
3682>::type
3683operator%(const _Expr1& __x, const _Expr2& __y)
3684{
3685 typedef typename _Expr1::value_type value_type;
3686 typedef _BinaryOp<modulus<value_type>, _Expr1, _Expr2> _Op;
3687 return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __y));
3688}
3689
3690template<class _Expr>
3691inline _LIBCPP_ALWAYS_INLINE
3692typename enable_if
3693<
3694 __is_val_expr<_Expr>::value,
3695 __val_expr<_BinaryOp<modulus<typename _Expr::value_type>,
3696 _Expr, __scalar_expr<typename _Expr::value_type> > >
3697>::type
3698operator%(const _Expr& __x, const typename _Expr::value_type& __y)
3699{
3700 typedef typename _Expr::value_type value_type;
3701 typedef _BinaryOp<modulus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
3702 return __val_expr<_Op>(_Op(modulus<value_type>(),
3703 __x, __scalar_expr<value_type>(__y, __x.size())));
3704}
3705
3706template<class _Expr>
3707inline _LIBCPP_ALWAYS_INLINE
3708typename enable_if
3709<
3710 __is_val_expr<_Expr>::value,
3711 __val_expr<_BinaryOp<modulus<typename _Expr::value_type>,
3712 __scalar_expr<typename _Expr::value_type>, _Expr> >
3713>::type
3714operator%(const typename _Expr::value_type& __x, const _Expr& __y)
3715{
3716 typedef typename _Expr::value_type value_type;
3717 typedef _BinaryOp<modulus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
3718 return __val_expr<_Op>(_Op(modulus<value_type>(),
3719 __scalar_expr<value_type>(__x, __y.size()), __y));
3720}
3721
3722template<class _Expr1, class _Expr2>
3723inline _LIBCPP_ALWAYS_INLINE
3724typename enable_if
3725<
3726 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
3727 __val_expr<_BinaryOp<plus<typename _Expr1::value_type>, _Expr1, _Expr2> >
3728>::type
3729operator+(const _Expr1& __x, const _Expr2& __y)
3730{
3731 typedef typename _Expr1::value_type value_type;
3732 typedef _BinaryOp<plus<value_type>, _Expr1, _Expr2> _Op;
3733 return __val_expr<_Op>(_Op(plus<value_type>(), __x, __y));
3734}
3735
3736template<class _Expr>
3737inline _LIBCPP_ALWAYS_INLINE
3738typename enable_if
3739<
3740 __is_val_expr<_Expr>::value,
3741 __val_expr<_BinaryOp<plus<typename _Expr::value_type>,
3742 _Expr, __scalar_expr<typename _Expr::value_type> > >
3743>::type
3744operator+(const _Expr& __x, const typename _Expr::value_type& __y)
3745{
3746 typedef typename _Expr::value_type value_type;
3747 typedef _BinaryOp<plus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
3748 return __val_expr<_Op>(_Op(plus<value_type>(),
3749 __x, __scalar_expr<value_type>(__y, __x.size())));
3750}
3751
3752template<class _Expr>
3753inline _LIBCPP_ALWAYS_INLINE
3754typename enable_if
3755<
3756 __is_val_expr<_Expr>::value,
3757 __val_expr<_BinaryOp<plus<typename _Expr::value_type>,
3758 __scalar_expr<typename _Expr::value_type>, _Expr> >
3759>::type
3760operator+(const typename _Expr::value_type& __x, const _Expr& __y)
3761{
3762 typedef typename _Expr::value_type value_type;
3763 typedef _BinaryOp<plus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
3764 return __val_expr<_Op>(_Op(plus<value_type>(),
3765 __scalar_expr<value_type>(__x, __y.size()), __y));
3766}
3767
3768template<class _Expr1, class _Expr2>
3769inline _LIBCPP_ALWAYS_INLINE
3770typename enable_if
3771<
3772 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
3773 __val_expr<_BinaryOp<minus<typename _Expr1::value_type>, _Expr1, _Expr2> >
3774>::type
3775operator-(const _Expr1& __x, const _Expr2& __y)
3776{
3777 typedef typename _Expr1::value_type value_type;
3778 typedef _BinaryOp<minus<value_type>, _Expr1, _Expr2> _Op;
3779 return __val_expr<_Op>(_Op(minus<value_type>(), __x, __y));
3780}
3781
3782template<class _Expr>
3783inline _LIBCPP_ALWAYS_INLINE
3784typename enable_if
3785<
3786 __is_val_expr<_Expr>::value,
3787 __val_expr<_BinaryOp<minus<typename _Expr::value_type>,
3788 _Expr, __scalar_expr<typename _Expr::value_type> > >
3789>::type
3790operator-(const _Expr& __x, const typename _Expr::value_type& __y)
3791{
3792 typedef typename _Expr::value_type value_type;
3793 typedef _BinaryOp<minus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
3794 return __val_expr<_Op>(_Op(minus<value_type>(),
3795 __x, __scalar_expr<value_type>(__y, __x.size())));
3796}
3797
3798template<class _Expr>
3799inline _LIBCPP_ALWAYS_INLINE
3800typename enable_if
3801<
3802 __is_val_expr<_Expr>::value,
3803 __val_expr<_BinaryOp<minus<typename _Expr::value_type>,
3804 __scalar_expr<typename _Expr::value_type>, _Expr> >
3805>::type
3806operator-(const typename _Expr::value_type& __x, const _Expr& __y)
3807{
3808 typedef typename _Expr::value_type value_type;
3809 typedef _BinaryOp<minus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
3810 return __val_expr<_Op>(_Op(minus<value_type>(),
3811 __scalar_expr<value_type>(__x, __y.size()), __y));
3812}
3813
3814template<class _Expr1, class _Expr2>
3815inline _LIBCPP_ALWAYS_INLINE
3816typename enable_if
3817<
3818 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
3819 __val_expr<_BinaryOp<bit_xor<typename _Expr1::value_type>, _Expr1, _Expr2> >
3820>::type
3821operator^(const _Expr1& __x, const _Expr2& __y)
3822{
3823 typedef typename _Expr1::value_type value_type;
3824 typedef _BinaryOp<bit_xor<value_type>, _Expr1, _Expr2> _Op;
3825 return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __y));
3826}
3827
3828template<class _Expr>
3829inline _LIBCPP_ALWAYS_INLINE
3830typename enable_if
3831<
3832 __is_val_expr<_Expr>::value,
3833 __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>,
3834 _Expr, __scalar_expr<typename _Expr::value_type> > >
3835>::type
3836operator^(const _Expr& __x, const typename _Expr::value_type& __y)
3837{
3838 typedef typename _Expr::value_type value_type;
3839 typedef _BinaryOp<bit_xor<value_type>, _Expr, __scalar_expr<value_type> > _Op;
3840 return __val_expr<_Op>(_Op(bit_xor<value_type>(),
3841 __x, __scalar_expr<value_type>(__y, __x.size())));
3842}
3843
3844template<class _Expr>
3845inline _LIBCPP_ALWAYS_INLINE
3846typename enable_if
3847<
3848 __is_val_expr<_Expr>::value,
3849 __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>,
3850 __scalar_expr<typename _Expr::value_type>, _Expr> >
3851>::type
3852operator^(const typename _Expr::value_type& __x, const _Expr& __y)
3853{
3854 typedef typename _Expr::value_type value_type;
3855 typedef _BinaryOp<bit_xor<value_type>, __scalar_expr<value_type>, _Expr> _Op;
3856 return __val_expr<_Op>(_Op(bit_xor<value_type>(),
3857 __scalar_expr<value_type>(__x, __y.size()), __y));
3858}
3859
3860template<class _Expr1, class _Expr2>
3861inline _LIBCPP_ALWAYS_INLINE
3862typename enable_if
3863<
3864 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
3865 __val_expr<_BinaryOp<bit_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
3866>::type
3867operator&(const _Expr1& __x, const _Expr2& __y)
3868{
3869 typedef typename _Expr1::value_type value_type;
3870 typedef _BinaryOp<bit_and<value_type>, _Expr1, _Expr2> _Op;
3871 return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __y));
3872}
3873
3874template<class _Expr>
3875inline _LIBCPP_ALWAYS_INLINE
3876typename enable_if
3877<
3878 __is_val_expr<_Expr>::value,
3879 __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>,
3880 _Expr, __scalar_expr<typename _Expr::value_type> > >
3881>::type
3882operator&(const _Expr& __x, const typename _Expr::value_type& __y)
3883{
3884 typedef typename _Expr::value_type value_type;
3885 typedef _BinaryOp<bit_and<value_type>, _Expr, __scalar_expr<value_type> > _Op;
3886 return __val_expr<_Op>(_Op(bit_and<value_type>(),
3887 __x, __scalar_expr<value_type>(__y, __x.size())));
3888}
3889
3890template<class _Expr>
3891inline _LIBCPP_ALWAYS_INLINE
3892typename enable_if
3893<
3894 __is_val_expr<_Expr>::value,
3895 __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>,
3896 __scalar_expr<typename _Expr::value_type>, _Expr> >
3897>::type
3898operator&(const typename _Expr::value_type& __x, const _Expr& __y)
3899{
3900 typedef typename _Expr::value_type value_type;
3901 typedef _BinaryOp<bit_and<value_type>, __scalar_expr<value_type>, _Expr> _Op;
3902 return __val_expr<_Op>(_Op(bit_and<value_type>(),
3903 __scalar_expr<value_type>(__x, __y.size()), __y));
3904}
3905
3906template<class _Expr1, class _Expr2>
3907inline _LIBCPP_ALWAYS_INLINE
3908typename enable_if
3909<
3910 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
3911 __val_expr<_BinaryOp<bit_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
3912>::type
3913operator|(const _Expr1& __x, const _Expr2& __y)
3914{
3915 typedef typename _Expr1::value_type value_type;
3916 typedef _BinaryOp<bit_or<value_type>, _Expr1, _Expr2> _Op;
3917 return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __y));
3918}
3919
3920template<class _Expr>
3921inline _LIBCPP_ALWAYS_INLINE
3922typename enable_if
3923<
3924 __is_val_expr<_Expr>::value,
3925 __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>,
3926 _Expr, __scalar_expr<typename _Expr::value_type> > >
3927>::type
3928operator|(const _Expr& __x, const typename _Expr::value_type& __y)
3929{
3930 typedef typename _Expr::value_type value_type;
3931 typedef _BinaryOp<bit_or<value_type>, _Expr, __scalar_expr<value_type> > _Op;
3932 return __val_expr<_Op>(_Op(bit_or<value_type>(),
3933 __x, __scalar_expr<value_type>(__y, __x.size())));
3934}
3935
3936template<class _Expr>
3937inline _LIBCPP_ALWAYS_INLINE
3938typename enable_if
3939<
3940 __is_val_expr<_Expr>::value,
3941 __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>,
3942 __scalar_expr<typename _Expr::value_type>, _Expr> >
3943>::type
3944operator|(const typename _Expr::value_type& __x, const _Expr& __y)
3945{
3946 typedef typename _Expr::value_type value_type;
3947 typedef _BinaryOp<bit_or<value_type>, __scalar_expr<value_type>, _Expr> _Op;
3948 return __val_expr<_Op>(_Op(bit_or<value_type>(),
3949 __scalar_expr<value_type>(__x, __y.size()), __y));
3950}
3951
3952template<class _Expr1, class _Expr2>
3953inline _LIBCPP_ALWAYS_INLINE
3954typename enable_if
3955<
3956 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
3957 __val_expr<_BinaryOp<__bit_shift_left<typename _Expr1::value_type>, _Expr1, _Expr2> >
3958>::type
3959operator<<(const _Expr1& __x, const _Expr2& __y)
3960{
3961 typedef typename _Expr1::value_type value_type;
3962 typedef _BinaryOp<__bit_shift_left<value_type>, _Expr1, _Expr2> _Op;
3963 return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __y));
3964}
3965
3966template<class _Expr>
3967inline _LIBCPP_ALWAYS_INLINE
3968typename enable_if
3969<
3970 __is_val_expr<_Expr>::value,
3971 __val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>,
3972 _Expr, __scalar_expr<typename _Expr::value_type> > >
3973>::type
3974operator<<(const _Expr& __x, const typename _Expr::value_type& __y)
3975{
3976 typedef typename _Expr::value_type value_type;
3977 typedef _BinaryOp<__bit_shift_left<value_type>, _Expr, __scalar_expr<value_type> > _Op;
3978 return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(),
3979 __x, __scalar_expr<value_type>(__y, __x.size())));
3980}
3981
3982template<class _Expr>
3983inline _LIBCPP_ALWAYS_INLINE
3984typename enable_if
3985<
3986 __is_val_expr<_Expr>::value,
3987 __val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>,
3988 __scalar_expr<typename _Expr::value_type>, _Expr> >
3989>::type
3990operator<<(const typename _Expr::value_type& __x, const _Expr& __y)
3991{
3992 typedef typename _Expr::value_type value_type;
3993 typedef _BinaryOp<__bit_shift_left<value_type>, __scalar_expr<value_type>, _Expr> _Op;
3994 return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(),
3995 __scalar_expr<value_type>(__x, __y.size()), __y));
3996}
3997
3998template<class _Expr1, class _Expr2>
3999inline _LIBCPP_ALWAYS_INLINE
4000typename enable_if
4001<
4002 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
4003 __val_expr<_BinaryOp<__bit_shift_right<typename _Expr1::value_type>, _Expr1, _Expr2> >
4004>::type
4005operator>>(const _Expr1& __x, const _Expr2& __y)
4006{
4007 typedef typename _Expr1::value_type value_type;
4008 typedef _BinaryOp<__bit_shift_right<value_type>, _Expr1, _Expr2> _Op;
4009 return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __y));
4010}
4011
4012template<class _Expr>
4013inline _LIBCPP_ALWAYS_INLINE
4014typename enable_if
4015<
4016 __is_val_expr<_Expr>::value,
4017 __val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>,
4018 _Expr, __scalar_expr<typename _Expr::value_type> > >
4019>::type
4020operator>>(const _Expr& __x, const typename _Expr::value_type& __y)
4021{
4022 typedef typename _Expr::value_type value_type;
4023 typedef _BinaryOp<__bit_shift_right<value_type>, _Expr, __scalar_expr<value_type> > _Op;
4024 return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(),
4025 __x, __scalar_expr<value_type>(__y, __x.size())));
4026}
4027
4028template<class _Expr>
4029inline _LIBCPP_ALWAYS_INLINE
4030typename enable_if
4031<
4032 __is_val_expr<_Expr>::value,
4033 __val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>,
4034 __scalar_expr<typename _Expr::value_type>, _Expr> >
4035>::type
4036operator>>(const typename _Expr::value_type& __x, const _Expr& __y)
4037{
4038 typedef typename _Expr::value_type value_type;
4039 typedef _BinaryOp<__bit_shift_right<value_type>, __scalar_expr<value_type>, _Expr> _Op;
4040 return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(),
4041 __scalar_expr<value_type>(__x, __y.size()), __y));
4042}
4043
4044template<class _Expr1, class _Expr2>
4045inline _LIBCPP_ALWAYS_INLINE
4046typename enable_if
4047<
4048 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
4049 __val_expr<_BinaryOp<logical_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
4050>::type
4051operator&&(const _Expr1& __x, const _Expr2& __y)
4052{
4053 typedef typename _Expr1::value_type value_type;
4054 typedef _BinaryOp<logical_and<value_type>, _Expr1, _Expr2> _Op;
4055 return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __y));
4056}
4057
4058template<class _Expr>
4059inline _LIBCPP_ALWAYS_INLINE
4060typename enable_if
4061<
4062 __is_val_expr<_Expr>::value,
4063 __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>,
4064 _Expr, __scalar_expr<typename _Expr::value_type> > >
4065>::type
4066operator&&(const _Expr& __x, const typename _Expr::value_type& __y)
4067{
4068 typedef typename _Expr::value_type value_type;
4069 typedef _BinaryOp<logical_and<value_type>, _Expr, __scalar_expr<value_type> > _Op;
4070 return __val_expr<_Op>(_Op(logical_and<value_type>(),
4071 __x, __scalar_expr<value_type>(__y, __x.size())));
4072}
4073
4074template<class _Expr>
4075inline _LIBCPP_ALWAYS_INLINE
4076typename enable_if
4077<
4078 __is_val_expr<_Expr>::value,
4079 __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>,
4080 __scalar_expr<typename _Expr::value_type>, _Expr> >
4081>::type
4082operator&&(const typename _Expr::value_type& __x, const _Expr& __y)
4083{
4084 typedef typename _Expr::value_type value_type;
4085 typedef _BinaryOp<logical_and<value_type>, __scalar_expr<value_type>, _Expr> _Op;
4086 return __val_expr<_Op>(_Op(logical_and<value_type>(),
4087 __scalar_expr<value_type>(__x, __y.size()), __y));
4088}
4089
4090template<class _Expr1, class _Expr2>
4091inline _LIBCPP_ALWAYS_INLINE
4092typename enable_if
4093<
4094 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
4095 __val_expr<_BinaryOp<logical_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
4096>::type
4097operator||(const _Expr1& __x, const _Expr2& __y)
4098{
4099 typedef typename _Expr1::value_type value_type;
4100 typedef _BinaryOp<logical_or<value_type>, _Expr1, _Expr2> _Op;
4101 return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __y));
4102}
4103
4104template<class _Expr>
4105inline _LIBCPP_ALWAYS_INLINE
4106typename enable_if
4107<
4108 __is_val_expr<_Expr>::value,
4109 __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>,
4110 _Expr, __scalar_expr<typename _Expr::value_type> > >
4111>::type
4112operator||(const _Expr& __x, const typename _Expr::value_type& __y)
4113{
4114 typedef typename _Expr::value_type value_type;
4115 typedef _BinaryOp<logical_or<value_type>, _Expr, __scalar_expr<value_type> > _Op;
4116 return __val_expr<_Op>(_Op(logical_or<value_type>(),
4117 __x, __scalar_expr<value_type>(__y, __x.size())));
4118}
4119
4120template<class _Expr>
4121inline _LIBCPP_ALWAYS_INLINE
4122typename enable_if
4123<
4124 __is_val_expr<_Expr>::value,
4125 __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>,
4126 __scalar_expr<typename _Expr::value_type>, _Expr> >
4127>::type
4128operator||(const typename _Expr::value_type& __x, const _Expr& __y)
4129{
4130 typedef typename _Expr::value_type value_type;
4131 typedef _BinaryOp<logical_or<value_type>, __scalar_expr<value_type>, _Expr> _Op;
4132 return __val_expr<_Op>(_Op(logical_or<value_type>(),
4133 __scalar_expr<value_type>(__x, __y.size()), __y));
4134}
4135
4136template<class _Expr1, class _Expr2>
4137inline _LIBCPP_ALWAYS_INLINE
4138typename enable_if
4139<
4140 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
4141 __val_expr<_BinaryOp<equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
4142>::type
4143operator==(const _Expr1& __x, const _Expr2& __y)
4144{
4145 typedef typename _Expr1::value_type value_type;
4146 typedef _BinaryOp<equal_to<value_type>, _Expr1, _Expr2> _Op;
4147 return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __y));
4148}
4149
4150template<class _Expr>
4151inline _LIBCPP_ALWAYS_INLINE
4152typename enable_if
4153<
4154 __is_val_expr<_Expr>::value,
4155 __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>,
4156 _Expr, __scalar_expr<typename _Expr::value_type> > >
4157>::type
4158operator==(const _Expr& __x, const typename _Expr::value_type& __y)
4159{
4160 typedef typename _Expr::value_type value_type;
4161 typedef _BinaryOp<equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op;
4162 return __val_expr<_Op>(_Op(equal_to<value_type>(),
4163 __x, __scalar_expr<value_type>(__y, __x.size())));
4164}
4165
4166template<class _Expr>
4167inline _LIBCPP_ALWAYS_INLINE
4168typename enable_if
4169<
4170 __is_val_expr<_Expr>::value,
4171 __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>,
4172 __scalar_expr<typename _Expr::value_type>, _Expr> >
4173>::type
4174operator==(const typename _Expr::value_type& __x, const _Expr& __y)
4175{
4176 typedef typename _Expr::value_type value_type;
4177 typedef _BinaryOp<equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op;
4178 return __val_expr<_Op>(_Op(equal_to<value_type>(),
4179 __scalar_expr<value_type>(__x, __y.size()), __y));
4180}
4181
4182template<class _Expr1, class _Expr2>
4183inline _LIBCPP_ALWAYS_INLINE
4184typename enable_if
4185<
4186 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
4187 __val_expr<_BinaryOp<not_equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
4188>::type
4189operator!=(const _Expr1& __x, const _Expr2& __y)
4190{
4191 typedef typename _Expr1::value_type value_type;
4192 typedef _BinaryOp<not_equal_to<value_type>, _Expr1, _Expr2> _Op;
4193 return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __y));
4194}
4195
4196template<class _Expr>
4197inline _LIBCPP_ALWAYS_INLINE
4198typename enable_if
4199<
4200 __is_val_expr<_Expr>::value,
4201 __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>,
4202 _Expr, __scalar_expr<typename _Expr::value_type> > >
4203>::type
4204operator!=(const _Expr& __x, const typename _Expr::value_type& __y)
4205{
4206 typedef typename _Expr::value_type value_type;
4207 typedef _BinaryOp<not_equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op;
4208 return __val_expr<_Op>(_Op(not_equal_to<value_type>(),
4209 __x, __scalar_expr<value_type>(__y, __x.size())));
4210}
4211
4212template<class _Expr>
4213inline _LIBCPP_ALWAYS_INLINE
4214typename enable_if
4215<
4216 __is_val_expr<_Expr>::value,
4217 __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>,
4218 __scalar_expr<typename _Expr::value_type>, _Expr> >
4219>::type
4220operator!=(const typename _Expr::value_type& __x, const _Expr& __y)
4221{
4222 typedef typename _Expr::value_type value_type;
4223 typedef _BinaryOp<not_equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op;
4224 return __val_expr<_Op>(_Op(not_equal_to<value_type>(),
4225 __scalar_expr<value_type>(__x, __y.size()), __y));
4226}
4227
4228template<class _Expr1, class _Expr2>
4229inline _LIBCPP_ALWAYS_INLINE
4230typename enable_if
4231<
4232 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
4233 __val_expr<_BinaryOp<less<typename _Expr1::value_type>, _Expr1, _Expr2> >
4234>::type
4235operator<(const _Expr1& __x, const _Expr2& __y)
4236{
4237 typedef typename _Expr1::value_type value_type;
4238 typedef _BinaryOp<less<value_type>, _Expr1, _Expr2> _Op;
4239 return __val_expr<_Op>(_Op(less<value_type>(), __x, __y));
4240}
4241
4242template<class _Expr>
4243inline _LIBCPP_ALWAYS_INLINE
4244typename enable_if
4245<
4246 __is_val_expr<_Expr>::value,
4247 __val_expr<_BinaryOp<less<typename _Expr::value_type>,
4248 _Expr, __scalar_expr<typename _Expr::value_type> > >
4249>::type
4250operator<(const _Expr& __x, const typename _Expr::value_type& __y)
4251{
4252 typedef typename _Expr::value_type value_type;
4253 typedef _BinaryOp<less<value_type>, _Expr, __scalar_expr<value_type> > _Op;
4254 return __val_expr<_Op>(_Op(less<value_type>(),
4255 __x, __scalar_expr<value_type>(__y, __x.size())));
4256}
4257
4258template<class _Expr>
4259inline _LIBCPP_ALWAYS_INLINE
4260typename enable_if
4261<
4262 __is_val_expr<_Expr>::value,
4263 __val_expr<_BinaryOp<less<typename _Expr::value_type>,
4264 __scalar_expr<typename _Expr::value_type>, _Expr> >
4265>::type
4266operator<(const typename _Expr::value_type& __x, const _Expr& __y)
4267{
4268 typedef typename _Expr::value_type value_type;
4269 typedef _BinaryOp<less<value_type>, __scalar_expr<value_type>, _Expr> _Op;
4270 return __val_expr<_Op>(_Op(less<value_type>(),
4271 __scalar_expr<value_type>(__x, __y.size()), __y));
4272}
4273
4274template<class _Expr1, class _Expr2>
4275inline _LIBCPP_ALWAYS_INLINE
4276typename enable_if
4277<
4278 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
4279 __val_expr<_BinaryOp<greater<typename _Expr1::value_type>, _Expr1, _Expr2> >
4280>::type
4281operator>(const _Expr1& __x, const _Expr2& __y)
4282{
4283 typedef typename _Expr1::value_type value_type;
4284 typedef _BinaryOp<greater<value_type>, _Expr1, _Expr2> _Op;
4285 return __val_expr<_Op>(_Op(greater<value_type>(), __x, __y));
4286}
4287
4288template<class _Expr>
4289inline _LIBCPP_ALWAYS_INLINE
4290typename enable_if
4291<
4292 __is_val_expr<_Expr>::value,
4293 __val_expr<_BinaryOp<greater<typename _Expr::value_type>,
4294 _Expr, __scalar_expr<typename _Expr::value_type> > >
4295>::type
4296operator>(const _Expr& __x, const typename _Expr::value_type& __y)
4297{
4298 typedef typename _Expr::value_type value_type;
4299 typedef _BinaryOp<greater<value_type>, _Expr, __scalar_expr<value_type> > _Op;
4300 return __val_expr<_Op>(_Op(greater<value_type>(),
4301 __x, __scalar_expr<value_type>(__y, __x.size())));
4302}
4303
4304template<class _Expr>
4305inline _LIBCPP_ALWAYS_INLINE
4306typename enable_if
4307<
4308 __is_val_expr<_Expr>::value,
4309 __val_expr<_BinaryOp<greater<typename _Expr::value_type>,
4310 __scalar_expr<typename _Expr::value_type>, _Expr> >
4311>::type
4312operator>(const typename _Expr::value_type& __x, const _Expr& __y)
4313{
4314 typedef typename _Expr::value_type value_type;
4315 typedef _BinaryOp<greater<value_type>, __scalar_expr<value_type>, _Expr> _Op;
4316 return __val_expr<_Op>(_Op(greater<value_type>(),
4317 __scalar_expr<value_type>(__x, __y.size()), __y));
4318}
4319
4320template<class _Expr1, class _Expr2>
4321inline _LIBCPP_ALWAYS_INLINE
4322typename enable_if
4323<
4324 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
4325 __val_expr<_BinaryOp<less_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
4326>::type
4327operator<=(const _Expr1& __x, const _Expr2& __y)
4328{
4329 typedef typename _Expr1::value_type value_type;
4330 typedef _BinaryOp<less_equal<value_type>, _Expr1, _Expr2> _Op;
4331 return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __y));
4332}
4333
4334template<class _Expr>
4335inline _LIBCPP_ALWAYS_INLINE
4336typename enable_if
4337<
4338 __is_val_expr<_Expr>::value,
4339 __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>,
4340 _Expr, __scalar_expr<typename _Expr::value_type> > >
4341>::type
4342operator<=(const _Expr& __x, const typename _Expr::value_type& __y)
4343{
4344 typedef typename _Expr::value_type value_type;
4345 typedef _BinaryOp<less_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op;
4346 return __val_expr<_Op>(_Op(less_equal<value_type>(),
4347 __x, __scalar_expr<value_type>(__y, __x.size())));
4348}
4349
4350template<class _Expr>
4351inline _LIBCPP_ALWAYS_INLINE
4352typename enable_if
4353<
4354 __is_val_expr<_Expr>::value,
4355 __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>,
4356 __scalar_expr<typename _Expr::value_type>, _Expr> >
4357>::type
4358operator<=(const typename _Expr::value_type& __x, const _Expr& __y)
4359{
4360 typedef typename _Expr::value_type value_type;
4361 typedef _BinaryOp<less_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op;
4362 return __val_expr<_Op>(_Op(less_equal<value_type>(),
4363 __scalar_expr<value_type>(__x, __y.size()), __y));
4364}
4365
4366template<class _Expr1, class _Expr2>
4367inline _LIBCPP_ALWAYS_INLINE
4368typename enable_if
4369<
4370 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
4371 __val_expr<_BinaryOp<greater_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
4372>::type
4373operator>=(const _Expr1& __x, const _Expr2& __y)
4374{
4375 typedef typename _Expr1::value_type value_type;
4376 typedef _BinaryOp<greater_equal<value_type>, _Expr1, _Expr2> _Op;
4377 return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __y));
4378}
4379
4380template<class _Expr>
4381inline _LIBCPP_ALWAYS_INLINE
4382typename enable_if
4383<
4384 __is_val_expr<_Expr>::value,
4385 __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>,
4386 _Expr, __scalar_expr<typename _Expr::value_type> > >
4387>::type
4388operator>=(const _Expr& __x, const typename _Expr::value_type& __y)
4389{
4390 typedef typename _Expr::value_type value_type;
4391 typedef _BinaryOp<greater_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op;
4392 return __val_expr<_Op>(_Op(greater_equal<value_type>(),
4393 __x, __scalar_expr<value_type>(__y, __x.size())));
4394}
4395
4396template<class _Expr>
4397inline _LIBCPP_ALWAYS_INLINE
4398typename enable_if
4399<
4400 __is_val_expr<_Expr>::value,
4401 __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>,
4402 __scalar_expr<typename _Expr::value_type>, _Expr> >
4403>::type
4404operator>=(const typename _Expr::value_type& __x, const _Expr& __y)
4405{
4406 typedef typename _Expr::value_type value_type;
4407 typedef _BinaryOp<greater_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op;
4408 return __val_expr<_Op>(_Op(greater_equal<value_type>(),
4409 __scalar_expr<value_type>(__x, __y.size()), __y));
4410}
4411
4412template<class _Expr>
4413inline _LIBCPP_ALWAYS_INLINE
4414typename enable_if
4415<
4416 __is_val_expr<_Expr>::value,
4417 __val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> >
4418>::type
4419abs(const _Expr& __x)
4420{
4421 typedef typename _Expr::value_type value_type;
4422 typedef _UnaryOp<__abs_expr<value_type>, _Expr> _Op;
4423 return __val_expr<_Op>(_Op(__abs_expr<value_type>(), __x));
4424}
4425
4426template<class _Expr>
4427inline _LIBCPP_ALWAYS_INLINE
4428typename enable_if
4429<
4430 __is_val_expr<_Expr>::value,
4431 __val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> >
4432>::type
4433acos(const _Expr& __x)
4434{
4435 typedef typename _Expr::value_type value_type;
4436 typedef _UnaryOp<__acos_expr<value_type>, _Expr> _Op;
4437 return __val_expr<_Op>(_Op(__acos_expr<value_type>(), __x));
4438}
4439
4440template<class _Expr>
4441inline _LIBCPP_ALWAYS_INLINE
4442typename enable_if
4443<
4444 __is_val_expr<_Expr>::value,
4445 __val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> >
4446>::type
4447asin(const _Expr& __x)
4448{
4449 typedef typename _Expr::value_type value_type;
4450 typedef _UnaryOp<__asin_expr<value_type>, _Expr> _Op;
4451 return __val_expr<_Op>(_Op(__asin_expr<value_type>(), __x));
4452}
4453
4454template<class _Expr>
4455inline _LIBCPP_ALWAYS_INLINE
4456typename enable_if
4457<
4458 __is_val_expr<_Expr>::value,
4459 __val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> >
4460>::type
4461atan(const _Expr& __x)
4462{
4463 typedef typename _Expr::value_type value_type;
4464 typedef _UnaryOp<__atan_expr<value_type>, _Expr> _Op;
4465 return __val_expr<_Op>(_Op(__atan_expr<value_type>(), __x));
4466}
4467
4468template<class _Expr1, class _Expr2>
4469inline _LIBCPP_ALWAYS_INLINE
4470typename enable_if
4471<
4472 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
4473 __val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
4474>::type
4475atan2(const _Expr1& __x, const _Expr2& __y)
4476{
4477 typedef typename _Expr1::value_type value_type;
4478 typedef _BinaryOp<__atan2_expr<value_type>, _Expr1, _Expr2> _Op;
4479 return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __y));
4480}
4481
4482template<class _Expr>
4483inline _LIBCPP_ALWAYS_INLINE
4484typename enable_if
4485<
4486 __is_val_expr<_Expr>::value,
4487 __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>,
4488 _Expr, __scalar_expr<typename _Expr::value_type> > >
4489>::type
4490atan2(const _Expr& __x, const typename _Expr::value_type& __y)
4491{
4492 typedef typename _Expr::value_type value_type;
4493 typedef _BinaryOp<__atan2_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
4494 return __val_expr<_Op>(_Op(__atan2_expr<value_type>(),
4495 __x, __scalar_expr<value_type>(__y, __x.size())));
4496}
4497
4498template<class _Expr>
4499inline _LIBCPP_ALWAYS_INLINE
4500typename enable_if
4501<
4502 __is_val_expr<_Expr>::value,
4503 __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>,
4504 __scalar_expr<typename _Expr::value_type>, _Expr> >
4505>::type
4506atan2(const typename _Expr::value_type& __x, const _Expr& __y)
4507{
4508 typedef typename _Expr::value_type value_type;
4509 typedef _BinaryOp<__atan2_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
4510 return __val_expr<_Op>(_Op(__atan2_expr<value_type>(),
4511 __scalar_expr<value_type>(__x, __y.size()), __y));
4512}
4513
4514template<class _Expr>
4515inline _LIBCPP_ALWAYS_INLINE
4516typename enable_if
4517<
4518 __is_val_expr<_Expr>::value,
4519 __val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> >
4520>::type
4521cos(const _Expr& __x)
4522{
4523 typedef typename _Expr::value_type value_type;
4524 typedef _UnaryOp<__cos_expr<value_type>, _Expr> _Op;
4525 return __val_expr<_Op>(_Op(__cos_expr<value_type>(), __x));
4526}
4527
4528template<class _Expr>
4529inline _LIBCPP_ALWAYS_INLINE
4530typename enable_if
4531<
4532 __is_val_expr<_Expr>::value,
4533 __val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> >
4534>::type
4535cosh(const _Expr& __x)
4536{
4537 typedef typename _Expr::value_type value_type;
4538 typedef _UnaryOp<__cosh_expr<value_type>, _Expr> _Op;
4539 return __val_expr<_Op>(_Op(__cosh_expr<value_type>(), __x));
4540}
4541
4542template<class _Expr>
4543inline _LIBCPP_ALWAYS_INLINE
4544typename enable_if
4545<
4546 __is_val_expr<_Expr>::value,
4547 __val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> >
4548>::type
4549exp(const _Expr& __x)
4550{
4551 typedef typename _Expr::value_type value_type;
4552 typedef _UnaryOp<__exp_expr<value_type>, _Expr> _Op;
4553 return __val_expr<_Op>(_Op(__exp_expr<value_type>(), __x));
4554}
4555
4556template<class _Expr>
4557inline _LIBCPP_ALWAYS_INLINE
4558typename enable_if
4559<
4560 __is_val_expr<_Expr>::value,
4561 __val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> >
4562>::type
4563log(const _Expr& __x)
4564{
4565 typedef typename _Expr::value_type value_type;
4566 typedef _UnaryOp<__log_expr<value_type>, _Expr> _Op;
4567 return __val_expr<_Op>(_Op(__log_expr<value_type>(), __x));
4568}
4569
4570template<class _Expr>
4571inline _LIBCPP_ALWAYS_INLINE
4572typename enable_if
4573<
4574 __is_val_expr<_Expr>::value,
4575 __val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> >
4576>::type
4577log10(const _Expr& __x)
4578{
4579 typedef typename _Expr::value_type value_type;
4580 typedef _UnaryOp<__log10_expr<value_type>, _Expr> _Op;
4581 return __val_expr<_Op>(_Op(__log10_expr<value_type>(), __x));
4582}
4583
4584template<class _Expr1, class _Expr2>
4585inline _LIBCPP_ALWAYS_INLINE
4586typename enable_if
4587<
4588 __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
4589 __val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
4590>::type
4591pow(const _Expr1& __x, const _Expr2& __y)
4592{
4593 typedef typename _Expr1::value_type value_type;
4594 typedef _BinaryOp<__pow_expr<value_type>, _Expr1, _Expr2> _Op;
4595 return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __y));
4596}
4597
4598template<class _Expr>
4599inline _LIBCPP_ALWAYS_INLINE
4600typename enable_if
4601<
4602 __is_val_expr<_Expr>::value,
4603 __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>,
4604 _Expr, __scalar_expr<typename _Expr::value_type> > >
4605>::type
4606pow(const _Expr& __x, const typename _Expr::value_type& __y)
4607{
4608 typedef typename _Expr::value_type value_type;
4609 typedef _BinaryOp<__pow_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
4610 return __val_expr<_Op>(_Op(__pow_expr<value_type>(),
4611 __x, __scalar_expr<value_type>(__y, __x.size())));
4612}
4613
4614template<class _Expr>
4615inline _LIBCPP_ALWAYS_INLINE
4616typename enable_if
4617<
4618 __is_val_expr<_Expr>::value,
4619 __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>,
4620 __scalar_expr<typename _Expr::value_type>, _Expr> >
4621>::type
4622pow(const typename _Expr::value_type& __x, const _Expr& __y)
4623{
4624 typedef typename _Expr::value_type value_type;
4625 typedef _BinaryOp<__pow_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
4626 return __val_expr<_Op>(_Op(__pow_expr<value_type>(),
4627 __scalar_expr<value_type>(__x, __y.size()), __y));
4628}
4629
4630template<class _Expr>
4631inline _LIBCPP_ALWAYS_INLINE
4632typename enable_if
4633<
4634 __is_val_expr<_Expr>::value,
4635 __val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> >
4636>::type
4637sin(const _Expr& __x)
4638{
4639 typedef typename _Expr::value_type value_type;
4640 typedef _UnaryOp<__sin_expr<value_type>, _Expr> _Op;
4641 return __val_expr<_Op>(_Op(__sin_expr<value_type>(), __x));
4642}
4643
4644template<class _Expr>
4645inline _LIBCPP_ALWAYS_INLINE
4646typename enable_if
4647<
4648 __is_val_expr<_Expr>::value,
4649 __val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> >
4650>::type
4651sinh(const _Expr& __x)
4652{
4653 typedef typename _Expr::value_type value_type;
4654 typedef _UnaryOp<__sinh_expr<value_type>, _Expr> _Op;
4655 return __val_expr<_Op>(_Op(__sinh_expr<value_type>(), __x));
4656}
4657
4658template<class _Expr>
4659inline _LIBCPP_ALWAYS_INLINE
4660typename enable_if
4661<
4662 __is_val_expr<_Expr>::value,
4663 __val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> >
4664>::type
4665sqrt(const _Expr& __x)
4666{
4667 typedef typename _Expr::value_type value_type;
4668 typedef _UnaryOp<__sqrt_expr<value_type>, _Expr> _Op;
4669 return __val_expr<_Op>(_Op(__sqrt_expr<value_type>(), __x));
4670}
4671
4672template<class _Expr>
4673inline _LIBCPP_ALWAYS_INLINE
4674typename enable_if
4675<
4676 __is_val_expr<_Expr>::value,
4677 __val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> >
4678>::type
4679tan(const _Expr& __x)
4680{
4681 typedef typename _Expr::value_type value_type;
4682 typedef _UnaryOp<__tan_expr<value_type>, _Expr> _Op;
4683 return __val_expr<_Op>(_Op(__tan_expr<value_type>(), __x));
4684}
4685
4686template<class _Expr>
4687inline _LIBCPP_ALWAYS_INLINE
4688typename enable_if
4689<
4690 __is_val_expr<_Expr>::value,
4691 __val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> >
4692>::type
4693tanh(const _Expr& __x)
4694{
4695 typedef typename _Expr::value_type value_type;
4696 typedef _UnaryOp<__tanh_expr<value_type>, _Expr> _Op;
4697 return __val_expr<_Op>(_Op(__tanh_expr<value_type>(), __x));
4698}
4699
4700template <class _Tp>
4701inline _LIBCPP_ALWAYS_INLINE
4702_Tp*
4703begin(valarray<_Tp>& __v)
4704{
4705 return __v.__begin_;
4706}
4707
4708template <class _Tp>
4709inline _LIBCPP_ALWAYS_INLINE
4710const _Tp*
4711begin(const valarray<_Tp>& __v)
4712{
4713 return __v.__begin_;
4714}
4715
4716template <class _Tp>
4717inline _LIBCPP_ALWAYS_INLINE
4718_Tp*
4719end(valarray<_Tp>& __v)
4720{
4721 return __v.__end_;
4722}
4723
4724template <class _Tp>
4725inline _LIBCPP_ALWAYS_INLINE
4726const _Tp*
4727end(const valarray<_Tp>& __v)
4728{
4729 return __v.__end_;
4730}
4731
4732extern template valarray<size_t>::valarray(size_t);
4733extern template valarray<size_t>::~valarray();
4734extern template void valarray<size_t>::resize(size_t, size_t);
4735
4736_LIBCPP_END_NAMESPACE_STD
4737
4738#endif // _LIBCPP_VALARRAY