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