contrib/llvm-project/libcxx/include/valarray

   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           {}
 373
 374     _LIBCPP_INLINE_VISIBILITY
 375     slice(size_t __start, size_t __size, size_t __stride)
 376         : __start_(__start),
 377           __size_(__size),
 378           __stride_(__stride)
 379           {}
 380
 381     _LIBCPP_INLINE_VISIBILITY size_t start()  const {return __start_;}
 382     _LIBCPP_INLINE_VISIBILITY size_t size()   const {return __size_;}
 383     _LIBCPP_INLINE_VISIBILITY size_t stride() const {return __stride_;}
 384 };
 385
 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     const value_type& operator[](size_t __i) const {return __begin_[__i];}
 849
 850     _LIBCPP_INLINE_VISIBILITY
 851     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     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     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         {__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         {__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         {__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         {__init(__start);}
1507
1508 #endif  // _LIBCPP_CXX03_LANG
1509
1510     _LIBCPP_INLINE_VISIBILITY
1511     size_t           start()  const {return __1d_.size() ? __1d_[0] : 0;}
1512
1513     _LIBCPP_INLINE_VISIBILITY
1514     valarray<size_t> size()   const {return __size_;}
1515
1516     _LIBCPP_INLINE_VISIBILITY
1517     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 {
2758     if (__n)
2759     {
2760         __begin_ = __end_ = static_cast<value_type*>(
2761             _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
2762 #ifndef _LIBCPP_NO_EXCEPTIONS
2763         try
2764         {
2765 #endif  // _LIBCPP_NO_EXCEPTIONS
2766             for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
2767                 ::new (__end_) value_type();
2768 #ifndef _LIBCPP_NO_EXCEPTIONS
2769         }
2770         catch (...)
2771         {
2772             __clear(__n);
2773             throw;
2774         }
2775 #endif  // _LIBCPP_NO_EXCEPTIONS
2776     }
2777 }
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 {
3003     __clear(size());
3004 }
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 {
3735   if (__begin_ != nullptr)
3736   {
3737     while (__end_ != __begin_)
3738       (--__end_)->~value_type();
3739     _VSTD::__libcpp_deallocate(__begin_, __capacity * sizeof(value_type), _LIBCPP_ALIGNOF(value_type));
3740     __begin_ = __end_ = nullptr;
3741   }
3742 }
3743
3744 template <class _Tp>
3745 void
3746 valarray<_Tp>::resize(size_t __n, value_type __x)
3747 {
3748     __clear(size());
3749     if (__n)
3750     {
3751         __begin_ = __end_ = static_cast<value_type*>(
3752            _VSTD::__libcpp_allocate(__n * sizeof(value_type), _LIBCPP_ALIGNOF(value_type)));
3753 #ifndef _LIBCPP_NO_EXCEPTIONS
3754         try
3755         {
3756 #endif  // _LIBCPP_NO_EXCEPTIONS
3757             for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
3758                 ::new (__end_) value_type(__x);
3759 #ifndef _LIBCPP_NO_EXCEPTIONS
3760         }
3761         catch (...)
3762         {
3763             __clear(__n);
3764             throw;
3765         }
3766 #endif  // _LIBCPP_NO_EXCEPTIONS
3767     }
3768 }
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