contrib/libc++/include/valarray

   1 // -*- C++ -*-
   2 //===-------------------------- valarray ----------------------------------===//
   3 //
   4 //                     The LLVM Compiler Infrastructure
   5 //
   6 // This file is dual licensed under the MIT and the University of Illinois Open
   7 // Source Licenses. See LICENSE.TXT for details.
   8 //
   9 //===----------------------------------------------------------------------===//
  10
  11 #ifndef _LIBCPP_VALARRAY
  12 #define _LIBCPP_VALARRAY
  13
  14 /*
  15     valarray synopsis
  16
  17 namespace std
  18 {
  19
  20 template<class T>
  21 class valarray
  22 {
  23 public:
  24     typedef T value_type;
  25
  26     // construct/destroy:
  27     valarray();
  28     explicit valarray(size_t n);
  29     valarray(const value_type& x, size_t n);
  30     valarray(const value_type* px, size_t n);
  31     valarray(const valarray& v);
  32     valarray(valarray&& v) noexcept;
  33     valarray(const slice_array<value_type>& sa);
  34     valarray(const gslice_array<value_type>& ga);
  35     valarray(const mask_array<value_type>& ma);
  36     valarray(const indirect_array<value_type>& ia);
  37     valarray(initializer_list<value_type> il);
  38     ~valarray();
  39
  40     // assignment:
  41     valarray& operator=(const valarray& v);
  42     valarray& operator=(valarray&& v) noexcept;
  43     valarray& operator=(initializer_list<value_type> il);
  44     valarray& operator=(const value_type& x);
  45     valarray& operator=(const slice_array<value_type>& sa);
  46     valarray& operator=(const gslice_array<value_type>& ga);
  47     valarray& operator=(const mask_array<value_type>& ma);
  48     valarray& operator=(const indirect_array<value_type>& ia);
  49
  50     // element access:
  51     const value_type& operator[](size_t i) const;
  52     value_type&       operator[](size_t i);
  53
  54     // subset operations:
  55     valarray                   operator[](slice s) const;
  56     slice_array<value_type>    operator[](slice s);
  57     valarray                   operator[](const gslice& gs) const;
  58     gslice_array<value_type>   operator[](const gslice& gs);
  59     valarray                   operator[](const valarray<bool>& vb) const;
  60     mask_array<value_type>     operator[](const valarray<bool>& vb);
  61     valarray                   operator[](const valarray<size_t>& vs) const;
  62     indirect_array<value_type> operator[](const valarray<size_t>& vs);
  63
  64     // unary operators:
  65     valarray       operator+() const;
  66     valarray       operator-() const;
  67     valarray       operator~() const;
  68     valarray<bool> operator!() const;
  69
  70     // computed assignment:
  71     valarray& operator*= (const value_type& x);
  72     valarray& operator/= (const value_type& x);
  73     valarray& operator%= (const value_type& x);
  74     valarray& operator+= (const value_type& x);
  75     valarray& operator-= (const value_type& x);
  76     valarray& operator^= (const value_type& x);
  77     valarray& operator&= (const value_type& x);
  78     valarray& operator|= (const value_type& x);
  79     valarray& operator<<=(const value_type& x);
  80     valarray& operator>>=(const value_type& x);
  81
  82     valarray& operator*= (const valarray& v);
  83     valarray& operator/= (const valarray& v);
  84     valarray& operator%= (const valarray& v);
  85     valarray& operator+= (const valarray& v);
  86     valarray& operator-= (const valarray& v);
  87     valarray& operator^= (const valarray& v);
  88     valarray& operator|= (const valarray& v);
  89     valarray& operator&= (const valarray& v);
  90     valarray& operator<<=(const valarray& v);
  91     valarray& operator>>=(const valarray& v);
  92
  93     // member functions:
  94     void swap(valarray& v) noexcept;
  95
  96     size_t size() const;
  97
  98     value_type sum() const;
  99     value_type min() const;
 100     value_type max() const;
 101
 102     valarray shift (int i) const;
 103     valarray cshift(int i) const;
 104     valarray apply(value_type f(value_type)) const;
 105     valarray apply(value_type f(const value_type&)) const;
 106     void resize(size_t n, value_type x = value_type());
 107 };
 108
 109 class slice
 110 {
 111 public:
 112     slice();
 113     slice(size_t start, size_t size, size_t stride);
 114
 115     size_t start()  const;
 116     size_t size()   const;
 117     size_t stride() const;
 118 };
 119
 120 template <class T>
 121 class slice_array
 122 {
 123 public:
 124     typedef T value_type;
 125
 126     const slice_array& operator=(const slice_array& sa) const;
 127     void operator=  (const valarray<value_type>& v) const;
 128     void operator*= (const valarray<value_type>& v) const;
 129     void operator/= (const valarray<value_type>& v) const;
 130     void operator%= (const valarray<value_type>& v) const;
 131     void operator+= (const valarray<value_type>& v) const;
 132     void operator-= (const valarray<value_type>& v) const;
 133     void operator^= (const valarray<value_type>& v) const;
 134     void operator&= (const valarray<value_type>& v) const;
 135     void operator|= (const valarray<value_type>& v) const;
 136     void operator<<=(const valarray<value_type>& v) const;
 137     void operator>>=(const valarray<value_type>& v) const;
 138
 139     void operator=(const value_type& x) const;
 140
 141     slice_array() = delete;
 142 };
 143
 144 class gslice
 145 {
 146 public:
 147     gslice();
 148     gslice(size_t start, const valarray<size_t>& size,
 149                          const valarray<size_t>& stride);
 150
 151     size_t           start()  const;
 152     valarray<size_t> size()   const;
 153     valarray<size_t> stride() const;
 154 };
 155
 156 template <class T>
 157 class gslice_array
 158 {
 159 public:
 160     typedef T value_type;
 161
 162     void operator=  (const valarray<value_type>& v) const;
 163     void operator*= (const valarray<value_type>& v) const;
 164     void operator/= (const valarray<value_type>& v) const;
 165     void operator%= (const valarray<value_type>& v) const;
 166     void operator+= (const valarray<value_type>& v) const;
 167     void operator-= (const valarray<value_type>& v) const;
 168     void operator^= (const valarray<value_type>& v) const;
 169     void operator&= (const valarray<value_type>& v) const;
 170     void operator|= (const valarray<value_type>& v) const;
 171     void operator<<=(const valarray<value_type>& v) const;
 172     void operator>>=(const valarray<value_type>& v) const;
 173
 174     gslice_array(const gslice_array& ga);
 175     ~gslice_array();
 176     const gslice_array& operator=(const gslice_array& ga) const;
 177     void operator=(const value_type& x) const;
 178
 179     gslice_array() = delete;
 180 };
 181
 182 template <class T>
 183 class mask_array
 184 {
 185 public:
 186     typedef T value_type;
 187
 188     void operator=  (const valarray<value_type>& v) const;
 189     void operator*= (const valarray<value_type>& v) const;
 190     void operator/= (const valarray<value_type>& v) const;
 191     void operator%= (const valarray<value_type>& v) const;
 192     void operator+= (const valarray<value_type>& v) const;
 193     void operator-= (const valarray<value_type>& v) const;
 194     void operator^= (const valarray<value_type>& v) const;
 195     void operator&= (const valarray<value_type>& v) const;
 196     void operator|= (const valarray<value_type>& v) const;
 197     void operator<<=(const valarray<value_type>& v) const;
 198     void operator>>=(const valarray<value_type>& v) const;
 199
 200     mask_array(const mask_array& ma);
 201     ~mask_array();
 202     const mask_array& operator=(const mask_array& ma) const;
 203     void operator=(const value_type& x) const;
 204
 205     mask_array() = delete;
 206 };
 207
 208 template <class T>
 209 class indirect_array
 210 {
 211 public:
 212     typedef T value_type;
 213
 214     void operator=  (const valarray<value_type>& v) const;
 215     void operator*= (const valarray<value_type>& v) const;
 216     void operator/= (const valarray<value_type>& v) const;
 217     void operator%= (const valarray<value_type>& v) const;
 218     void operator+= (const valarray<value_type>& v) const;
 219     void operator-= (const valarray<value_type>& v) const;
 220     void operator^= (const valarray<value_type>& v) const;
 221     void operator&= (const valarray<value_type>& v) const;
 222     void operator|= (const valarray<value_type>& v) const;
 223     void operator<<=(const valarray<value_type>& v) const;
 224     void operator>>=(const valarray<value_type>& v) const;
 225
 226     indirect_array(const indirect_array& ia);
 227     ~indirect_array();
 228     const indirect_array& operator=(const indirect_array& ia) const;
 229     void operator=(const value_type& x) const;
 230
 231     indirect_array() = delete;
 232 };
 233
 234 template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept;
 235
 236 template<class T> valarray<T> operator* (const valarray<T>& x, const valarray<T>& y);
 237 template<class T> valarray<T> operator* (const valarray<T>& x, const T& y);
 238 template<class T> valarray<T> operator* (const T& x, const valarray<T>& y);
 239
 240 template<class T> valarray<T> operator/ (const valarray<T>& x, const valarray<T>& y);
 241 template<class T> valarray<T> operator/ (const valarray<T>& x, const T& y);
 242 template<class T> valarray<T> operator/ (const T& x, const valarray<T>& y);
 243
 244 template<class T> valarray<T> operator% (const valarray<T>& x, const valarray<T>& y);
 245 template<class T> valarray<T> operator% (const valarray<T>& x, const T& y);
 246 template<class T> valarray<T> operator% (const T& x, const valarray<T>& y);
 247
 248 template<class T> valarray<T> operator+ (const valarray<T>& x, const valarray<T>& y);
 249 template<class T> valarray<T> operator+ (const valarray<T>& x, const T& y);
 250 template<class T> valarray<T> operator+ (const T& x, const valarray<T>& y);
 251
 252 template<class T> valarray<T> operator- (const valarray<T>& x, const valarray<T>& y);
 253 template<class T> valarray<T> operator- (const valarray<T>& x, const T& y);
 254 template<class T> valarray<T> operator- (const T& x, const valarray<T>& y);
 255
 256 template<class T> valarray<T> operator^ (const valarray<T>& x, const valarray<T>& y);
 257 template<class T> valarray<T> operator^ (const valarray<T>& x, const T& y);
 258 template<class T> valarray<T> operator^ (const T& x, const valarray<T>& y);
 259
 260 template<class T> valarray<T> operator& (const valarray<T>& x, const valarray<T>& y);
 261 template<class T> valarray<T> operator& (const valarray<T>& x, const T& y);
 262 template<class T> valarray<T> operator& (const T& x, const valarray<T>& y);
 263
 264 template<class T> valarray<T> operator| (const valarray<T>& x, const valarray<T>& y);
 265 template<class T> valarray<T> operator| (const valarray<T>& x, const T& y);
 266 template<class T> valarray<T> operator| (const T& x, const valarray<T>& y);
 267
 268 template<class T> valarray<T> operator<<(const valarray<T>& x, const valarray<T>& y);
 269 template<class T> valarray<T> operator<<(const valarray<T>& x, const T& y);
 270 template<class T> valarray<T> operator<<(const T& x, const valarray<T>& y);
 271
 272 template<class T> valarray<T> operator>>(const valarray<T>& x, const valarray<T>& y);
 273 template<class T> valarray<T> operator>>(const valarray<T>& x, const T& y);
 274 template<class T> valarray<T> operator>>(const T& x, const valarray<T>& y);
 275
 276 template<class T> valarray<bool> operator&&(const valarray<T>& x, const valarray<T>& y);
 277 template<class T> valarray<bool> operator&&(const valarray<T>& x, const T& y);
 278 template<class T> valarray<bool> operator&&(const T& x, const valarray<T>& y);
 279
 280 template<class T> valarray<bool> operator||(const valarray<T>& x, const valarray<T>& y);
 281 template<class T> valarray<bool> operator||(const valarray<T>& x, const T& y);
 282 template<class T> valarray<bool> operator||(const T& x, const valarray<T>& y);
 283
 284 template<class T> valarray<bool> operator==(const valarray<T>& x, const valarray<T>& y);
 285 template<class T> valarray<bool> operator==(const valarray<T>& x, const T& y);
 286 template<class T> valarray<bool> operator==(const T& x, const valarray<T>& y);
 287
 288 template<class T> valarray<bool> operator!=(const valarray<T>& x, const valarray<T>& y);
 289 template<class T> valarray<bool> operator!=(const valarray<T>& x, const T& y);
 290 template<class T> valarray<bool> operator!=(const T& x, const valarray<T>& y);
 291
 292 template<class T> valarray<bool> operator< (const valarray<T>& x, const valarray<T>& y);
 293 template<class T> valarray<bool> operator< (const valarray<T>& x, const T& y);
 294 template<class T> valarray<bool> operator< (const T& x, const valarray<T>& y);
 295
 296 template<class T> valarray<bool> operator> (const valarray<T>& x, const valarray<T>& y);
 297 template<class T> valarray<bool> operator> (const valarray<T>& x, const T& y);
 298 template<class T> valarray<bool> operator> (const T& x, const valarray<T>& y);
 299
 300 template<class T> valarray<bool> operator<=(const valarray<T>& x, const valarray<T>& y);
 301 template<class T> valarray<bool> operator<=(const valarray<T>& x, const T& y);
 302 template<class T> valarray<bool> operator<=(const T& x, const valarray<T>& y);
 303
 304 template<class T> valarray<bool> operator>=(const valarray<T>& x, const valarray<T>& y);
 305 template<class T> valarray<bool> operator>=(const valarray<T>& x, const T& y);
 306 template<class T> valarray<bool> operator>=(const T& x, const valarray<T>& y);
 307
 308 template<class T> valarray<T> abs (const valarray<T>& x);
 309 template<class T> valarray<T> acos (const valarray<T>& x);
 310 template<class T> valarray<T> asin (const valarray<T>& x);
 311 template<class T> valarray<T> atan (const valarray<T>& x);
 312
 313 template<class T> valarray<T> atan2(const valarray<T>& x, const valarray<T>& y);
 314 template<class T> valarray<T> atan2(const valarray<T>& x, const T& y);
 315 template<class T> valarray<T> atan2(const T& x, const valarray<T>& y);
 316
 317 template<class T> valarray<T> cos (const valarray<T>& x);
 318 template<class T> valarray<T> cosh (const valarray<T>& x);
 319 template<class T> valarray<T> exp (const valarray<T>& x);
 320 template<class T> valarray<T> log (const valarray<T>& x);
 321 template<class T> valarray<T> log10(const valarray<T>& x);
 322
 323 template<class T> valarray<T> pow(const valarray<T>& x, const valarray<T>& y);
 324 template<class T> valarray<T> pow(const valarray<T>& x, const T& y);
 325 template<class T> valarray<T> pow(const T& x, const valarray<T>& y);
 326
 327 template<class T> valarray<T> sin (const valarray<T>& x);
 328 template<class T> valarray<T> sinh (const valarray<T>& x);
 329 template<class T> valarray<T> sqrt (const valarray<T>& x);
 330 template<class T> valarray<T> tan (const valarray<T>& x);
 331 template<class T> valarray<T> tanh (const valarray<T>& x);
 332
 333 template <class T> unspecified1 begin(valarray<T>& v);
 334 template <class T> unspecified2 begin(const valarray<T>& v);
 335 template <class T> unspecified1 end(valarray<T>& v);
 336 template <class T> unspecified2 end(const valarray<T>& v);
 337
 338 }  // std
 339
 340 */
 341
 342 #include <__config>
 343 #include <cstddef>
 344 #include <cmath>
 345 #include <initializer_list>
 346 #include <algorithm>
 347 #include <functional>
 348 #include <new>
 349
 350 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 351 #pragma GCC system_header
 352 #endif
 353
 354 _LIBCPP_PUSH_MACROS
 355 #include <__undef_macros>
 356
 357
 358 _LIBCPP_BEGIN_NAMESPACE_STD
 359
 360 template<class _Tp> class _LIBCPP_TEMPLATE_VIS valarray;
 361
 362 class _LIBCPP_TEMPLATE_VIS slice
 363 {
 364     size_t __start_;
 365     size_t __size_;
 366     size_t __stride_;
 367 public:
 368     _LIBCPP_INLINE_VISIBILITY
 369     slice()
 370         : __start_(0),
 371           __size_(0),
 372           __stride_(0)
 373           {}
 374
 375     _LIBCPP_INLINE_VISIBILITY
 376     slice(size_t __start, size_t __size, size_t __stride)
 377         : __start_(__start),
 378           __size_(__size),
 379           __stride_(__stride)
 380           {}
 381
 382     _LIBCPP_INLINE_VISIBILITY size_t start()  const {return __start_;}
 383     _LIBCPP_INLINE_VISIBILITY size_t size()   const {return __size_;}
 384     _LIBCPP_INLINE_VISIBILITY size_t stride() const {return __stride_;}
 385 };
 386
 387 template <class _Tp> class _LIBCPP_TEMPLATE_VIS slice_array;
 388 class _LIBCPP_TYPE_VIS gslice;
 389 template <class _Tp> class _LIBCPP_TEMPLATE_VIS gslice_array;
 390 template <class _Tp> class _LIBCPP_TEMPLATE_VIS mask_array;
 391 template <class _Tp> class _LIBCPP_TEMPLATE_VIS indirect_array;
 392
 393 template <class _Tp>
 394 _LIBCPP_INLINE_VISIBILITY
 395 _Tp*
 396 begin(valarray<_Tp>& __v);
 397
 398 template <class _Tp>
 399 _LIBCPP_INLINE_VISIBILITY
 400 const _Tp*
 401 begin(const valarray<_Tp>& __v);
 402
 403 template <class _Tp>
 404 _LIBCPP_INLINE_VISIBILITY
 405 _Tp*
 406 end(valarray<_Tp>& __v);
 407
 408 template <class _Tp>
 409 _LIBCPP_INLINE_VISIBILITY
 410 const _Tp*
 411 end(const valarray<_Tp>& __v);
 412
 413 template <class _Op, class _A0>
 414 struct _UnaryOp
 415 {
 416     typedef typename _Op::result_type result_type;
 417     typedef typename _A0::value_type value_type;
 418
 419     _Op __op_;
 420     _A0 __a0_;
 421
 422     _LIBCPP_INLINE_VISIBILITY
 423     _UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {}
 424
 425     _LIBCPP_INLINE_VISIBILITY
 426     result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}
 427
 428     _LIBCPP_INLINE_VISIBILITY
 429     size_t size() const {return __a0_.size();}
 430 };
 431
 432 template <class _Op, class _A0, class _A1>
 433 struct _BinaryOp
 434 {
 435     typedef typename _Op::result_type result_type;
 436     typedef typename _A0::value_type value_type;
 437
 438     _Op __op_;
 439     _A0 __a0_;
 440     _A1 __a1_;
 441
 442     _LIBCPP_INLINE_VISIBILITY
 443     _BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1)
 444         : __op_(__op), __a0_(__a0), __a1_(__a1) {}
 445
 446     _LIBCPP_INLINE_VISIBILITY
 447     value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
 448
 449     _LIBCPP_INLINE_VISIBILITY
 450     size_t size() const {return __a0_.size();}
 451 };
 452
 453 template <class _Tp>
 454 class __scalar_expr
 455 {
 456 public:
 457     typedef _Tp        value_type;
 458     typedef const _Tp& result_type;
 459 private:
 460     const value_type& __t_;
 461     size_t __s_;
 462 public:
 463     _LIBCPP_INLINE_VISIBILITY
 464     explicit __scalar_expr(const value_type& __t, size_t __s) : __t_(__t), __s_(__s) {}
 465
 466     _LIBCPP_INLINE_VISIBILITY
 467     result_type operator[](size_t) const {return __t_;}
 468
 469     _LIBCPP_INLINE_VISIBILITY
 470     size_t size() const {return __s_;}
 471 };
 472
 473 template <class _Tp>
 474 struct __unary_plus : unary_function<_Tp, _Tp>
 475 {
 476     _LIBCPP_INLINE_VISIBILITY
 477     _Tp operator()(const _Tp& __x) const
 478         {return +__x;}
 479 };
 480
 481 template <class _Tp>
 482 struct __bit_not  : unary_function<_Tp, _Tp>
 483 {
 484     _LIBCPP_INLINE_VISIBILITY
 485     _Tp operator()(const _Tp& __x) const
 486         {return ~__x;}
 487 };
 488
 489 template <class _Tp>
 490 struct __bit_shift_left : binary_function<_Tp, _Tp, _Tp>
 491 {
 492     _LIBCPP_INLINE_VISIBILITY
 493     _Tp operator()(const _Tp& __x, const _Tp& __y) const
 494         {return __x << __y;}
 495 };
 496
 497 template <class _Tp>
 498 struct __bit_shift_right : binary_function<_Tp, _Tp, _Tp>
 499 {
 500     _LIBCPP_INLINE_VISIBILITY
 501     _Tp operator()(const _Tp& __x, const _Tp& __y) const
 502         {return __x >> __y;}
 503 };
 504
 505 template <class _Tp, class _Fp>
 506 struct __apply_expr   : unary_function<_Tp, _Tp>
 507 {
 508 private:
 509     _Fp __f_;
 510 public:
 511     _LIBCPP_INLINE_VISIBILITY
 512     explicit __apply_expr(_Fp __f) : __f_(__f) {}
 513
 514     _LIBCPP_INLINE_VISIBILITY
 515     _Tp operator()(const _Tp& __x) const
 516         {return __f_(__x);}
 517 };
 518
 519 template <class _Tp>
 520 struct __abs_expr : unary_function<_Tp, _Tp>
 521 {
 522     _LIBCPP_INLINE_VISIBILITY
 523     _Tp operator()(const _Tp& __x) const
 524         {return abs(__x);}
 525 };
 526
 527 template <class _Tp>
 528 struct __acos_expr : unary_function<_Tp, _Tp>
 529 {
 530     _LIBCPP_INLINE_VISIBILITY
 531     _Tp operator()(const _Tp& __x) const
 532         {return acos(__x);}
 533 };
 534
 535 template <class _Tp>
 536 struct __asin_expr : unary_function<_Tp, _Tp>
 537 {
 538     _LIBCPP_INLINE_VISIBILITY
 539     _Tp operator()(const _Tp& __x) const
 540         {return asin(__x);}
 541 };
 542
 543 template <class _Tp>
 544 struct __atan_expr : unary_function<_Tp, _Tp>
 545 {
 546     _LIBCPP_INLINE_VISIBILITY
 547     _Tp operator()(const _Tp& __x) const
 548         {return atan(__x);}
 549 };
 550
 551 template <class _Tp>
 552 struct __atan2_expr : binary_function<_Tp, _Tp, _Tp>
 553 {
 554     _LIBCPP_INLINE_VISIBILITY
 555     _Tp operator()(const _Tp& __x, const _Tp& __y) const
 556         {return atan2(__x, __y);}
 557 };
 558
 559 template <class _Tp>
 560 struct __cos_expr : unary_function<_Tp, _Tp>
 561 {
 562     _LIBCPP_INLINE_VISIBILITY
 563     _Tp operator()(const _Tp& __x) const
 564         {return cos(__x);}
 565 };
 566
 567 template <class _Tp>
 568 struct __cosh_expr : unary_function<_Tp, _Tp>
 569 {
 570     _LIBCPP_INLINE_VISIBILITY
 571     _Tp operator()(const _Tp& __x) const
 572         {return cosh(__x);}
 573 };
 574
 575 template <class _Tp>
 576 struct __exp_expr : unary_function<_Tp, _Tp>
 577 {
 578     _LIBCPP_INLINE_VISIBILITY
 579     _Tp operator()(const _Tp& __x) const
 580         {return exp(__x);}
 581 };
 582
 583 template <class _Tp>
 584 struct __log_expr : unary_function<_Tp, _Tp>
 585 {
 586     _LIBCPP_INLINE_VISIBILITY
 587     _Tp operator()(const _Tp& __x) const
 588         {return log(__x);}
 589 };
 590
 591 template <class _Tp>
 592 struct __log10_expr : unary_function<_Tp, _Tp>
 593 {
 594     _LIBCPP_INLINE_VISIBILITY
 595     _Tp operator()(const _Tp& __x) const
 596         {return log10(__x);}
 597 };
 598
 599 template <class _Tp>
 600 struct __pow_expr : binary_function<_Tp, _Tp, _Tp>
 601 {
 602     _LIBCPP_INLINE_VISIBILITY
 603     _Tp operator()(const _Tp& __x, const _Tp& __y) const
 604         {return pow(__x, __y);}
 605 };
 606
 607 template <class _Tp>
 608 struct __sin_expr : unary_function<_Tp, _Tp>
 609 {
 610     _LIBCPP_INLINE_VISIBILITY
 611     _Tp operator()(const _Tp& __x) const
 612         {return sin(__x);}
 613 };
 614
 615 template <class _Tp>
 616 struct __sinh_expr : unary_function<_Tp, _Tp>
 617 {
 618     _LIBCPP_INLINE_VISIBILITY
 619     _Tp operator()(const _Tp& __x) const
 620         {return sinh(__x);}
 621 };
 622
 623 template <class _Tp>
 624 struct __sqrt_expr : unary_function<_Tp, _Tp>
 625 {
 626     _LIBCPP_INLINE_VISIBILITY
 627     _Tp operator()(const _Tp& __x) const
 628         {return sqrt(__x);}
 629 };
 630
 631 template <class _Tp>
 632 struct __tan_expr : unary_function<_Tp, _Tp>
 633 {
 634     _LIBCPP_INLINE_VISIBILITY
 635     _Tp operator()(const _Tp& __x) const
 636         {return tan(__x);}
 637 };
 638
 639 template <class _Tp>
 640 struct __tanh_expr : unary_function<_Tp, _Tp>
 641 {
 642     _LIBCPP_INLINE_VISIBILITY
 643     _Tp operator()(const _Tp& __x) const
 644         {return tanh(__x);}
 645 };
 646
 647 template <class _ValExpr>
 648 class __slice_expr
 649 {
 650     typedef typename remove_reference<_ValExpr>::type  _RmExpr;
 651 public:
 652     typedef typename _RmExpr::value_type value_type;
 653     typedef value_type result_type;
 654
 655 private:
 656     _ValExpr __expr_;
 657     size_t __start_;
 658     size_t __size_;
 659     size_t __stride_;
 660
 661     _LIBCPP_INLINE_VISIBILITY
 662     __slice_expr(const slice& __sl, const _RmExpr& __e)
 663         : __expr_(__e),
 664           __start_(__sl.start()),
 665           __size_(__sl.size()),
 666           __stride_(__sl.stride())
 667         {}
 668 public:
 669
 670     _LIBCPP_INLINE_VISIBILITY
 671     result_type operator[](size_t __i) const
 672         {return __expr_[__start_ + __i * __stride_];}
 673
 674     _LIBCPP_INLINE_VISIBILITY
 675     size_t size() const {return __size_;}
 676
 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 valarray<size_t>::valarray(size_t))
