Coverage Report

Created: 2020-02-25 14:32

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