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