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