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