1063 _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS valarray<size_t>::~valarray())
1064 _LIBCPP_EXTERN_TEMPLATE(_LIBCPP_FUNC_VIS void valarray<size_t>::resize(size_t, size_t))
1065
1066 template <class _Op, class _Tp>
1067 struct _UnaryOp<_Op, valarray<_Tp> >
1068 {
1069     typedef typename _Op::result_type result_type;
1070     typedef _Tp value_type;
1071
1072     _Op __op_;
1073     const valarray<_Tp>& __a0_;
1074
1075     _LIBCPP_INLINE_VISIBILITY
1076     _UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {}
1077
1078     _LIBCPP_INLINE_VISIBILITY
1079     result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}
1080
1081     _LIBCPP_INLINE_VISIBILITY
1082     size_t size() const {return __a0_.size();}
1083 };
1084
1085 template <class _Op, class _Tp, class _A1>
1086 struct _BinaryOp<_Op, valarray<_Tp>, _A1>
1087 {
1088     typedef typename _Op::result_type result_type;
1089     typedef _Tp value_type;
1090
1091     _Op __op_;
1092     const valarray<_Tp>& __a0_;
1093     _A1 __a1_;
1094
1095     _LIBCPP_INLINE_VISIBILITY
1096     _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1)
1097         : __op_(__op), __a0_(__a0), __a1_(__a1) {}
1098
1099     _LIBCPP_INLINE_VISIBILITY
1100     value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
1101
1102     _LIBCPP_INLINE_VISIBILITY
1103     size_t size() const {return __a0_.size();}
1104 };
1105
1106 template <class _Op, class _A0, class _Tp>
1107 struct _BinaryOp<_Op, _A0, valarray<_Tp> >
1108 {
1109     typedef typename _Op::result_type result_type;
1110     typedef _Tp value_type;
1111
1112     _Op __op_;
1113     _A0 __a0_;
1114     const valarray<_Tp>& __a1_;
1115
1116     _LIBCPP_INLINE_VISIBILITY
1117     _BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1)
1118         : __op_(__op), __a0_(__a0), __a1_(__a1) {}
1119
1120     _LIBCPP_INLINE_VISIBILITY
1121     value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
1122
1123     _LIBCPP_INLINE_VISIBILITY
1124     size_t size() const {return __a0_.size();}
1125 };
1126
1127 template <class _Op, class _Tp>
1128 struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> >
1129 {
1130     typedef typename _Op::result_type result_type;
1131     typedef _Tp value_type;
1132
1133     _Op __op_;
1134     const valarray<_Tp>& __a0_;
1135     const valarray<_Tp>& __a1_;
1136
1137     _LIBCPP_INLINE_VISIBILITY
1138     _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1)
1139         : __op_(__op), __a0_(__a0), __a1_(__a1) {}
1140
1141     _LIBCPP_INLINE_VISIBILITY
1142     value_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
1143
1144     _LIBCPP_INLINE_VISIBILITY
1145     size_t size() const {return __a0_.size();}
1146 };
1147
1148 // slice_array
1149
1150 template <class _Tp>
1151 class _LIBCPP_TEMPLATE_VIS slice_array
1152 {
1153 public:
1154     typedef _Tp value_type;
1155
1156 private:
1157     value_type* __vp_;
1158     size_t __size_;
1159     size_t __stride_;
1160
1161 public:
1162     template <class _Expr>
1163     typename enable_if
1164     <
1165         __is_val_expr<_Expr>::value,
1166         void
1167     >::type
1168     _LIBCPP_INLINE_VISIBILITY
1169     operator=(const _Expr& __v) const;
1170
1171     template <class _Expr>
1172     typename enable_if
1173     <
1174         __is_val_expr<_Expr>::value,
1175         void
1176     >::type
1177     _LIBCPP_INLINE_VISIBILITY
1178     operator*=(const _Expr& __v) const;
1179
1180     template <class _Expr>
1181     typename enable_if
1182     <
1183         __is_val_expr<_Expr>::value,
1184         void
1185     >::type
1186     _LIBCPP_INLINE_VISIBILITY
1187     operator/=(const _Expr& __v) const;
1188
1189     template <class _Expr>
1190     typename enable_if
1191     <
1192         __is_val_expr<_Expr>::value,
1193         void
1194     >::type
1195     _LIBCPP_INLINE_VISIBILITY
1196     operator%=(const _Expr& __v) const;
1197
1198     template <class _Expr>
1199     typename enable_if
1200     <
1201         __is_val_expr<_Expr>::value,
1202         void
1203     >::type
1204     _LIBCPP_INLINE_VISIBILITY
1205     operator+=(const _Expr& __v) const;
1206
1207     template <class _Expr>
1208     typename enable_if
1209     <
1210         __is_val_expr<_Expr>::value,
1211         void
1212     >::type
1213     _LIBCPP_INLINE_VISIBILITY
1214     operator-=(const _Expr& __v) const;
1215
1216     template <class _Expr>
1217     typename enable_if
1218     <
1219         __is_val_expr<_Expr>::value,
1220         void
1221     >::type
1222     _LIBCPP_INLINE_VISIBILITY
1223     operator^=(const _Expr& __v) const;
1224
1225     template <class _Expr>
1226     typename enable_if
1227     <
1228         __is_val_expr<_Expr>::value,
1229         void
1230     >::type
1231     _LIBCPP_INLINE_VISIBILITY
1232     operator&=(const _Expr& __v) const;
1233
1234     template <class _Expr>
1235     typename enable_if
1236     <
1237         __is_val_expr<_Expr>::value,
1238         void
1239     >::type
1240     _LIBCPP_INLINE_VISIBILITY
1241     operator|=(const _Expr& __v) const;
1242
1243     template <class _Expr>
1244     typename enable_if
1245     <
1246         __is_val_expr<_Expr>::value,
1247         void
1248     >::type
1249     _LIBCPP_INLINE_VISIBILITY
1250     operator<<=(const _Expr& __v) const;
1251
1252     template <class _Expr>
1253     typename enable_if
1254     <
1255         __is_val_expr<_Expr>::value,
1256         void
1257     >::type
1258     _LIBCPP_INLINE_VISIBILITY
1259     operator>>=(const _Expr& __v) const;
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 //  gslice(const gslice&)            = default;
1511 //  gslice(gslice&&)                 = default;
1512 //  gslice& operator=(const gslice&) = default;
1513 //  gslice& operator=(gslice&&)      = default;
1514
1515     _LIBCPP_INLINE_VISIBILITY
1516     size_t           start()  const {return __1d_.size() ? __1d_[0] : 0;}
1517
1518     _LIBCPP_INLINE_VISIBILITY
1519     valarray<size_t> size()   const {return __size_;}
1520
1521     _LIBCPP_INLINE_VISIBILITY
1522     valarray<size_t> stride() const {return __stride_;}
1523
1524 private:
1525     void __init(size_t __start);
1526
1527     template <class> friend class gslice_array;
1528     template <class> friend class valarray;
1529     template <class> friend class __val_expr;
1530 };
1531
1532 // gslice_array
1533
1534 template <class _Tp>
1535 class _LIBCPP_TEMPLATE_VIS gslice_array
1536 {
1537 public:
1538     typedef _Tp value_type;
1539
1540 private:
1541     value_type*      __vp_;
1542     valarray<size_t> __1d_;
1543
1544 public:
1545     template <class _Expr>
1546     typename enable_if
1547     <
1548         __is_val_expr<_Expr>::value,
1549         void
1550     >::type
1551     _LIBCPP_INLINE_VISIBILITY
1552     operator=(const _Expr& __v) const;
1553
1554     template <class _Expr>
1555     typename enable_if
1556     <
1557         __is_val_expr<_Expr>::value,
1558         void
1559     >::type
1560     _LIBCPP_INLINE_VISIBILITY
1561     operator*=(const _Expr& __v) const;
1562
1563     template <class _Expr>
1564     typename enable_if
1565     <
1566         __is_val_expr<_Expr>::value,
1567         void
1568     >::type
1569     _LIBCPP_INLINE_VISIBILITY
1570     operator/=(const _Expr& __v) const;
1571
1572     template <class _Expr>
1573     typename enable_if
1574     <
1575         __is_val_expr<_Expr>::value,
1576         void
1577     >::type
1578     _LIBCPP_INLINE_VISIBILITY
1579     operator%=(const _Expr& __v) const;
1580
1581     template <class _Expr>
1582     typename enable_if
1583     <
1584         __is_val_expr<_Expr>::value,
1585         void
1586     >::type
1587     _LIBCPP_INLINE_VISIBILITY
1588     operator+=(const _Expr& __v) const;
1589
1590     template <class _Expr>
1591     typename enable_if
1592     <
1593         __is_val_expr<_Expr>::value,
1594         void
1595     >::type
1596     _LIBCPP_INLINE_VISIBILITY
1597     operator-=(const _Expr& __v) const;
1598
1599     template <class _Expr>
1600     typename enable_if
1601     <
1602         __is_val_expr<_Expr>::value,
1603         void
1604     >::type
1605     _LIBCPP_INLINE_VISIBILITY
1606     operator^=(const _Expr& __v) const;
1607
1608     template <class _Expr>
1609     typename enable_if
1610     <
1611         __is_val_expr<_Expr>::value,
1612         void
1613     >::type
1614     _LIBCPP_INLINE_VISIBILITY
1615     operator&=(const _Expr& __v) const;
1616
1617     template <class _Expr>
1618     typename enable_if
1619     <
1620         __is_val_expr<_Expr>::value,
1621         void
1622     >::type
1623     _LIBCPP_INLINE_VISIBILITY
1624     operator|=(const _Expr& __v) const;
1625
1626     template <class _Expr>
1627     typename enable_if
1628     <
1629         __is_val_expr<_Expr>::value,
1630         void
1631     >::type
1632     _LIBCPP_INLINE_VISIBILITY
1633     operator<<=(const _Expr& __v) const;
1634
1635     template <class _Expr>
1636     typename enable_if
1637     <
1638         __is_val_expr<_Expr>::value,
1639         void
1640     >::type
1641     _LIBCPP_INLINE_VISIBILITY
1642     operator>>=(const _Expr& __v) const;
1643
1644     _LIBCPP_INLINE_VISIBILITY
1645     const gslice_array& operator=(const gslice_array& __ga) const;
1646
1647     _LIBCPP_INLINE_VISIBILITY
1648     void operator=(const value_type& __x) const;
1649
1650 //  gslice_array(const gslice_array&)            = default;
1651 //  gslice_array(gslice_array&&)                 = default;
1652 //  gslice_array& operator=(const gslice_array&) = default;
1653 //  gslice_array& operator=(gslice_array&&)      = default;
1654
1655 private:
1656     gslice_array(const gslice& __gs, const valarray<value_type>& __v)
1657         : __vp_(const_cast<value_type*>(__v.__begin_)),
1658           __1d_(__gs.__1d_)
1659         {}
1660
1661 #ifndef _LIBCPP_CXX03_LANG
1662     gslice_array(gslice&& __gs, const valarray<value_type>& __v)
1663         : __vp_(const_cast<value_type*>(__v.__begin_)),
1664           __1d_(move(__gs.__1d_))
1665         {}
1666 #endif  // _LIBCPP_CXX03_LANG
1667
1668     template <class> friend class valarray;
1669 };
1670
1671 template <class _Tp>
1672 template <class _Expr>
1673 inline
1674 typename enable_if
1675 <
1676     __is_val_expr<_Expr>::value,
1677     void
1678 >::type
1679 gslice_array<_Tp>::operator=(const _Expr& __v) const
1680 {
1681     typedef const size_t* _Ip;
1682     size_t __j = 0;
1683     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1684         __vp_[*__i] = __v[__j];
1685 }
1686
1687 template <class _Tp>
1688 template <class _Expr>
1689 inline
1690 typename enable_if
1691 <
1692     __is_val_expr<_Expr>::value,
1693     void
1694 >::type
1695 gslice_array<_Tp>::operator*=(const _Expr& __v) const
1696 {
1697     typedef const size_t* _Ip;
1698     size_t __j = 0;
1699     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1700         __vp_[*__i] *= __v[__j];
1701 }
1702
1703 template <class _Tp>
1704 template <class _Expr>
1705 inline
1706 typename enable_if
1707 <
1708     __is_val_expr<_Expr>::value,
1709     void
1710 >::type
1711 gslice_array<_Tp>::operator/=(const _Expr& __v) const
1712 {
1713     typedef const size_t* _Ip;
1714     size_t __j = 0;
1715     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1716         __vp_[*__i] /= __v[__j];
1717 }
1718
1719 template <class _Tp>
1720 template <class _Expr>
1721 inline
1722 typename enable_if
1723 <
1724     __is_val_expr<_Expr>::value,
1725     void
1726 >::type
1727 gslice_array<_Tp>::operator%=(const _Expr& __v) const
1728 {
1729     typedef const size_t* _Ip;
1730     size_t __j = 0;
1731     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1732         __vp_[*__i] %= __v[__j];
1733 }
1734
1735 template <class _Tp>
1736 template <class _Expr>
1737 inline
1738 typename enable_if
1739 <
1740     __is_val_expr<_Expr>::value,
1741     void
1742 >::type
1743 gslice_array<_Tp>::operator+=(const _Expr& __v) const
1744 {
1745     typedef const size_t* _Ip;
1746     size_t __j = 0;
1747     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1748         __vp_[*__i] += __v[__j];
1749 }
1750
1751 template <class _Tp>
1752 template <class _Expr>
1753 inline
1754 typename enable_if
1755 <
1756     __is_val_expr<_Expr>::value,
1757     void
1758 >::type
1759 gslice_array<_Tp>::operator-=(const _Expr& __v) const
1760 {
1761     typedef const size_t* _Ip;
1762     size_t __j = 0;
1763     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1764         __vp_[*__i] -= __v[__j];
1765 }
1766
1767 template <class _Tp>
1768 template <class _Expr>
1769 inline
1770 typename enable_if
1771 <
1772     __is_val_expr<_Expr>::value,
1773     void
1774 >::type
1775 gslice_array<_Tp>::operator^=(const _Expr& __v) const
1776 {
1777     typedef const size_t* _Ip;
1778     size_t __j = 0;
1779     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1780         __vp_[*__i] ^= __v[__j];
1781 }
1782
1783 template <class _Tp>
1784 template <class _Expr>
1785 inline
1786 typename enable_if
1787 <
1788     __is_val_expr<_Expr>::value,
1789     void
1790 >::type
1791 gslice_array<_Tp>::operator&=(const _Expr& __v) const
1792 {
1793     typedef const size_t* _Ip;
1794     size_t __j = 0;
1795     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1796         __vp_[*__i] &= __v[__j];
1797 }
1798
1799 template <class _Tp>
1800 template <class _Expr>
1801 inline
1802 typename enable_if
1803 <
1804     __is_val_expr<_Expr>::value,
1805     void
1806 >::type
1807 gslice_array<_Tp>::operator|=(const _Expr& __v) const
1808 {
1809     typedef const size_t* _Ip;
1810     size_t __j = 0;
1811     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1812         __vp_[*__i] |= __v[__j];
1813 }
1814
1815 template <class _Tp>
1816 template <class _Expr>
1817 inline
1818 typename enable_if
1819 <
1820     __is_val_expr<_Expr>::value,
1821     void
1822 >::type
1823 gslice_array<_Tp>::operator<<=(const _Expr& __v) const
1824 {
1825     typedef const size_t* _Ip;
1826     size_t __j = 0;
1827     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1828         __vp_[*__i] <<= __v[__j];
1829 }
1830
1831 template <class _Tp>
1832 template <class _Expr>
1833 inline
1834 typename enable_if
1835 <
1836     __is_val_expr<_Expr>::value,
1837     void
1838 >::type
1839 gslice_array<_Tp>::operator>>=(const _Expr& __v) const
1840 {
1841     typedef const size_t* _Ip;
1842     size_t __j = 0;
1843     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
1844         __vp_[*__i] >>= __v[__j];
1845 }
1846
1847 template <class _Tp>
1848 inline
1849 const gslice_array<_Tp>&
1850 gslice_array<_Tp>::operator=(const gslice_array& __ga) const
1851 {
1852     typedef const size_t* _Ip;
1853     const value_type* __s = __ga.__vp_;
1854     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ga.__1d_.__begin_;
1855             __i != __e; ++__i, ++__j)
1856         __vp_[*__i] = __s[*__j];
1857     return *this;
1858 }
1859
1860 template <class _Tp>
1861 inline
1862 void
1863 gslice_array<_Tp>::operator=(const value_type& __x) const
1864 {
1865     typedef const size_t* _Ip;
1866     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
1867         __vp_[*__i] = __x;
1868 }
1869
1870 // mask_array
1871
1872 template <class _Tp>
1873 class _LIBCPP_TEMPLATE_VIS mask_array
1874 {
1875 public:
1876     typedef _Tp value_type;
1877
1878 private:
1879     value_type*      __vp_;
1880     valarray<size_t> __1d_;
1881
1882 public:
1883     template <class _Expr>
1884     typename enable_if
1885     <
1886         __is_val_expr<_Expr>::value,
1887         void
1888     >::type
1889     _LIBCPP_INLINE_VISIBILITY
1890     operator=(const _Expr& __v) const;
1891
1892     template <class _Expr>
1893     typename enable_if
1894     <
1895         __is_val_expr<_Expr>::value,
1896         void
1897     >::type
1898     _LIBCPP_INLINE_VISIBILITY
1899     operator*=(const _Expr& __v) const;
1900
1901     template <class _Expr>
1902     typename enable_if
1903     <
1904         __is_val_expr<_Expr>::value,
1905         void
1906     >::type
1907     _LIBCPP_INLINE_VISIBILITY
1908     operator/=(const _Expr& __v) const;
1909
1910     template <class _Expr>
1911     typename enable_if
1912     <
1913         __is_val_expr<_Expr>::value,
1914         void
1915     >::type
1916     _LIBCPP_INLINE_VISIBILITY
1917     operator%=(const _Expr& __v) const;
1918
1919     template <class _Expr>
1920     typename enable_if
1921     <
1922         __is_val_expr<_Expr>::value,
1923         void
1924     >::type
1925     _LIBCPP_INLINE_VISIBILITY
1926     operator+=(const _Expr& __v) const;
1927
1928     template <class _Expr>
1929     typename enable_if
1930     <
1931         __is_val_expr<_Expr>::value,
1932         void
1933     >::type
1934     _LIBCPP_INLINE_VISIBILITY
1935     operator-=(const _Expr& __v) const;
1936
1937     template <class _Expr>
1938     typename enable_if
1939     <
1940         __is_val_expr<_Expr>::value,
1941         void
1942     >::type
1943     _LIBCPP_INLINE_VISIBILITY
1944     operator^=(const _Expr& __v) const;
1945
1946     template <class _Expr>
1947     typename enable_if
1948     <
1949         __is_val_expr<_Expr>::value,
1950         void
1951     >::type
1952     _LIBCPP_INLINE_VISIBILITY
1953     operator&=(const _Expr& __v) const;
1954
1955     template <class _Expr>
1956     typename enable_if
1957     <
1958         __is_val_expr<_Expr>::value,
1959         void
1960     >::type
1961     _LIBCPP_INLINE_VISIBILITY
1962     operator|=(const _Expr& __v) const;
1963
1964     template <class _Expr>
1965     typename enable_if
1966     <
1967         __is_val_expr<_Expr>::value,
1968         void
1969     >::type
1970     _LIBCPP_INLINE_VISIBILITY
1971     operator<<=(const _Expr& __v) const;
1972
1973     template <class _Expr>
1974     typename enable_if
1975     <
1976         __is_val_expr<_Expr>::value,
1977         void
1978     >::type
1979     _LIBCPP_INLINE_VISIBILITY
1980     operator>>=(const _Expr& __v) const;
1981
1982     _LIBCPP_INLINE_VISIBILITY
1983     const mask_array& operator=(const mask_array& __ma) const;
1984
1985     _LIBCPP_INLINE_VISIBILITY
1986     void operator=(const value_type& __x) const;
1987
1988 //  mask_array(const mask_array&)            = default;
1989 //  mask_array(mask_array&&)                 = default;
1990 //  mask_array& operator=(const mask_array&) = default;
1991 //  mask_array& operator=(mask_array&&)      = default;
1992
1993 private:
1994     _LIBCPP_INLINE_VISIBILITY
1995     mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v)
1996         : __vp_(const_cast<value_type*>(__v.__begin_)),
1997           __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true)))
1998           {
1999               size_t __j = 0;
2000               for (size_t __i = 0; __i < __vb.size(); ++__i)
2001                   if (__vb[__i])
2002                       __1d_[__j++] = __i;
2003           }
2004
2005     template <class> friend class valarray;
2006 };
2007
2008 template <class _Tp>
2009 template <class _Expr>
2010 inline
2011 typename enable_if
2012 <
2013     __is_val_expr<_Expr>::value,
2014     void
2015 >::type
2016 mask_array<_Tp>::operator=(const _Expr& __v) const
2017 {
2018     size_t __n = __1d_.size();
2019     for (size_t __i = 0; __i < __n; ++__i)
2020         __vp_[__1d_[__i]] = __v[__i];
2021 }
2022
2023 template <class _Tp>
2024 template <class _Expr>
2025 inline
2026 typename enable_if
2027 <
2028     __is_val_expr<_Expr>::value,
2029     void
2030 >::type
2031 mask_array<_Tp>::operator*=(const _Expr& __v) const
2032 {
2033     size_t __n = __1d_.size();
2034     for (size_t __i = 0; __i < __n; ++__i)
2035         __vp_[__1d_[__i]] *= __v[__i];
2036 }
2037
2038 template <class _Tp>
2039 template <class _Expr>
2040 inline
2041 typename enable_if
2042 <
2043     __is_val_expr<_Expr>::value,
2044     void
2045 >::type
2046 mask_array<_Tp>::operator/=(const _Expr& __v) const
2047 {
2048     size_t __n = __1d_.size();
2049     for (size_t __i = 0; __i < __n; ++__i)
2050         __vp_[__1d_[__i]] /= __v[__i];
2051 }
2052
2053 template <class _Tp>
2054 template <class _Expr>
2055 inline
2056 typename enable_if
2057 <
2058     __is_val_expr<_Expr>::value,
2059     void
2060 >::type
2061 mask_array<_Tp>::operator%=(const _Expr& __v) const
2062 {
2063     size_t __n = __1d_.size();
2064     for (size_t __i = 0; __i < __n; ++__i)
2065         __vp_[__1d_[__i]] %= __v[__i];
2066 }
2067
2068 template <class _Tp>
2069 template <class _Expr>
2070 inline
2071 typename enable_if
2072 <
2073     __is_val_expr<_Expr>::value,
2074     void
2075 >::type
2076 mask_array<_Tp>::operator+=(const _Expr& __v) const
2077 {
2078     size_t __n = __1d_.size();
2079     for (size_t __i = 0; __i < __n; ++__i)
2080         __vp_[__1d_[__i]] += __v[__i];
2081 }
2082
2083 template <class _Tp>
2084 template <class _Expr>
2085 inline
2086 typename enable_if
2087 <
2088     __is_val_expr<_Expr>::value,
2089     void
2090 >::type
2091 mask_array<_Tp>::operator-=(const _Expr& __v) const
2092 {
2093     size_t __n = __1d_.size();
2094     for (size_t __i = 0; __i < __n; ++__i)
2095         __vp_[__1d_[__i]] -= __v[__i];
2096 }
2097
2098 template <class _Tp>
2099 template <class _Expr>
2100 inline
2101 typename enable_if
2102 <
2103     __is_val_expr<_Expr>::value,
2104     void
2105 >::type
2106 mask_array<_Tp>::operator^=(const _Expr& __v) const
2107 {
2108     size_t __n = __1d_.size();
2109     for (size_t __i = 0; __i < __n; ++__i)
2110         __vp_[__1d_[__i]] ^= __v[__i];
2111 }
2112
2113 template <class _Tp>
2114 template <class _Expr>
2115 inline
2116 typename enable_if
2117 <
2118     __is_val_expr<_Expr>::value,
2119     void
2120 >::type
2121 mask_array<_Tp>::operator&=(const _Expr& __v) const
2122 {
2123     size_t __n = __1d_.size();
2124     for (size_t __i = 0; __i < __n; ++__i)
2125         __vp_[__1d_[__i]] &= __v[__i];
2126 }
2127
2128 template <class _Tp>
2129 template <class _Expr>
2130 inline
2131 typename enable_if
2132 <
2133     __is_val_expr<_Expr>::value,
2134     void
2135 >::type
2136 mask_array<_Tp>::operator|=(const _Expr& __v) const
2137 {
2138     size_t __n = __1d_.size();
2139     for (size_t __i = 0; __i < __n; ++__i)
2140         __vp_[__1d_[__i]] |= __v[__i];
2141 }
2142
2143 template <class _Tp>
2144 template <class _Expr>
2145 inline
2146 typename enable_if
2147 <
2148     __is_val_expr<_Expr>::value,
2149     void
2150 >::type
2151 mask_array<_Tp>::operator<<=(const _Expr& __v) const
2152 {
2153     size_t __n = __1d_.size();
2154     for (size_t __i = 0; __i < __n; ++__i)
2155         __vp_[__1d_[__i]] <<= __v[__i];
2156 }
2157
2158 template <class _Tp>
2159 template <class _Expr>
2160 inline
2161 typename enable_if
2162 <
2163     __is_val_expr<_Expr>::value,
2164     void
2165 >::type
2166 mask_array<_Tp>::operator>>=(const _Expr& __v) const
2167 {
2168     size_t __n = __1d_.size();
2169     for (size_t __i = 0; __i < __n; ++__i)
2170         __vp_[__1d_[__i]] >>= __v[__i];
2171 }
2172
2173 template <class _Tp>
2174 inline
2175 const mask_array<_Tp>&
2176 mask_array<_Tp>::operator=(const mask_array& __ma) const
2177 {
2178     size_t __n = __1d_.size();
2179     for (size_t __i = 0; __i < __n; ++__i)
2180         __vp_[__1d_[__i]] = __ma.__vp_[__1d_[__i]];
2181     return *this;
2182 }
2183
2184 template <class _Tp>
2185 inline
2186 void
2187 mask_array<_Tp>::operator=(const value_type& __x) const
2188 {
2189     size_t __n = __1d_.size();
2190     for (size_t __i = 0; __i < __n; ++__i)
2191         __vp_[__1d_[__i]] = __x;
2192 }
2193
2194 template <class _ValExpr>
2195 class __mask_expr
2196 {
2197     typedef typename remove_reference<_ValExpr>::type  _RmExpr;
2198 public:
2199     typedef typename _RmExpr::value_type value_type;
2200     typedef value_type result_type;
2201
2202 private:
2203     _ValExpr __expr_;
2204     valarray<size_t> __1d_;
2205
2206     _LIBCPP_INLINE_VISIBILITY
2207     __mask_expr(const valarray<bool>& __vb, const _RmExpr& __e)
2208         : __expr_(__e),
2209           __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true)))
2210           {
2211               size_t __j = 0;
2212               for (size_t __i = 0; __i < __vb.size(); ++__i)
2213                   if (__vb[__i])
2214                       __1d_[__j++] = __i;
2215           }
2216
2217 public:
2218     _LIBCPP_INLINE_VISIBILITY
2219     result_type operator[](size_t __i) const
2220         {return __expr_[__1d_[__i]];}
2221
2222     _LIBCPP_INLINE_VISIBILITY
2223     size_t size() const {return __1d_.size();}
2224
2225     template <class> friend class valarray;
2226 };
2227
2228 // indirect_array
2229
2230 template <class _Tp>
2231 class _LIBCPP_TEMPLATE_VIS indirect_array
2232 {
2233 public:
2234     typedef _Tp value_type;
2235
2236 private:
2237     value_type*      __vp_;
2238     valarray<size_t> __1d_;
2239
2240 public:
2241     template <class _Expr>
2242     typename enable_if
2243     <
2244         __is_val_expr<_Expr>::value,
2245         void
2246     >::type
2247     _LIBCPP_INLINE_VISIBILITY
2248     operator=(const _Expr& __v) const;
2249
2250     template <class _Expr>
2251     typename enable_if
2252     <
2253         __is_val_expr<_Expr>::value,
2254         void
2255     >::type
2256     _LIBCPP_INLINE_VISIBILITY
2257     operator*=(const _Expr& __v) const;
2258
2259     template <class _Expr>
2260     typename enable_if
2261     <
2262         __is_val_expr<_Expr>::value,
2263         void
2264     >::type
2265     _LIBCPP_INLINE_VISIBILITY
2266     operator/=(const _Expr& __v) const;
2267
2268     template <class _Expr>
2269     typename enable_if
2270     <
2271         __is_val_expr<_Expr>::value,
2272         void
2273     >::type
2274     _LIBCPP_INLINE_VISIBILITY
2275     operator%=(const _Expr& __v) const;
2276
2277     template <class _Expr>
2278     typename enable_if
2279     <
2280         __is_val_expr<_Expr>::value,
2281         void
2282     >::type
2283     _LIBCPP_INLINE_VISIBILITY
2284     operator+=(const _Expr& __v) const;
2285
2286     template <class _Expr>
2287     typename enable_if
2288     <
2289         __is_val_expr<_Expr>::value,
2290         void
2291     >::type
2292     _LIBCPP_INLINE_VISIBILITY
2293     operator-=(const _Expr& __v) const;
2294
2295     template <class _Expr>
2296     typename enable_if
2297     <
2298         __is_val_expr<_Expr>::value,
2299         void
2300     >::type
2301     _LIBCPP_INLINE_VISIBILITY
2302     operator^=(const _Expr& __v) const;
2303
2304     template <class _Expr>
2305     typename enable_if
2306     <
2307         __is_val_expr<_Expr>::value,
2308         void
2309     >::type
2310     _LIBCPP_INLINE_VISIBILITY
2311     operator&=(const _Expr& __v) const;
2312
2313     template <class _Expr>
2314     typename enable_if
2315     <
2316         __is_val_expr<_Expr>::value,
2317         void
2318     >::type
2319     _LIBCPP_INLINE_VISIBILITY
2320     operator|=(const _Expr& __v) const;
2321
2322     template <class _Expr>
2323     typename enable_if
2324     <
2325         __is_val_expr<_Expr>::value,
2326         void
2327     >::type
2328     _LIBCPP_INLINE_VISIBILITY
2329     operator<<=(const _Expr& __v) const;
2330
2331     template <class _Expr>
2332     typename enable_if
2333     <
2334         __is_val_expr<_Expr>::value,
2335         void
2336     >::type
2337     _LIBCPP_INLINE_VISIBILITY
2338     operator>>=(const _Expr& __v) const;
2339
2340     _LIBCPP_INLINE_VISIBILITY
2341     const indirect_array& operator=(const indirect_array& __ia) const;
2342
2343     _LIBCPP_INLINE_VISIBILITY
2344     void operator=(const value_type& __x) const;
2345
2346 //  indirect_array(const indirect_array&)            = default;
2347 //  indirect_array(indirect_array&&)                 = default;
2348 //  indirect_array& operator=(const indirect_array&) = default;
2349 //  indirect_array& operator=(indirect_array&&)      = default;
2350
2351 private:
2352      _LIBCPP_INLINE_VISIBILITY
2353    indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v)
2354         : __vp_(const_cast<value_type*>(__v.__begin_)),
2355           __1d_(__ia)
2356         {}
2357
2358 #ifndef _LIBCPP_CXX03_LANG
2359
2360     _LIBCPP_INLINE_VISIBILITY
2361     indirect_array(valarray<size_t>&& __ia, const valarray<value_type>& __v)
2362         : __vp_(const_cast<value_type*>(__v.__begin_)),
2363           __1d_(move(__ia))
2364         {}
2365
2366 #endif  // _LIBCPP_CXX03_LANG
2367
2368     template <class> friend class valarray;
2369 };
2370
2371 template <class _Tp>
2372 template <class _Expr>
2373 inline
2374 typename enable_if
2375 <
2376     __is_val_expr<_Expr>::value,
2377     void
2378 >::type
2379 indirect_array<_Tp>::operator=(const _Expr& __v) const
2380 {
2381     size_t __n = __1d_.size();
2382     for (size_t __i = 0; __i < __n; ++__i)
2383         __vp_[__1d_[__i]] = __v[__i];
2384 }
2385
2386 template <class _Tp>
2387 template <class _Expr>
2388 inline
2389 typename enable_if
2390 <
2391     __is_val_expr<_Expr>::value,
2392     void
2393 >::type
2394 indirect_array<_Tp>::operator*=(const _Expr& __v) const
2395 {
2396     size_t __n = __1d_.size();
2397     for (size_t __i = 0; __i < __n; ++__i)
2398         __vp_[__1d_[__i]] *= __v[__i];
2399 }
2400
2401 template <class _Tp>
2402 template <class _Expr>
2403 inline
2404 typename enable_if
2405 <
2406     __is_val_expr<_Expr>::value,
2407     void
2408 >::type
2409 indirect_array<_Tp>::operator/=(const _Expr& __v) const
2410 {
2411     size_t __n = __1d_.size();
2412     for (size_t __i = 0; __i < __n; ++__i)
2413         __vp_[__1d_[__i]] /= __v[__i];
2414 }
2415
2416 template <class _Tp>
2417 template <class _Expr>
2418 inline
2419 typename enable_if
2420 <
2421     __is_val_expr<_Expr>::value,
2422     void
2423 >::type
2424 indirect_array<_Tp>::operator%=(const _Expr& __v) const
2425 {
2426     size_t __n = __1d_.size();
2427     for (size_t __i = 0; __i < __n; ++__i)
2428         __vp_[__1d_[__i]] %= __v[__i];
2429 }
2430
2431 template <class _Tp>
2432 template <class _Expr>
2433 inline
2434 typename enable_if
2435 <
2436     __is_val_expr<_Expr>::value,
2437     void
2438 >::type
2439 indirect_array<_Tp>::operator+=(const _Expr& __v) const
2440 {
2441     size_t __n = __1d_.size();
2442     for (size_t __i = 0; __i < __n; ++__i)
2443         __vp_[__1d_[__i]] += __v[__i];
2444 }
2445
2446 template <class _Tp>
2447 template <class _Expr>
2448 inline
2449 typename enable_if
2450 <
2451     __is_val_expr<_Expr>::value,
2452     void
2453 >::type
2454 indirect_array<_Tp>::operator-=(const _Expr& __v) const
2455 {
2456     size_t __n = __1d_.size();
2457     for (size_t __i = 0; __i < __n; ++__i)
2458         __vp_[__1d_[__i]] -= __v[__i];
2459 }
2460
2461 template <class _Tp>
2462 template <class _Expr>
2463 inline
2464 typename enable_if
2465 <
2466     __is_val_expr<_Expr>::value,
2467     void
2468 >::type
2469 indirect_array<_Tp>::operator^=(const _Expr& __v) const
2470 {
2471     size_t __n = __1d_.size();
2472     for (size_t __i = 0; __i < __n; ++__i)
2473         __vp_[__1d_[__i]] ^= __v[__i];
2474 }
2475
2476 template <class _Tp>
2477 template <class _Expr>
2478 inline
2479 typename enable_if
2480 <
2481     __is_val_expr<_Expr>::value,
2482     void
2483 >::type
2484 indirect_array<_Tp>::operator&=(const _Expr& __v) const
2485 {
2486     size_t __n = __1d_.size();
2487     for (size_t __i = 0; __i < __n; ++__i)
2488         __vp_[__1d_[__i]] &= __v[__i];
2489 }
2490
2491 template <class _Tp>
2492 template <class _Expr>
2493 inline
2494 typename enable_if
2495 <
2496     __is_val_expr<_Expr>::value,
2497     void
2498 >::type
2499 indirect_array<_Tp>::operator|=(const _Expr& __v) const
2500 {
2501     size_t __n = __1d_.size();
2502     for (size_t __i = 0; __i < __n; ++__i)
2503         __vp_[__1d_[__i]] |= __v[__i];
2504 }
2505
2506 template <class _Tp>
2507 template <class _Expr>
2508 inline
2509 typename enable_if
2510 <
2511     __is_val_expr<_Expr>::value,
2512     void
2513 >::type
2514 indirect_array<_Tp>::operator<<=(const _Expr& __v) const
2515 {
2516     size_t __n = __1d_.size();
2517     for (size_t __i = 0; __i < __n; ++__i)
2518         __vp_[__1d_[__i]] <<= __v[__i];
2519 }
2520
2521 template <class _Tp>
2522 template <class _Expr>
2523 inline
2524 typename enable_if
2525 <
2526     __is_val_expr<_Expr>::value,
2527     void
2528 >::type
2529 indirect_array<_Tp>::operator>>=(const _Expr& __v) const
2530 {
2531     size_t __n = __1d_.size();
2532     for (size_t __i = 0; __i < __n; ++__i)
2533         __vp_[__1d_[__i]] >>= __v[__i];
2534 }
2535
2536 template <class _Tp>
2537 inline
2538 const indirect_array<_Tp>&
2539 indirect_array<_Tp>::operator=(const indirect_array& __ia) const
2540 {
2541     typedef const size_t* _Ip;
2542     const value_type* __s = __ia.__vp_;
2543     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ia.__1d_.__begin_;
2544             __i != __e; ++__i, ++__j)
2545         __vp_[*__i] = __s[*__j];
2546     return *this;
2547 }
2548
2549 template <class _Tp>
2550 inline
2551 void
2552 indirect_array<_Tp>::operator=(const value_type& __x) const
2553 {
2554     typedef const size_t* _Ip;
2555     for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
2556         __vp_[*__i] = __x;
2557 }
2558
2559 template <class _ValExpr>
2560 class __indirect_expr
2561 {
2562     typedef typename remove_reference<_ValExpr>::type  _RmExpr;
2563 public:
2564     typedef typename _RmExpr::value_type value_type;
2565     typedef value_type result_type;
2566
2567 private:
2568     _ValExpr __expr_;
2569     valarray<size_t> __1d_;
2570
2571     _LIBCPP_INLINE_VISIBILITY
2572     __indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e)
2573         : __expr_(__e),
2574           __1d_(__ia)
2575           {}
2576
2577 #ifndef _LIBCPP_CXX03_LANG
2578
2579     _LIBCPP_INLINE_VISIBILITY
2580     __indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e)
2581         : __expr_(__e),
2582           __1d_(move(__ia))
2583           {}
2584
2585 #endif  // _LIBCPP_CXX03_LANG
2586
2587 public:
2588     _LIBCPP_INLINE_VISIBILITY
2589     result_type operator[](size_t __i) const
2590         {return __expr_[__1d_[__i]];}
2591
2592     _LIBCPP_INLINE_VISIBILITY
2593     size_t size() const {return __1d_.size();}
2594
2595     template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
2596 };
2597
2598 template<class _ValExpr>
2599 class __val_expr
2600 {
2601     typedef typename remove_reference<_ValExpr>::type  _RmExpr;
2602
2603     _ValExpr __expr_;
2604 public:
2605     typedef typename _RmExpr::value_type value_type;
2606     typedef typename _RmExpr::result_type result_type;
2607
2608     _LIBCPP_INLINE_VISIBILITY
2609     explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {}
2610
2611     _LIBCPP_INLINE_VISIBILITY
2612     result_type operator[](size_t __i) const
2613         {return __expr_[__i];}
2614
2615     _LIBCPP_INLINE_VISIBILITY
2616     __val_expr<__slice_expr<_ValExpr> > operator[](slice __s) const
2617         {return __val_expr<__slice_expr<_ValExpr> >(__expr_, __s);}
2618
2619     _LIBCPP_INLINE_VISIBILITY
2620     __val_expr<__indirect_expr<_ValExpr> > operator[](const gslice& __gs) const
2621         {return __val_expr<__indirect_expr<_ValExpr> >(__expr_, __gs.__1d_);}
2622
2623     _LIBCPP_INLINE_VISIBILITY
2624     __val_expr<__mask_expr<_ValExpr> > operator[](const valarray<bool>& __vb) const
2625         {return __val_expr<__mask_expr<_ValExpr> >(__expr_, __vb);}
2626
2627     _LIBCPP_INLINE_VISIBILITY
2628     __val_expr<__indirect_expr<_ValExpr> > operator[](const valarray<size_t>& __vs) const
2629         {return __val_expr<__indirect_expr<_ValExpr> >(__expr_, __vs);}
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